fastly_sys/

lib.rs

// TODO ACF 2020-12-01: remove once this is fixed: https://github.com/rust-lang/rust/issues/79581
#![allow(clashing_extern_declarations)]

//! FFI bindings to the Fastly Compute ABI.
//!
//! This is a low-level package; the [`fastly`](https://docs.rs/fastly) crate wraps these functions
//! in a much friendlier, Rust-like interface. You should not have to depend on this crate
//! explicitly in your `Cargo.toml`.
//!
//! # Versioning and compatibility
//!
//! The Cargo version of this package was previously set according to compatibility with the
//! Compute platform. Since the [`v0.25.0` release of the Fastly
//! CLI](https://github.com/fastly/cli/releases/tag/v0.25.0), the CLI is configured with the range
//! of `fastly-sys` versions that are currently compatible with the Compute platform. The Cargo
//! version of this package since `0.4.0` instead follows the [Cargo SemVer compatibility
//! guidelines](https://doc.rust-lang.org/cargo/reference/semver.html).
use fastly_shared::FastlyStatus;

pub mod fastly_cache;
pub mod fastly_config_store;
pub mod fastly_http_cache;

// The following type aliases are used for readability of definitions in this module. They should
// not be confused with types of similar names in the `fastly` crate which are used to provide safe
// wrappers around these definitions.

pub type AclHandle = u32;
pub type AsyncItemHandle = u32;
pub type BodyHandle = u32;
pub type DictionaryHandle = u32;
pub type KVStoreHandle = u32;
pub type PendingObjectStoreDeleteHandle = u32;
pub type PendingObjectStoreInsertHandle = u32;
pub type PendingObjectStoreListHandle = u32;
pub type PendingObjectStoreLookupHandle = u32;
pub type PendingRequestHandle = u32;
pub type RequestHandle = u32;
pub type RequestPromiseHandle = u32;
pub type ResponseHandle = u32;
pub type SecretHandle = u32;
pub type SecretStoreHandle = u32;

#[repr(C)]
pub struct DynamicBackendConfig {
    pub host_override: *const u8,
    pub host_override_len: u32,
    pub connect_timeout_ms: u32,
    pub first_byte_timeout_ms: u32,
    pub between_bytes_timeout_ms: u32,
    pub ssl_min_version: u32,
    pub ssl_max_version: u32,
    pub cert_hostname: *const u8,
    pub cert_hostname_len: u32,
    pub ca_cert: *const u8,
    pub ca_cert_len: u32,
    pub ciphers: *const u8,
    pub ciphers_len: u32,
    pub sni_hostname: *const u8,
    pub sni_hostname_len: u32,
    pub client_certificate: *const u8,
    pub client_certificate_len: u32,
    pub client_key: SecretHandle,
    pub http_keepalive_time_ms: u32,
    pub tcp_keepalive_enable: u32,
    pub tcp_keepalive_interval_secs: u32,
    pub tcp_keepalive_probes: u32,
    pub tcp_keepalive_time_secs: u32,
    pub max_connections: u32,
    pub max_use: u32,
    pub max_lifetime_ms: u32,
}

impl Default for DynamicBackendConfig {
    fn default() -> Self {
        DynamicBackendConfig {
            host_override: std::ptr::null(),
            host_override_len: 0,
            connect_timeout_ms: 0,
            first_byte_timeout_ms: 0,
            between_bytes_timeout_ms: 0,
            ssl_min_version: 0,
            ssl_max_version: 0,
            cert_hostname: std::ptr::null(),
            cert_hostname_len: 0,
            ca_cert: std::ptr::null(),
            ca_cert_len: 0,
            ciphers: std::ptr::null(),
            ciphers_len: 0,
            sni_hostname: std::ptr::null(),
            sni_hostname_len: 0,
            client_certificate: std::ptr::null(),
            client_certificate_len: 0,
            client_key: 0,
            http_keepalive_time_ms: 0,
            tcp_keepalive_enable: 0,
            tcp_keepalive_interval_secs: 0,
            tcp_keepalive_probes: 0,
            tcp_keepalive_time_secs: 0,
            max_connections: 0,
            max_use: 0,
            max_lifetime_ms: 0,
        }
    }
}

/// Selects the behavior for an insert when the new key matches an existing key.
///
/// A KV store maintains the property that its keys are unique from each other. If an insert
/// has a key that doesn't match any key already in the store, then the pair of the key and the
/// new value is inserted into the store. However, if the insert's key does match a key already
/// in the store, then no new key-value pair is inserted, and the insert's mode
/// determines what it does instead.
#[repr(C)]
#[derive(Default, Clone, Copy)]
pub enum InsertMode {
    /// Updates the existing key's value by overwriting it with the new value.
    ///
    /// This is the default mode.
    #[default]
    Overwrite,

    /// Fails, leaving the existing key's value unmodified.
    ///
    /// With this mode, the insert fails with a “precondition failed” error, and
    /// does not modify the existing value. Inserts with this mode will only “add” new key-value
    /// pairs; they are prevented from modifying any existing ones.
    Add,

    /// Updates the existing key's value by appending the new value to it.
    Append,

    /// Updates the existing key's value by prepending the new value to it.
    Prepend,
}

#[repr(C)]
pub struct InsertConfig {
    pub mode: InsertMode,
    pub unused: u32,
    pub metadata: *const u8,
    pub metadata_len: u32,
    pub time_to_live_sec: u32,
    pub if_generation_match: u64,
}

impl Default for InsertConfig {
    fn default() -> Self {
        InsertConfig {
            mode: InsertMode::Overwrite,
            unused: 0,
            metadata: std::ptr::null(),
            metadata_len: 0,
            time_to_live_sec: 0,
            if_generation_match: 0,
        }
    }
}

/// Modes of KV Store list operations.
///
/// This type serves to facilitate alternative methods of cache interactions with list operations.
#[repr(C)]
#[derive(Default, Clone)]
pub enum ListMode {
    /// The default method of listing. Performs an un-cached list on every invocation.
    #[default]
    Strong,
    /// Returns a cached list response to improve performance.
    ///
    /// The data may be slightly out of sync with the store, but repeated calls are faster.
    ///
    /// The word “eventual” here refers to eventual consistency.
    Eventual,
    /// Handles unexpected or unknown list modes returned by the upstream API.
    ///
    /// This variant is a catch-all and should not be constructed manually by SDK consumers.
    Other(String),
}

#[repr(C)]
#[derive(Default, Clone)]
pub enum ListModeInternal {
    #[default]
    Strong,
    Eventual,
}

#[repr(C)]
pub struct ListConfig {
    pub mode: ListModeInternal,
    pub cursor: *const u8,
    pub cursor_len: u32,
    pub limit: u32,
    pub prefix: *const u8,
    pub prefix_len: u32,
}

impl Default for ListConfig {
    fn default() -> Self {
        ListConfig {
            mode: ListModeInternal::Strong,
            cursor: std::ptr::null(),
            cursor_len: 0,
            limit: 0,
            prefix: std::ptr::null(),
            prefix_len: 0,
        }
    }
}

#[repr(C)]
#[derive(Default)]
pub struct LookupConfig {
    // reserved is just a placeholder,
    // can be removed when somethin real is added
    reserved: u32,
}

#[repr(C)]
#[derive(Default)]
pub struct DeleteConfig {
    // reserved is just a placeholder,
    // can be removed when somethin real is added
    reserved: u32,
}

bitflags::bitflags! {
    /// `Content-Encoding` codings.
    #[derive(Default)]
    #[repr(transparent)]
    pub struct ContentEncodings: u32 {
        const GZIP = 1 << 0;
    }
}

bitflags::bitflags! {
    /// `BackendConfigOptions` codings.
    #[derive(Default)]
    #[repr(transparent)]
    pub struct BackendConfigOptions: u32 {
        const RESERVED = 1 << 0;
        const HOST_OVERRIDE = 1 << 1;
        const CONNECT_TIMEOUT = 1 << 2;
        const FIRST_BYTE_TIMEOUT = 1 << 3;
        const BETWEEN_BYTES_TIMEOUT = 1 << 4;
        const USE_SSL = 1 << 5;
        const SSL_MIN_VERSION = 1 << 6;
        const SSL_MAX_VERSION = 1 << 7;
        const CERT_HOSTNAME = 1 << 8;
        const CA_CERT = 1 << 9;
        const CIPHERS = 1 << 10;
        const SNI_HOSTNAME = 1 << 11;
        const DONT_POOL = 1 << 12;
        const CLIENT_CERT = 1 << 13;
        const GRPC = 1 << 14;
        const KEEPALIVE = 1 << 15;
        const POOLING_LIMITS = 1 << 16;
        const PREFER_IPV4 = 1 << 17;
    }
    /// `InsertConfigOptions` codings.
    #[derive(Default)]
    #[repr(transparent)]
    pub struct InsertConfigOptions: u32 {
        const RESERVED = 1 << 0;
        const BACKGROUND_FETCH = 1 << 1;
        const RESERVED_2 = 1 << 2;
        const METADATA = 1 << 3;
        const TIME_TO_LIVE_SEC = 1 << 4;
        const IF_GENERATION_MATCH = 1 << 5;
    }
    /// `ListConfigOptions` codings.
    #[derive(Default)]
    #[repr(transparent)]
    pub struct ListConfigOptions: u32 {
        const RESERVED = 1 << 0;
        const CURSOR = 1 << 1;
        const LIMIT = 1 << 2;
        const PREFIX = 1 << 3;
    }
    /// `LookupConfigOptions` codings.
    #[derive(Default)]
    #[repr(transparent)]
    pub struct LookupConfigOptions: u32 {
        const RESERVED = 1 << 0;
    }
    /// `DeleteConfigOptions` codings.
    #[derive(Default)]
    #[repr(transparent)]
    pub struct DeleteConfigOptions: u32 {
        const RESERVED = 1 << 0;
    }
}

pub mod fastly_abi {
    use super::*;

    #[link(wasm_import_module = "fastly_abi")]
    extern "C" {
        #[link_name = "init"]
        /// Tell the runtime what ABI version this program is using (FASTLY_ABI_VERSION)
        pub fn init(abi_version: u64) -> FastlyStatus;
    }
}

#[deprecated(since = "0.11.6")]
pub mod fastly_uap {
    use super::*;

    #[link(wasm_import_module = "fastly_uap")]
    extern "C" {
        #[link_name = "parse"]
        pub fn parse(
            user_agent: *const u8,
            user_agent_max_len: usize,
            family: *mut u8,
            family_max_len: usize,
            family_written: *mut usize,
            major: *mut u8,
            major_max_len: usize,
            major_written: *mut usize,
            minor: *mut u8,
            minor_max_len: usize,
            minor_written: *mut usize,
            patch: *mut u8,
            patch_max_len: usize,
            patch_written: *mut usize,
        ) -> FastlyStatus;
    }
}

pub mod fastly_http_body {
    use super::*;

    #[link(wasm_import_module = "fastly_http_body")]
    extern "C" {
        #[link_name = "append"]
        pub fn append(dst_handle: BodyHandle, src_handle: BodyHandle) -> FastlyStatus;

        #[link_name = "new"]
        pub fn new(handle_out: *mut BodyHandle) -> FastlyStatus;

        #[link_name = "read"]
        pub fn read(
            body_handle: BodyHandle,
            buf: *mut u8,
            buf_len: usize,
            nread_out: *mut usize,
        ) -> FastlyStatus;

        // overeager warning for extern declarations is a rustc bug: https://github.com/rust-lang/rust/issues/79581
        #[allow(clashing_extern_declarations)]
        #[link_name = "write"]
        pub fn write(
            body_handle: BodyHandle,
            buf: *const u8,
            buf_len: usize,
            end: fastly_shared::BodyWriteEnd,
            nwritten_out: *mut usize,
        ) -> FastlyStatus;

        /// Close a body, freeing its resources and causing any sends to finish.
        #[link_name = "close"]
        pub fn close(body_handle: BodyHandle) -> FastlyStatus;

        /// Abandon a streaming body, freeing its resources and informing the peer that the stream
        /// is incomplete.
        #[link_name = "abandon"]
        pub fn abandon(body_handle: BodyHandle) -> FastlyStatus;

        #[link_name = "trailer_append"]
        pub fn trailer_append(
            body_handle: BodyHandle,
            name: *const u8,
            name_len: usize,
            value: *const u8,
            value_len: usize,
        ) -> FastlyStatus;

        #[link_name = "trailer_names_get"]
        pub fn trailer_names_get(
            body_handle: BodyHandle,
            buf: *mut u8,
            buf_len: usize,
            cursor: u32,
            ending_cursor: *mut i64,
            nwritten: *mut usize,
        ) -> FastlyStatus;

        #[link_name = "trailer_value_get"]
        pub fn trailer_value_get(
            body_handle: BodyHandle,
            name: *const u8,
            name_len: usize,
            value: *mut u8,
            value_max_len: usize,
            nwritten: *mut usize,
        ) -> FastlyStatus;

        #[link_name = "trailer_values_get"]
        pub fn trailer_values_get(
            body_handle: BodyHandle,
            name: *const u8,
            name_len: usize,
            buf: *mut u8,
            buf_len: usize,
            cursor: u32,
            ending_cursor: *mut i64,
            nwritten: *mut usize,
        ) -> FastlyStatus;

        #[link_name = "known_length"]
        pub fn known_length(body_handle: BodyHandle, length_out: *mut u64) -> FastlyStatus;
    }
}

pub mod fastly_log {
    use super::*;

    #[link(wasm_import_module = "fastly_log")]
    extern "C" {
        #[link_name = "endpoint_get"]
        pub fn endpoint_get(
            name: *const u8,
            name_len: usize,
            endpoint_handle_out: *mut u32,
        ) -> FastlyStatus;

        // overeager warning for extern declarations is a rustc bug: https://github.com/rust-lang/rust/issues/79581
        #[allow(clashing_extern_declarations)]
        #[link_name = "write"]
        pub fn write(
            endpoint_handle: u32,
            msg: *const u8,
            msg_len: usize,
            nwritten_out: *mut usize,
        ) -> FastlyStatus;

    }
}

pub mod fastly_http_downstream {
    use super::*;

    #[derive(Default)]
    #[repr(C)]
    pub struct NextRequestOptions {
        pub timeout_ms: u64,
    }

    bitflags::bitflags! {
        /// Request options.
        #[derive(Default)]
        #[repr(transparent)]
        pub struct NextRequestOptionsMask: u32 {
            const RESERVED = 1 << 0;
            const TIMEOUT = 1 << 1;
        }
    }

    #[link(wasm_import_module = "fastly_http_downstream")]
    extern "C" {
        #[link_name = "next_request"]
        pub fn next_request(
            options_mask: NextRequestOptionsMask,
            options: *const NextRequestOptions,
            handle_out: *mut RequestPromiseHandle,
        ) -> FastlyStatus;

        #[link_name = "next_request_wait"]
        pub fn next_request_wait(
            handle: RequestPromiseHandle,
            req_handle_out: *mut RequestHandle,
            body_handle_out: *mut BodyHandle,
        ) -> FastlyStatus;

        #[link_name = "next_request_abandon"]
        pub fn next_request_abandon(handle: RequestPromiseHandle) -> FastlyStatus;

        #[link_name = "downstream_original_header_names"]
        pub fn downstream_original_header_names(
            req_handle: RequestHandle,
            buf: *mut u8,
            buf_len: usize,
            cursor: u32,
            ending_cursor: *mut i64,
            nwritten: *mut usize,
        ) -> FastlyStatus;

        #[link_name = "downstream_original_header_count"]
        pub fn downstream_original_header_count(
            req_handle: RequestHandle,
            count_out: *mut u32,
        ) -> FastlyStatus;

        #[link_name = "downstream_client_ip_addr"]
        pub fn downstream_client_ip_addr(
            req_handle: RequestHandle,
            addr_octets_out: *mut u8,
            nwritten_out: *mut usize,
        ) -> FastlyStatus;

        #[link_name = "downstream_server_ip_addr"]
        pub fn downstream_server_ip_addr(
            req_handle: RequestHandle,
            addr_octets_out: *mut u8,
            nwritten_out: *mut usize,
        ) -> FastlyStatus;

        #[link_name = "downstream_client_h2_fingerprint"]
        pub fn downstream_client_h2_fingerprint(
            req_handle: RequestHandle,
            h2fp_out: *mut u8,
            h2fp_max_len: usize,
            nwritten: *mut usize,
        ) -> FastlyStatus;

        #[link_name = "downstream_client_request_id"]
        pub fn downstream_client_request_id(
            req_handle: RequestHandle,
            reqid_out: *mut u8,
            reqid_max_len: usize,
            nwritten: *mut usize,
        ) -> FastlyStatus;

        #[link_name = "downstream_client_oh_fingerprint"]
        pub fn downstream_client_oh_fingerprint(
            req_handle: RequestHandle,
            ohfp_out: *mut u8,
            ohfp_max_len: usize,
            nwritten: *mut usize,
        ) -> FastlyStatus;

        #[link_name = "downstream_client_ddos_detected"]
        pub fn downstream_client_ddos_detected(
            req_handle: RequestHandle,
            ddos_detected_out: *mut u32,
        ) -> FastlyStatus;

        #[link_name = "downstream_tls_cipher_openssl_name"]
        pub fn downstream_tls_cipher_openssl_name(
            req_handle: RequestHandle,
            cipher_out: *mut u8,
            cipher_max_len: usize,
            nwritten: *mut usize,
        ) -> FastlyStatus;

        #[link_name = "downstream_tls_protocol"]
        pub fn downstream_tls_protocol(
            req_handle: RequestHandle,
            protocol_out: *mut u8,
            protocol_max_len: usize,
            nwritten: *mut usize,
        ) -> FastlyStatus;

        #[link_name = "downstream_tls_client_hello"]
        pub fn downstream_tls_client_hello(
            req_handle: RequestHandle,
            client_hello_out: *mut u8,
            client_hello_max_len: usize,
            nwritten: *mut usize,
        ) -> FastlyStatus;

        #[link_name = "downstream_tls_client_servername"]
        pub fn downstream_tls_client_servername(
            req_handle: RequestHandle,
            sni_out: *mut u8,
            sni_max_len: usize,
            nwritten: *mut usize,
        ) -> FastlyStatus;

        #[link_name = "downstream_tls_ja3_md5"]
        pub fn downstream_tls_ja3_md5(
            req_handle: RequestHandle,
            ja3_md5_out: *mut u8,
            nwritten_out: *mut usize,
        ) -> FastlyStatus;

        #[link_name = "downstream_tls_ja4"]
        pub fn downstream_tls_ja4(
            req_handle: RequestHandle,
            ja4_out: *mut u8,
            ja4_max_len: usize,
            nwritten: *mut usize,
        ) -> FastlyStatus;

        #[link_name = "downstream_compliance_region"]
        pub fn downstream_compliance_region(
            req_handle: RequestHandle,
            region_out: *mut u8,
            region_max_len: usize,
            nwritten: *mut usize,
        ) -> FastlyStatus;

        #[link_name = "downstream_tls_raw_client_certificate"]
        pub fn downstream_tls_raw_client_certificate(
            req_handle: RequestHandle,
            client_hello_out: *mut u8,
            client_hello_max_len: usize,
            nwritten: *mut usize,
        ) -> FastlyStatus;

        #[link_name = "downstream_tls_client_cert_verify_result"]
        pub fn downstream_tls_client_cert_verify_result(
            req_handle: RequestHandle,
            verify_result_out: *mut u32,
        ) -> FastlyStatus;

        #[link_name = "fastly_key_is_valid"]
        pub fn fastly_key_is_valid(
            req_handle: RequestHandle,
            is_valid_out: *mut u32,
        ) -> FastlyStatus;

        #[link_name = "downstream_bot_analyzed"]
        pub fn downstream_bot_analyzed(
            req_handle: RequestHandle,
            bot_analyzed_out: *mut u32,
        ) -> FastlyStatus;

        #[link_name = "downstream_bot_detected"]
        pub fn downstream_bot_detected(
            req_handle: RequestHandle,
            bot_detected_out: *mut u32,
        ) -> FastlyStatus;

        #[link_name = "downstream_bot_name"]
        pub fn downstream_bot_name(
            req_handle: RequestHandle,
            bot_name_out: *mut u8,
            bot_name_max_len: usize,
            nwritten: *mut usize,
        ) -> FastlyStatus;

        #[link_name = "downstream_bot_category"]
        pub fn downstream_bot_category(
            req_handle: RequestHandle,
            bot_category_out: *mut u8,
            bot_category_max_len: usize,
            nwritten: *mut usize,
        ) -> FastlyStatus;

        #[link_name = "downstream_bot_category_kind"]
        pub fn downstream_bot_category_kind(
            req_handle: RequestHandle,
            bot_category_kind_out: *mut u32,
        ) -> FastlyStatus;

        #[link_name = "downstream_bot_verified"]
        pub fn downstream_bot_verified(
            req_handle: RequestHandle,
            bot_verified_out: *mut u32,
        ) -> FastlyStatus;
    }
}

pub mod fastly_http_req {
    use super::*;

    bitflags::bitflags! {
        #[derive(Default)]
        #[repr(transparent)]
        pub struct SendErrorDetailMask: u32 {
            const RESERVED = 1 << 0;
            const DNS_ERROR_RCODE = 1 << 1;
            const DNS_ERROR_INFO_CODE = 1 << 2;
            const TLS_ALERT_ID = 1 << 3;
            const H2_ERROR = 1 << 4;
        }
    }

    /// What types of responses to a `PendingRequestHandle` a queued operation
    /// should apply to.
    #[repr(u32)]
    #[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
    pub enum PendingResponseKind {
        /// Apply the change to any response, regardless of whether it's a real one
        /// or a synthetic response generated after a request error.
        #[default]
        Any = 0,

        /// Only apply the change to an actual response, and skip synthetic responses.  
        Response = 1,

        /// Only apply the change to a synthetic error response, and skip real responses.
        Error = 2,
    }

    #[repr(u32)]
    #[derive(Clone, Copy, Debug, PartialEq, Eq)]
    #[non_exhaustive]
    pub enum SendErrorDetailTag {
        Uninitialized,
        Ok,
        DnsTimeout,
        DnsError,
        DestinationNotFound,
        DestinationUnavailable,
        DestinationIpUnroutable,
        ConnectionRefused,
        ConnectionTerminated,
        ConnectionTimeout,
        ConnectionLimitReached,
        TlsCertificateError,
        TlsConfigurationError,
        HttpIncompleteResponse,
        HttpResponseHeaderSectionTooLarge,
        HttpResponseBodyTooLarge,
        HttpResponseTimeout,
        HttpResponseStatusInvalid,
        HttpUpgradeFailed,
        HttpProtocolError,
        HttpRequestCacheKeyInvalid,
        HttpRequestUriInvalid,
        InternalError,
        TlsAlertReceived,
        TlsProtocolError,
        H2Error,
    }

    #[repr(C)]
    #[derive(Clone, Debug, PartialEq, Eq)]
    #[non_exhaustive]
    pub struct SendErrorDetail {
        pub tag: SendErrorDetailTag,
        pub mask: SendErrorDetailMask,
        pub dns_error_rcode: u16,
        pub dns_error_info_code: u16,
        pub tls_alert_id: u8,
        pub h2_error_frame: u8,
        pub h2_error_code: u32,
    }

    impl SendErrorDetail {
        pub fn uninitialized_all() -> Self {
            Self {
                tag: SendErrorDetailTag::Uninitialized,
                mask: SendErrorDetailMask::all(),
                dns_error_rcode: Default::default(),
                dns_error_info_code: Default::default(),
                tls_alert_id: Default::default(),
                h2_error_frame: Default::default(),
                h2_error_code: Default::default(),
            }
        }
    }

    bitflags::bitflags! {
        #[repr(transparent)]
        pub struct InspectInfoMask: u32 {
            const RESERVED = 1 << 0;
            const CORP = 1 << 1;
            const WORKSPACE = 1 << 2;
            const OVERRIDE_CLIENT_IP = 1 << 3;
        }
    }

    #[repr(C)]
    pub struct InspectInfo {
        pub corp: *const u8,
        pub corp_len: u32,
        pub workspace: *const u8,
        pub workspace_len: u32,
        pub override_client_ip_ptr: *const u8,
        pub override_client_ip_len: u32,
    }

    impl Default for InspectInfo {
        fn default() -> Self {
            InspectInfo {
                corp: std::ptr::null(),
                corp_len: 0,
                workspace: std::ptr::null(),
                workspace_len: 0,
                override_client_ip_ptr: std::ptr::null(),
                override_client_ip_len: 0,
            }
        }
    }

    #[link(wasm_import_module = "fastly_http_req")]
    extern "C" {
        #[link_name = "body_downstream_get"]
        pub fn body_downstream_get(
            req_handle_out: *mut RequestHandle,
            body_handle_out: *mut BodyHandle,
        ) -> FastlyStatus;

        #[link_name = "cache_override_set"]
        pub fn cache_override_set(
            req_handle: RequestHandle,
            tag: u32,
            ttl: u32,
            swr: u32,
        ) -> FastlyStatus;

        #[link_name = "cache_override_v2_set"]
        pub fn cache_override_v2_set(
            req_handle: RequestHandle,
            tag: u32,
            ttl: u32,
            swr: u32,
            sk: *const u8,
            sk_len: usize,
        ) -> FastlyStatus;

        #[link_name = "framing_headers_mode_set"]
        pub fn framing_headers_mode_set(
            req_handle: RequestHandle,
            mode: fastly_shared::FramingHeadersMode,
        ) -> FastlyStatus;

        #[deprecated(since = "0.12.0", note = "kept for backward compatibility")]
        #[link_name = "downstream_client_ip_addr"]
        pub fn downstream_client_ip_addr(
            addr_octets_out: *mut u8,
            nwritten_out: *mut usize,
        ) -> FastlyStatus;

        #[deprecated(since = "0.12.0", note = "kept for backward compatibility")]
        #[link_name = "downstream_server_ip_addr"]
        pub fn downstream_server_ip_addr(
            addr_octets_out: *mut u8,
            nwritten_out: *mut usize,
        ) -> FastlyStatus;

        #[deprecated(since = "0.12.0", note = "kept for backward compatibility")]
        #[link_name = "downstream_client_h2_fingerprint"]
        pub fn downstream_client_h2_fingerprint(
            h2fp_out: *mut u8,
            h2fp_max_len: usize,
            nwritten: *mut usize,
        ) -> FastlyStatus;

        #[deprecated(since = "0.12.0", note = "kept for backward compatibility")]
        #[link_name = "downstream_client_request_id"]
        pub fn downstream_client_request_id(
            reqid_out: *mut u8,
            reqid_max_len: usize,
            nwritten: *mut usize,
        ) -> FastlyStatus;

        #[deprecated(since = "0.12.0", note = "kept for backward compatibility")]
        #[link_name = "downstream_client_oh_fingerprint"]
        pub fn downstream_client_oh_fingerprint(
            ohfp_out: *mut u8,
            ohfp_max_len: usize,
            nwritten: *mut usize,
        ) -> FastlyStatus;

        #[deprecated(since = "0.12.0", note = "kept for backward compatibility")]
        #[link_name = "downstream_client_ddos_detected"]
        pub fn downstream_client_ddos_detected(ddos_detected_out: *mut u32) -> FastlyStatus;

        #[deprecated(since = "0.12.0", note = "kept for backward compatibility")]
        #[link_name = "downstream_tls_cipher_openssl_name"]
        pub fn downstream_tls_cipher_openssl_name(
            cipher_out: *mut u8,
            cipher_max_len: usize,
            nwritten: *mut usize,
        ) -> FastlyStatus;

        #[deprecated(since = "0.12.0", note = "kept for backward compatibility")]
        #[link_name = "downstream_tls_protocol"]
        pub fn downstream_tls_protocol(
            protocol_out: *mut u8,
            protocol_max_len: usize,
            nwritten: *mut usize,
        ) -> FastlyStatus;

        #[deprecated(since = "0.12.0", note = "kept for backward compatibility")]
        #[link_name = "downstream_tls_client_hello"]
        pub fn downstream_tls_client_hello(
            client_hello_out: *mut u8,
            client_hello_max_len: usize,
            nwritten: *mut usize,
        ) -> FastlyStatus;

        #[deprecated(since = "0.12.0", note = "kept for backward compatibility")]
        #[link_name = "downstream_tls_ja3_md5"]
        pub fn downstream_tls_ja3_md5(
            ja3_md5_out: *mut u8,
            nwritten_out: *mut usize,
        ) -> FastlyStatus;

        #[deprecated(since = "0.12.0", note = "kept for backward compatibility")]
        #[link_name = "downstream_tls_ja4"]
        pub fn downstream_tls_ja4(
            ja4_out: *mut u8,
            ja4_max_len: usize,
            nwritten: *mut usize,
        ) -> FastlyStatus;

        #[deprecated(since = "0.12.0", note = "kept for backward compatibility")]
        #[link_name = "downstream_compliance_region"]
        pub fn downstream_compliance_region(
            region_out: *mut u8,
            region_max_len: usize,
            nwritten: *mut usize,
        ) -> FastlyStatus;

        #[deprecated(since = "0.12.0", note = "kept for backward compatibility")]
        #[link_name = "downstream_tls_raw_client_certificate"]
        pub fn downstream_tls_raw_client_certificate(
            client_hello_out: *mut u8,
            client_hello_max_len: usize,
            nwritten: *mut usize,
        ) -> FastlyStatus;

        #[deprecated(since = "0.12.0", note = "kept for backward compatibility")]
        #[link_name = "downstream_tls_client_cert_verify_result"]
        pub fn downstream_tls_client_cert_verify_result(
            verify_result_out: *mut u32,
        ) -> FastlyStatus;

        #[link_name = "header_append"]
        pub fn header_append(
            req_handle: RequestHandle,
            name: *const u8,
            name_len: usize,
            value: *const u8,
            value_len: usize,
        ) -> FastlyStatus;

        #[link_name = "header_insert"]
        pub fn header_insert(
            req_handle: RequestHandle,
            name: *const u8,
            name_len: usize,
            value: *const u8,
            value_len: usize,
        ) -> FastlyStatus;

        #[deprecated(since = "0.12.0", note = "kept for backward compatibility")]
        #[link_name = "original_header_names_get"]
        pub fn original_header_names_get(
            buf: *mut u8,
            buf_len: usize,
            cursor: u32,
            ending_cursor: *mut i64,
            nwritten: *mut usize,
        ) -> FastlyStatus;

        #[deprecated(since = "0.12.0", note = "kept for backward compatibility")]
        #[link_name = "original_header_count"]
        pub fn original_header_count(count_out: *mut u32) -> FastlyStatus;

        #[link_name = "header_names_get"]
        pub fn header_names_get(
            req_handle: RequestHandle,
            buf: *mut u8,
            buf_len: usize,
            cursor: u32,
            ending_cursor: *mut i64,
            nwritten: *mut usize,
        ) -> FastlyStatus;

        #[link_name = "header_values_get"]
        pub fn header_values_get(
            req_handle: RequestHandle,
            name: *const u8,
            name_len: usize,
            buf: *mut u8,
            buf_len: usize,
            cursor: u32,
            ending_cursor: *mut i64,
            nwritten: *mut usize,
        ) -> FastlyStatus;

        #[link_name = "header_values_set"]
        pub fn header_values_set(
            req_handle: RequestHandle,
            name: *const u8,
            name_len: usize,
            values: *const u8,
            values_len: usize,
        ) -> FastlyStatus;

        #[link_name = "header_value_get"]
        pub fn header_value_get(
            req_handle: RequestHandle,
            name: *const u8,
            name_len: usize,
            value: *mut u8,
            value_max_len: usize,
            nwritten: *mut usize,
        ) -> FastlyStatus;

        #[link_name = "header_remove"]
        pub fn header_remove(
            req_handle: RequestHandle,
            name: *const u8,
            name_len: usize,
        ) -> FastlyStatus;

        #[link_name = "method_get"]
        pub fn method_get(
            req_handle: RequestHandle,
            method: *mut u8,
            method_max_len: usize,
            nwritten: *mut usize,
        ) -> FastlyStatus;

        #[link_name = "method_set"]
        pub fn method_set(
            req_handle: RequestHandle,
            method: *const u8,
            method_len: usize,
        ) -> FastlyStatus;

        #[link_name = "new"]
        pub fn new(req_handle_out: *mut RequestHandle) -> FastlyStatus;

        #[link_name = "send_v2"]
        pub fn send_v2(
            req_handle: RequestHandle,
            body_handle: BodyHandle,
            backend: *const u8,
            backend_len: usize,
            error_detail: *mut SendErrorDetail,
            resp_handle_out: *mut ResponseHandle,
            resp_body_handle_out: *mut BodyHandle,
        ) -> FastlyStatus;

        #[link_name = "send_v3"]
        pub fn send_v3(
            req_handle: RequestHandle,
            body_handle: BodyHandle,
            backend: *const u8,
            backend_len: usize,
            error_detail: *mut SendErrorDetail,
            resp_handle_out: *mut ResponseHandle,
            resp_body_handle_out: *mut BodyHandle,
        ) -> FastlyStatus;

        #[link_name = "send_async"]
        pub fn send_async(
            req_handle: RequestHandle,
            body_handle: BodyHandle,
            backend: *const u8,
            backend_len: usize,
            pending_req_handle_out: *mut PendingRequestHandle,
        ) -> FastlyStatus;

        #[link_name = "send_async_streaming"]
        pub fn send_async_streaming(
            req_handle: RequestHandle,
            body_handle: BodyHandle,
            backend: *const u8,
            backend_len: usize,
            pending_req_handle_out: *mut PendingRequestHandle,
        ) -> FastlyStatus;

        #[link_name = "send_async_v2"]
        pub fn send_async_v2(
            req_handle: RequestHandle,
            body_handle: BodyHandle,
            backend: *const u8,
            backend_len: usize,
            streaming: u32,
            pending_req_handle_out: *mut PendingRequestHandle,
        ) -> FastlyStatus;

        #[link_name = "upgrade_websocket"]
        pub fn upgrade_websocket(backend: *const u8, backend_len: usize) -> FastlyStatus;

        #[link_name = "redirect_to_websocket_proxy_v2"]
        pub fn redirect_to_websocket_proxy_v2(
            req: RequestHandle,
            backend: *const u8,
            backend_len: usize,
        ) -> FastlyStatus;

        #[link_name = "redirect_to_grip_proxy_v2"]
        pub fn redirect_to_grip_proxy_v2(
            req: RequestHandle,
            backend: *const u8,
            backend_len: usize,
        ) -> FastlyStatus;

        #[link_name = "register_dynamic_backend"]
        pub fn register_dynamic_backend(
            name_prefix: *const u8,
            name_prefix_len: usize,
            target: *const u8,
            target_len: usize,
            config_mask: BackendConfigOptions,
            config: *const DynamicBackendConfig,
        ) -> FastlyStatus;

        #[link_name = "uri_get"]
        pub fn uri_get(
            req_handle: RequestHandle,
            uri: *mut u8,
            uri_max_len: usize,
            nwritten: *mut usize,
        ) -> FastlyStatus;

        #[link_name = "uri_set"]
        pub fn uri_set(req_handle: RequestHandle, uri: *const u8, uri_len: usize) -> FastlyStatus;

        #[link_name = "version_get"]
        pub fn version_get(req_handle: RequestHandle, version: *mut u32) -> FastlyStatus;

        #[link_name = "version_set"]
        pub fn version_set(req_handle: RequestHandle, version: u32) -> FastlyStatus;

        #[link_name = "pending_req_header_append"]
        pub fn pending_req_header_append(
            pending_req_handle: PendingRequestHandle,
            name: *const u8,
            name_len: usize,
            value: *const u8,
            value_len: usize,
            target: PendingResponseKind,
        ) -> FastlyStatus;

        #[link_name = "pending_req_header_insert"]
        pub fn pending_req_header_insert(
            pending_req_handle: PendingRequestHandle,
            name: *const u8,
            name_len: usize,
            value: *const u8,
            value_len: usize,
            target: PendingResponseKind,
        ) -> FastlyStatus;

        #[link_name = "pending_req_header_remove"]
        pub fn pending_req_header_remove(
            pending_req_handle: PendingRequestHandle,
            name: *const u8,
            name_len: usize,
            target: PendingResponseKind,
        ) -> FastlyStatus;

        #[link_name = "pending_req_poll_v2"]
        pub fn pending_req_poll_v2(
            pending_req_handle: PendingRequestHandle,
            error_detail: *mut SendErrorDetail,
            is_done_out: *mut i32,
            resp_handle_out: *mut ResponseHandle,
            resp_body_handle_out: *mut BodyHandle,
        ) -> FastlyStatus;

        #[link_name = "pending_req_select_v2"]
        pub fn pending_req_select_v2(
            pending_req_handles: *const PendingRequestHandle,
            pending_req_handles_len: usize,
            error_detail: *mut SendErrorDetail,
            done_index_out: *mut i32,
            resp_handle_out: *mut ResponseHandle,
            resp_body_handle_out: *mut BodyHandle,
        ) -> FastlyStatus;

        #[link_name = "pending_req_wait_v2"]
        pub fn pending_req_wait_v2(
            pending_req_handle: PendingRequestHandle,
            error_detail: *mut SendErrorDetail,
            resp_handle_out: *mut ResponseHandle,
            resp_body_handle_out: *mut BodyHandle,
        ) -> FastlyStatus;

        #[deprecated(since = "0.12.0", note = "kept for backward compatibility")]
        #[link_name = "fastly_key_is_valid"]
        pub fn fastly_key_is_valid(is_valid_out: *mut u32) -> FastlyStatus;

        #[link_name = "close"]
        pub fn close(req_handle: RequestHandle) -> FastlyStatus;

        #[link_name = "auto_decompress_response_set"]
        pub fn auto_decompress_response_set(
            req_handle: RequestHandle,
            encodings: ContentEncodings,
        ) -> FastlyStatus;

        #[link_name = "inspect"]
        pub fn inspect(
            request_handle: RequestHandle,
            body_handle: BodyHandle,
            add_info_mask: InspectInfoMask,
            add_info: *const InspectInfo,
            buf: *mut u8,
            buf_len: usize,
            nwritten: *mut usize,
        ) -> FastlyStatus;

        #[link_name = "on_behalf_of"]
        pub fn on_behalf_of(
            request_handle: RequestHandle,
            service: *const u8,
            service_len: usize,
        ) -> FastlyStatus;
    }
}

pub mod fastly_http_resp {
    use super::*;

    #[link(wasm_import_module = "fastly_http_resp")]
    extern "C" {
        #[link_name = "header_append"]
        pub fn header_append(
            resp_handle: ResponseHandle,
            name: *const u8,
            name_len: usize,
            value: *const u8,
            value_len: usize,
        ) -> FastlyStatus;

        #[link_name = "header_insert"]
        pub fn header_insert(
            resp_handle: ResponseHandle,
            name: *const u8,
            name_len: usize,
            value: *const u8,
            value_len: usize,
        ) -> FastlyStatus;

        #[link_name = "header_names_get"]
        pub fn header_names_get(
            resp_handle: ResponseHandle,
            buf: *mut u8,
            buf_len: usize,
            cursor: u32,
            ending_cursor: *mut i64,
            nwritten: *mut usize,
        ) -> FastlyStatus;

        #[link_name = "header_value_get"]
        pub fn header_value_get(
            resp_handle: ResponseHandle,
            name: *const u8,
            name_len: usize,
            value: *mut u8,
            value_max_len: usize,
            nwritten: *mut usize,
        ) -> FastlyStatus;

        #[link_name = "header_values_get"]
        pub fn header_values_get(
            resp_handle: ResponseHandle,
            name: *const u8,
            name_len: usize,
            buf: *mut u8,
            buf_len: usize,
            cursor: u32,
            ending_cursor: *mut i64,
            nwritten: *mut usize,
        ) -> FastlyStatus;

        #[link_name = "header_values_set"]
        pub fn header_values_set(
            resp_handle: ResponseHandle,
            name: *const u8,
            name_len: usize,
            values: *const u8,
            values_len: usize,
        ) -> FastlyStatus;

        #[link_name = "header_remove"]
        pub fn header_remove(
            resp_handle: ResponseHandle,
            name: *const u8,
            name_len: usize,
        ) -> FastlyStatus;

        #[link_name = "new"]
        pub fn new(resp_handle_out: *mut ResponseHandle) -> FastlyStatus;

        #[link_name = "send_downstream"]
        pub fn send_downstream(
            resp_handle: ResponseHandle,
            body_handle: BodyHandle,
            streaming: u32,
        ) -> FastlyStatus;

        #[link_name = "send_downstream_pending"]
        pub fn send_downstream_pending(pending_req_handle: PendingRequestHandle) -> FastlyStatus;

        #[link_name = "status_get"]
        pub fn status_get(resp_handle: ResponseHandle, status: *mut u16) -> FastlyStatus;

        #[link_name = "status_set"]
        pub fn status_set(resp_handle: ResponseHandle, status: u16) -> FastlyStatus;

        #[link_name = "version_get"]
        pub fn version_get(resp_handle: ResponseHandle, version: *mut u32) -> FastlyStatus;

        #[link_name = "version_set"]
        pub fn version_set(resp_handle: ResponseHandle, version: u32) -> FastlyStatus;

        #[link_name = "framing_headers_mode_set"]
        pub fn framing_headers_mode_set(
            resp_handle: ResponseHandle,
            mode: fastly_shared::FramingHeadersMode,
        ) -> FastlyStatus;

        #[doc(hidden)]
        #[link_name = "http_keepalive_mode_set"]
        pub fn http_keepalive_mode_set(
            resp_handle: ResponseHandle,
            mode: fastly_shared::HttpKeepaliveMode,
        ) -> FastlyStatus;

        #[link_name = "close"]
        pub fn close(resp_handle: ResponseHandle) -> FastlyStatus;

        #[link_name = "get_addr_dest_ip"]
        pub fn get_addr_dest_ip(
            resp_handle: ResponseHandle,
            addr_octets_out: *mut u8,
            nwritten_out: *mut usize,
        ) -> FastlyStatus;

        #[link_name = "get_addr_dest_port"]
        pub fn get_addr_dest_port(resp_handle: ResponseHandle, port_out: *mut u16) -> FastlyStatus;
    }
}

pub mod fastly_dictionary {
    use super::*;

    #[link(wasm_import_module = "fastly_dictionary")]
    extern "C" {
        #[link_name = "open"]
        pub fn open(
            name: *const u8,
            name_len: usize,
            dict_handle_out: *mut DictionaryHandle,
        ) -> FastlyStatus;

        #[link_name = "get"]
        pub fn get(
            dict_handle: DictionaryHandle,
            key: *const u8,
            key_len: usize,
            value: *mut u8,
            value_max_len: usize,
            nwritten: *mut usize,
        ) -> FastlyStatus;
    }
}

pub mod fastly_geo {
    use super::*;

    #[link(wasm_import_module = "fastly_geo")]
    extern "C" {
        #[link_name = "lookup"]
        pub fn lookup(
            addr_octets: *const u8,
            addr_len: usize,
            buf: *mut u8,
            buf_len: usize,
            nwritten_out: *mut usize,
        ) -> FastlyStatus;
    }
}

pub mod fastly_device_detection {
    use super::*;

    #[link(wasm_import_module = "fastly_device_detection")]
    extern "C" {
        #[link_name = "lookup"]
        pub fn lookup(
            user_agent: *const u8,
            user_agent_max_len: usize,
            buf: *mut u8,
            buf_len: usize,
            nwritten_out: *mut usize,
        ) -> FastlyStatus;
    }
}

pub mod fastly_erl {
    use super::*;

    #[link(wasm_import_module = "fastly_erl")]
    extern "C" {
        #[link_name = "check_rate"]
        pub fn check_rate(
            rc: *const u8,
            rc_max_len: usize,
            entry: *const u8,
            entry_max_len: usize,
            delta: u32,
            window: u32,
            limit: u32,
            pb: *const u8,
            pb_max_len: usize,
            ttl: u32,
            value: *mut u32,
        ) -> FastlyStatus;

        #[link_name = "ratecounter_increment"]
        pub fn ratecounter_increment(
            rc: *const u8,
            rc_max_len: usize,
            entry: *const u8,
            entry_max_len: usize,
            delta: u32,
        ) -> FastlyStatus;

        #[link_name = "ratecounter_lookup_rate"]
        pub fn ratecounter_lookup_rate(
            rc: *const u8,
            rc_max_len: usize,
            entry: *const u8,
            entry_max_len: usize,
            window: u32,
            value: *mut u32,
        ) -> FastlyStatus;

        #[link_name = "ratecounter_lookup_count"]
        pub fn ratecounter_lookup_count(
            rc: *const u8,
            rc_max_len: usize,
            entry: *const u8,
            entry_max_len: usize,
            duration: u32,
            value: *mut u32,
        ) -> FastlyStatus;

        #[link_name = "penaltybox_add"]
        pub fn penaltybox_add(
            pb: *const u8,
            pb_max_len: usize,
            entry: *const u8,
            entry_max_len: usize,
            ttl: u32,
        ) -> FastlyStatus;

        #[link_name = "penaltybox_has"]
        pub fn penaltybox_has(
            pb: *const u8,
            pb_max_len: usize,
            entry: *const u8,
            entry_max_len: usize,
            value: *mut u32,
        ) -> FastlyStatus;
    }
}

pub mod fastly_kv_store {
    use super::*;

    #[repr(u32)]
    #[derive(Clone, Copy, Debug, PartialEq, Eq)]
    pub enum KvError {
        Uninitialized,
        Ok,
        BadRequest,
        NotFound,
        PreconditionFailed,
        PayloadTooLarge,
        InternalError,
    }

    // TODO ACF 2023-04-11: keep the object store name here until the ABI is updated
    #[link(wasm_import_module = "fastly_object_store")]
    extern "C" {
        #[link_name = "open"]
        pub fn open(
            name_ptr: *const u8,
            name_len: usize,
            kv_store_handle_out: *mut KVStoreHandle,
        ) -> FastlyStatus;

        #[deprecated(note = "kept for backward compatibility")]
        #[link_name = "lookup"]
        pub fn lookup(
            kv_store_handle: KVStoreHandle,
            key_ptr: *const u8,
            key_len: usize,
            body_handle_out: *mut BodyHandle,
        ) -> FastlyStatus;

        #[deprecated(note = "kept for backward compatibility")]
        #[link_name = "lookup_async"]
        pub fn lookup_async(
            kv_store_handle: KVStoreHandle,
            key_ptr: *const u8,
            key_len: usize,
            pending_body_handle_out: *mut PendingObjectStoreLookupHandle,
        ) -> FastlyStatus;

        #[deprecated(note = "kept for backward compatibility")]
        #[link_name = "pending_lookup_wait"]
        pub fn pending_lookup_wait(
            pending_handle: PendingObjectStoreLookupHandle,
            body_handle_out: *mut BodyHandle,
        ) -> FastlyStatus;

        #[deprecated(note = "kept for backward compatibility")]
        #[link_name = "insert"]
        pub fn insert(
            kv_store_handle: KVStoreHandle,
            key_ptr: *const u8,
            key_len: usize,
            body_handle: BodyHandle,
        ) -> FastlyStatus;

        #[deprecated(note = "kept for backward compatibility")]
        #[link_name = "insert_async"]
        pub fn insert_async(
            kv_store_handle: KVStoreHandle,
            key_ptr: *const u8,
            key_len: usize,
            body_handle: BodyHandle,
            pending_body_handle_out: *mut PendingObjectStoreInsertHandle,
        ) -> FastlyStatus;

        #[deprecated(note = "kept for backward compatibility")]
        #[link_name = "pending_insert_wait"]
        pub fn pending_insert_wait(
            pending_body_handle: PendingObjectStoreInsertHandle,
            kv_error_out: *mut KvError,
        ) -> FastlyStatus;

        #[deprecated(note = "kept for backward compatibility")]
        #[link_name = "delete_async"]
        pub fn delete_async(
            kv_store_handle: KVStoreHandle,
            key_ptr: *const u8,
            key_len: usize,
            pending_body_handle_out: *mut PendingObjectStoreDeleteHandle,
        ) -> FastlyStatus;

        #[deprecated(note = "kept for backward compatibility")]
        #[link_name = "pending_delete_wait"]
        pub fn pending_delete_wait(
            pending_body_handle: PendingObjectStoreDeleteHandle,
        ) -> FastlyStatus;
    }

    #[link(wasm_import_module = "fastly_kv_store")]
    extern "C" {
        #[link_name = "open"]
        pub fn open_v2(
            name_ptr: *const u8,
            name_len: usize,
            kv_store_handle_out: *mut KVStoreHandle,
        ) -> FastlyStatus;

        #[link_name = "lookup"]
        pub fn lookup_v2(
            kv_store_handle: KVStoreHandle,
            key_ptr: *const u8,
            key_len: usize,
            lookup_config_mask: LookupConfigOptions,
            lookup_config: *const LookupConfig,
            pending_body_handle_out: *mut PendingObjectStoreLookupHandle,
        ) -> FastlyStatus;

        #[link_name = "lookup_wait"]
        pub fn pending_lookup_wait_v2(
            pending_handle: PendingObjectStoreLookupHandle,
            body_handle_out: *mut BodyHandle,
            metadata_buf: *mut u8,
            metadata_buf_len: usize,
            nwritten_out: *mut usize,
            generation_out: *mut u32,
            kv_error_out: *mut KvError,
        ) -> FastlyStatus;

        #[link_name = "lookup_wait_v2"]
        pub fn lookup_wait_v2(
            pending_handle: PendingObjectStoreLookupHandle,
            body_handle_out: *mut BodyHandle,
            metadata_buf: *mut u8,
            metadata_buf_len: usize,
            nwritten_out: *mut usize,
            generation_out: *mut u64,
            kv_error_out: *mut KvError,
        ) -> FastlyStatus;

        #[link_name = "insert"]
        pub fn insert_v2(
            kv_store_handle: KVStoreHandle,
            key_ptr: *const u8,
            key_len: usize,
            body_handle: BodyHandle,
            insert_config_mask: InsertConfigOptions,
            insert_config: *const InsertConfig,
            pending_body_handle_out: *mut PendingObjectStoreInsertHandle,
        ) -> FastlyStatus;

        #[link_name = "insert_wait"]
        pub fn pending_insert_wait_v2(
            pending_body_handle: PendingObjectStoreInsertHandle,
            kv_error_out: *mut KvError,
        ) -> FastlyStatus;

        #[link_name = "delete"]
        pub fn delete_v2(
            kv_store_handle: KVStoreHandle,
            key_ptr: *const u8,
            key_len: usize,
            delete_config_mask: DeleteConfigOptions,
            delete_config: *const DeleteConfig,
            pending_body_handle_out: *mut PendingObjectStoreDeleteHandle,
        ) -> FastlyStatus;

        #[link_name = "delete_wait"]
        pub fn pending_delete_wait_v2(
            pending_body_handle: PendingObjectStoreDeleteHandle,
            kv_error_out: *mut KvError,
        ) -> FastlyStatus;

        #[link_name = "list"]
        pub fn list_v2(
            kv_store_handle: KVStoreHandle,
            list_config_mask: ListConfigOptions,
            list_config: *const ListConfig,
            pending_body_handle_out: *mut PendingObjectStoreListHandle,
        ) -> FastlyStatus;

        #[link_name = "list_wait"]
        pub fn pending_list_wait_v2(
            pending_body_handle: PendingObjectStoreListHandle,
            body_handle_out: *mut BodyHandle,
            kv_error_out: *mut KvError,
        ) -> FastlyStatus;
    }
}

pub mod fastly_secret_store {
    use super::*;

    #[link(wasm_import_module = "fastly_secret_store")]
    extern "C" {
        #[link_name = "open"]
        pub fn open(
            secret_store_name_ptr: *const u8,
            secret_store_name_len: usize,
            secret_store_handle_out: *mut SecretStoreHandle,
        ) -> FastlyStatus;

        #[link_name = "get"]
        pub fn get(
            secret_store_handle: SecretStoreHandle,
            secret_name_ptr: *const u8,
            secret_name_len: usize,
            secret_handle_out: *mut SecretHandle,
        ) -> FastlyStatus;

        #[link_name = "plaintext"]
        pub fn plaintext(
            secret_handle: SecretHandle,
            plaintext_buf: *mut u8,
            plaintext_max_len: usize,
            nwritten_out: *mut usize,
        ) -> FastlyStatus;

        #[link_name = "from_bytes"]
        pub fn from_bytes(
            plaintext_buf: *const u8,
            plaintext_len: usize,
            secret_handle_out: *mut SecretHandle,
        ) -> FastlyStatus;
    }
}

pub mod fastly_backend {
    use super::*;

    #[derive(Clone, Copy, Debug, PartialEq, Eq)]
    #[repr(u32)]
    pub enum BackendHealth {
        Unknown,
        Healthy,
        Unhealthy,
    }

    #[link(wasm_import_module = "fastly_backend")]
    extern "C" {
        #[link_name = "exists"]
        pub fn exists(
            backend_ptr: *const u8,
            backend_len: usize,
            backend_exists_out: *mut u32,
        ) -> FastlyStatus;

        #[link_name = "is_healthy"]
        pub fn is_healthy(
            backend_ptr: *const u8,
            backend_len: usize,
            backend_health_out: *mut BackendHealth,
        ) -> FastlyStatus;

        #[link_name = "is_dynamic"]
        pub fn is_dynamic(
            backend_ptr: *const u8,
            backend_len: usize,
            value: *mut u32,
        ) -> FastlyStatus;

        #[link_name = "get_host"]
        pub fn get_host(
            backend_ptr: *const u8,
            backend_len: usize,
            value: *mut u8,
            value_max_len: usize,
            nwritten: *mut usize,
        ) -> FastlyStatus;

        #[link_name = "get_override_host"]
        pub fn get_override_host(
            backend_ptr: *const u8,
            backend_len: usize,
            value: *mut u8,
            value_max_len: usize,
            nwritten: *mut usize,
        ) -> FastlyStatus;

        #[link_name = "get_port"]
        pub fn get_port(
            backend_ptr: *const u8,
            backend_len: usize,
            value: *mut u16,
        ) -> FastlyStatus;

        #[link_name = "get_connect_timeout_ms"]
        pub fn get_connect_timeout_ms(
            backend_ptr: *const u8,
            backend_len: usize,
            value: *mut u32,
        ) -> FastlyStatus;

        #[link_name = "get_first_byte_timeout_ms"]
        pub fn get_first_byte_timeout_ms(
            backend_ptr: *const u8,
            backend_len: usize,
            value: *mut u32,
        ) -> FastlyStatus;

        #[link_name = "get_between_bytes_timeout_ms"]
        pub fn get_between_bytes_timeout_ms(
            backend_ptr: *const u8,
            backend_len: usize,
            value: *mut u32,
        ) -> FastlyStatus;

        #[link_name = "get_http_keepalive_time"]
        pub fn get_http_keepalive_time(
            backend_ptr: *const u8,
            backend_len: usize,
            value: *mut u32,
        ) -> FastlyStatus;

        #[link_name = "get_tcp_keepalive_enable"]
        pub fn get_tcp_keepalive_enable(
            backend_ptr: *const u8,
            backend_len: usize,
            value: *mut u32,
        ) -> FastlyStatus;

        #[link_name = "get_tcp_keepalive_interval"]
        pub fn get_tcp_keepalive_interval(
            backend_ptr: *const u8,
            backend_len: usize,
            value: *mut u32,
        ) -> FastlyStatus;

        #[link_name = "get_tcp_keepalive_probes"]
        pub fn get_tcp_keepalive_probes(
            backend_ptr: *const u8,
            backend_len: usize,
            value: *mut u32,
        ) -> FastlyStatus;

        #[link_name = "get_tcp_keepalive_time"]
        pub fn get_tcp_keepalive_time(
            backend_ptr: *const u8,
            backend_len: usize,
            value: *mut u32,
        ) -> FastlyStatus;

        #[link_name = "is_ssl"]
        pub fn is_ssl(backend_ptr: *const u8, backend_len: usize, value: *mut u32) -> FastlyStatus;

        #[link_name = "get_ssl_min_version"]
        pub fn get_ssl_min_version(
            backend_ptr: *const u8,
            backend_len: usize,
            value: *mut u32,
        ) -> FastlyStatus;

        #[link_name = "get_ssl_max_version"]
        pub fn get_ssl_max_version(
            backend_ptr: *const u8,
            backend_len: usize,
            value: *mut u32,
        ) -> FastlyStatus;
    }
}

pub mod fastly_async_io {
    use super::*;

    #[link(wasm_import_module = "fastly_async_io")]
    extern "C" {
        #[link_name = "select"]
        pub fn select(
            async_item_handles: *const AsyncItemHandle,
            async_item_handles_len: usize,
            timeout_ms: u32,
            done_index_out: *mut u32,
        ) -> FastlyStatus;

        #[link_name = "is_ready"]
        pub fn is_ready(async_item_handle: AsyncItemHandle, ready_out: *mut u32) -> FastlyStatus;
    }
}

pub mod fastly_image_optimizer {
    use super::*;

    bitflags::bitflags! {
        #[repr(transparent)]
        pub struct ImageOptimizerTransformConfigOptions: u32 {
            const RESERVED = 1 << 0;
            const SDK_CLAIMS_OPTS = 1 << 1;
        }
    }

    #[repr(C, align(8))]
    pub struct ImageOptimizerTransformConfig {
        pub sdk_claims_opts: *const u8,
        pub sdk_claims_opts_len: u32,
    }

    impl Default for ImageOptimizerTransformConfig {
        fn default() -> Self {
            ImageOptimizerTransformConfig {
                sdk_claims_opts: std::ptr::null(),
                sdk_claims_opts_len: 0,
            }
        }
    }

    #[repr(u32)]
    #[derive(Clone, Copy, Debug, PartialEq, Eq)]
    pub enum ImageOptimizerErrorTag {
        Uninitialized,
        Ok,
        Error,
        Warning,
    }

    #[repr(C, align(8))]
    #[derive(Clone, Debug, PartialEq, Eq)]
    pub struct ImageOptimizerErrorDetail {
        pub tag: ImageOptimizerErrorTag,
        pub message: *const u8,
        pub message_len: usize,
    }

    impl ImageOptimizerErrorDetail {
        pub fn uninitialized() -> Self {
            Self {
                tag: ImageOptimizerErrorTag::Uninitialized,
                message: std::ptr::null(),
                message_len: 0,
            }
        }
    }

    #[link(wasm_import_module = "fastly_image_optimizer")]
    extern "C" {
        #[link_name = "transform_image_optimizer_request"]
        pub fn transform_image_optimizer_request(
            origin_image_request: RequestHandle,
            origin_image_request_body: BodyHandle,
            origin_image_backend: *const u8,
            origin_image_backend_len: usize,
            io_transform_config_options: ImageOptimizerTransformConfigOptions,
            io_transform_config: *const ImageOptimizerTransformConfig,
            io_error_detail: *mut ImageOptimizerErrorDetail,
            resp_handle_out: *mut ResponseHandle,
            resp_body_handle_out: *mut BodyHandle,
        ) -> FastlyStatus;
    }
}

pub mod fastly_purge {
    use super::*;

    bitflags::bitflags! {
        #[derive(Default)]
        #[repr(transparent)]
        pub struct PurgeOptionsMask: u32 {
            const SOFT_PURGE = 1 << 0;
            const RET_BUF = 1 << 1;
        }
    }

    #[derive(Debug)]
    #[repr(C)]
    pub struct PurgeOptions {
        pub ret_buf_ptr: *mut u8,
        pub ret_buf_len: usize,
        pub ret_buf_nwritten_out: *mut usize,
    }

    #[link(wasm_import_module = "fastly_purge")]
    extern "C" {
        #[link_name = "purge_surrogate_key"]
        pub fn purge_surrogate_key(
            surrogate_key_ptr: *const u8,
            surrogate_key_len: usize,
            options_mask: PurgeOptionsMask,
            options: *mut PurgeOptions,
        ) -> FastlyStatus;
    }
}

pub mod fastly_compute_runtime {
    use super::*;

    #[link(wasm_import_module = "fastly_compute_runtime")]
    extern "C" {
        #[link_name = "get_vcpu_ms"]
        pub fn get_vcpu_ms(ms_out: *mut u64) -> FastlyStatus;
    }

    #[link(wasm_import_module = "fastly_compute_runtime")]
    extern "C" {
        #[link_name = "get_heap_mib"]
        pub fn get_heap_mib(mb_out: *mut u32) -> fastly_shared::FastlyStatus;
    }
}

pub mod fastly_acl {
    use super::*;

    #[repr(u32)]
    #[derive(Clone, Copy, Debug, PartialEq, Eq)]
    pub enum AclError {
        Uninitialized,
        Ok,
        NoContent,
        TooManyRequests,
    }

    #[link(wasm_import_module = "fastly_acl")]
    extern "C" {
        #[link_name = "open"]
        pub fn open(
            acl_name_ptr: *const u8,
            acl_name_len: usize,
            acl_handle_out: *mut AclHandle,
        ) -> FastlyStatus;

        #[link_name = "lookup"]
        pub fn lookup(
            acl_handle: AclHandle,
            ip_octets: *const u8,
            ip_len: usize,
            body_handle_out: *mut BodyHandle,
            acl_error_out: *mut AclError,
        ) -> FastlyStatus;
    }
}

pub mod fastly_shielding {
    use super::*;

    bitflags::bitflags! {
        #[derive(Default)]
        #[repr(transparent)]
        pub struct ShieldBackendOptions: u32 {
            const RESERVED = 1 << 0;
            const CACHE_KEY = 1 << 1;
            const FIRST_BYTE_TIMEOUT = 1 << 2;
        }
    }

    #[repr(C)]
    pub struct ShieldBackendConfig {
        pub cache_key: *const u8,
        pub cache_key_len: u32,
        pub first_byte_timeout_ms: u32,
    }

    impl Default for ShieldBackendConfig {
        fn default() -> Self {
            ShieldBackendConfig {
                cache_key: std::ptr::null(),
                cache_key_len: 0,
                first_byte_timeout_ms: 0,
            }
        }
    }

    //   (@interface func (export "shield_info")
    //     (param $name string)
    //     (param $info_block (@witx pointer (@witx char8)))
    //     (param $info_block_max_len (@witx usize))
    //     (result $err (expected $num_bytes (error $fastly_status)))
    //   )

    #[link(wasm_import_module = "fastly_shielding")]
    extern "C" {

        /// Get information about the given shield in the Fastly network
        #[link_name = "shield_info"]
        pub fn shield_info(
            name: *const u8,
            name_len: usize,
            info_block: *mut u8,
            info_block_len: usize,
            nwritten_out: *mut u32,
        ) -> FastlyStatus;

        /// Turn a pop name into a backend that we can send requests to.
        #[link_name = "backend_for_shield"]
        pub fn backend_for_shield(
            name: *const u8,
            name_len: usize,
            options_mask: ShieldBackendOptions,
            options: *const ShieldBackendConfig,
            backend_name: *mut u8,
            backend_name_len: usize,
            nwritten_out: *mut u32,
        ) -> FastlyStatus;
    }
}

/// WIT for the Fastly APIs in the `fastly:compute/service@0.1.0` world.
#[cfg(not(target_env = "p1"))]
pub mod service0_1_0;

#[cfg(not(target_env = "p1"))]
impl From<service0_1_0::fastly::compute::types::Error> for fastly_shared::FastlyStatus {
    fn from(error: service0_1_0::fastly::compute::types::Error) -> Self {
        use service0_1_0::fastly::compute::types::Error;
        match error {
            Error::InvalidArgument => Self::INVAL,
            Error::Unsupported => Self::UNSUPPORTED,
            Error::LimitExceeded => Self::LIMITEXCEEDED,
            Error::GenericError => Self::ERROR,
            Error::BufferLen(_) => Self::BUFLEN,
            Error::CannotRead => Self::NONE,
            Error::AuxiliaryError => Self::BADF,
            Error::HttpInvalid => Self::HTTPINVALID,
            Error::HttpUser => Self::HTTPUSER,
            Error::HttpIncomplete => Self::HTTPINCOMPLETE,
            Error::HttpHeadTooLarge => Self::HTTPHEADTOOLARGE,
            Error::HttpInvalidStatus => Self::HTTPINVALIDSTATUS,
        }
    }
}

#[cfg(not(target_env = "p1"))]
impl From<std::net::IpAddr> for service0_1_0::fastly::compute::types::IpAddress {
    fn from(addr: std::net::IpAddr) -> Self {
        use std::net::IpAddr;
        match addr {
            IpAddr::V4(v4) => Self::Ipv4(v4.octets().into()),
            IpAddr::V6(v6) => Self::Ipv6(v6.segments().into()),
        }
    }
}

#[cfg(not(target_env = "p1"))]
impl From<service0_1_0::fastly::compute::types::IpAddress> for std::net::IpAddr {
    fn from(addr: service0_1_0::fastly::compute::types::IpAddress) -> Self {
        use service0_1_0::fastly::compute::types::IpAddress;
        match addr {
            IpAddress::Ipv4(v4) => Self::V4(<[u8; 4]>::from(v4).into()),
            IpAddress::Ipv6(v6) => Self::V6(<[u16; 8]>::from(v6).into()),
        }
    }
}

#[cfg(not(target_env = "p1"))]
impl From<service0_1_0::fastly::compute::http_types::HttpVersion> for http::version::Version {
    fn from(version: service0_1_0::fastly::compute::http_types::HttpVersion) -> Self {
        use service0_1_0::fastly::compute::http_types::HttpVersion;
        match version {
            HttpVersion::Http09 => Self::HTTP_09,
            HttpVersion::Http10 => Self::HTTP_10,
            HttpVersion::Http11 => Self::HTTP_11,
            HttpVersion::H2 => Self::HTTP_2,
            HttpVersion::H3 => Self::HTTP_3,
        }
    }
}

#[cfg(not(target_env = "p1"))]
impl TryFrom<http::version::Version> for service0_1_0::fastly::compute::http_types::HttpVersion {
    type Error = ();

    fn try_from(version: http::version::Version) -> Result<Self, Self::Error> {
        use http::version::Version;
        Ok(match version {
            Version::HTTP_09 => Self::Http09,
            Version::HTTP_10 => Self::Http10,
            Version::HTTP_11 => Self::Http11,
            Version::HTTP_2 => Self::H2,
            Version::HTTP_3 => Self::H3,
            _ => return Err(()),
        })
    }
}

#[cfg(not(target_env = "p1"))]
impl From<fastly_shared::FramingHeadersMode>
    for service0_1_0::fastly::compute::http_types::FramingHeadersMode
{
    fn from(mode: fastly_shared::FramingHeadersMode) -> Self {
        use fastly_shared::FramingHeadersMode;
        match mode {
            FramingHeadersMode::Automatic => Self::Automatic,
            FramingHeadersMode::ManuallyFromHeaders => Self::ManuallyFromHeaders,
        }
    }
}

#[cfg(not(target_env = "p1"))]
impl From<service0_1_0::fastly::compute::http_types::FramingHeadersMode>
    for fastly_shared::FramingHeadersMode
{
    fn from(mode: service0_1_0::fastly::compute::http_types::FramingHeadersMode) -> Self {
        use service0_1_0::fastly::compute::http_types::FramingHeadersMode;
        match mode {
            FramingHeadersMode::Automatic => Self::Automatic,
            FramingHeadersMode::ManuallyFromHeaders => Self::ManuallyFromHeaders,
        }
    }
}

#[cfg(not(target_env = "p1"))]
impl From<fastly_shared::HttpKeepaliveMode>
    for service0_1_0::fastly::compute::http_resp::KeepaliveMode
{
    fn from(mode: fastly_shared::HttpKeepaliveMode) -> Self {
        use fastly_shared::HttpKeepaliveMode;
        match mode {
            HttpKeepaliveMode::Automatic => Self::Automatic,
            HttpKeepaliveMode::NoKeepalive => Self::NoKeepalive,
        }
    }
}

#[cfg(not(target_env = "p1"))]
impl From<service0_1_0::fastly::compute::http_resp::KeepaliveMode>
    for fastly_shared::HttpKeepaliveMode
{
    fn from(mode: service0_1_0::fastly::compute::http_resp::KeepaliveMode) -> Self {
        use service0_1_0::fastly::compute::http_resp::KeepaliveMode;
        match mode {
            KeepaliveMode::Automatic => Self::Automatic,
            KeepaliveMode::NoKeepalive => Self::NoKeepalive,
        }
    }
}