compute-at-edge.witx

(use "typenames.witx")
(use "cache.witx")
(use "config-store.witx")

(module $fastly_abi
    (@interface func (export "init")
        (param $abi_version u64)
        (result $err (expected (error $fastly_status)))
    )
)

(module $fastly_uap
    (@interface func (export "parse")
        (param $user_agent string)

        (param $family (@witx pointer (@witx char8)))
        (param $family_len (@witx usize))
        (param $family_nwritten_out (@witx pointer (@witx usize)))

        (param $major (@witx pointer (@witx char8)))
        (param $major_len (@witx usize))
        (param $major_nwritten_out (@witx pointer (@witx usize)))

        (param $minor (@witx pointer (@witx char8)))
        (param $minor_len (@witx usize))
        (param $minor_nwritten_out (@witx pointer (@witx usize)))

        (param $patch (@witx pointer (@witx char8)))
        (param $patch_len (@witx usize))
        (param $patch_nwritten_out (@witx pointer (@witx usize)))

        (result $err (expected (error $fastly_status)))
    )
)

(module $fastly_http_body
    (@interface func (export "append")
        (param $dest $body_handle)
        (param $src $body_handle)
        (result $err (expected (error $fastly_status)))
    )

    (@interface func (export "new")
        (result $err (expected $body_handle (error $fastly_status)))
    )

    (@interface func (export "read")
        (param $h $body_handle)
        (param $buf (@witx pointer u8))
        (param $buf_len (@witx usize))
        (result $err (expected $num_bytes (error $fastly_status)))
    )

    (@interface func (export "write")
        (param $h $body_handle)
        (param $buf (list u8))
        (param $end $body_write_end)
        (result $err (expected $num_bytes (error $fastly_status)))
    )

    ;;; Frees the body on the host.
    ;;;
    ;;; For streaming bodies, this is a _successful_ stream termination, which will signal
    ;;; via framing that the body transfer is complete.
    (@interface func (export "close")
        (param $h $body_handle)
        (result $err (expected (error $fastly_status)))
    )

    ;;; Frees a streaming body on the host _unsuccessfully_, so that framing makes clear that
    ;;; the body is incomplete.
    (@interface func (export "abandon")
        (param $h $body_handle)
        (result $err (expected (error $fastly_status)))
    )

    (@interface func (export "trailer_append")
        (param $h $body_handle)
        (param $name (list u8))
        (param $value (list u8))
        (result $err (expected (error $fastly_status)))
    )

    (@interface func (export "trailer_names_get")
        (param $h $body_handle)
        (param $buf (@witx pointer (@witx char8)))
        (param $buf_len (@witx usize))
        (param $cursor $multi_value_cursor)
        (param $ending_cursor_out (@witx pointer $multi_value_cursor_result))
        (param $nwritten_out (@witx pointer (@witx usize)))
        (result $err (expected (error $fastly_status)))
    )

    (@interface func (export "trailer_value_get")
        (param $h $body_handle)
        (param $name (list u8))
        (param $value (@witx pointer (@witx char8)))
        (param $value_max_len (@witx usize))
        (param $nwritten_out (@witx pointer (@witx usize)))
        (result $err (expected (error $fastly_status)))
    )

    (@interface func (export "trailer_values_get")
        (param $h $body_handle)
        (param $name (list u8))
        (param $buf (@witx pointer (@witx char8)))
        (param $buf_len (@witx usize))
        (param $cursor $multi_value_cursor)
        (param $ending_cursor_out (@witx pointer $multi_value_cursor_result))
        (param $nwritten_out (@witx pointer (@witx usize)))
        (result $err (expected (error $fastly_status)))
    )

    ;;; Returns a u64 body length if the length of a body is known, or `FastlyStatus::None`
    ;;; otherwise.
    ;;;
    ;;; If the length is unknown, it is likely due to the body arising from an HTTP/1.1 message with
    ;;; chunked encoding, an HTTP/2 or later message with no `content-length`, or being a streaming
    ;;; body.
    ;;;
    ;;; Note that receiving a length from this function does not guarantee that the full number of
    ;;; bytes can actually be read from the body. For example, when proxying a response from a
    ;;; backend, this length may reflect the `content-length` promised in the response, but if the
    ;;; backend connection is closed prematurely, fewer bytes may be delivered before this body
    ;;; handle can no longer be read.
    (@interface func (export "known_length")
        (param $h $body_handle)
        (result $err (expected $body_length (error $fastly_status)))
    )
)

(module $fastly_log
    (@interface func (export "endpoint_get")
        (param $name (list u8))
        (result $err (expected $endpoint_handle (error $fastly_status)))
    )

    (@interface func (export "write")
        (param $h $endpoint_handle)
        (param $msg (list u8))
        (result $err (expected $num_bytes (error $fastly_status)))
    )
)

(module $fastly_http_req
    (@interface func (export "body_downstream_get")
        (result $err (expected
                (tuple $request_handle $body_handle)
                (error $fastly_status)))
    )

    (@interface func (export "cache_override_set")
        (param $h $request_handle)
        (param $tag $cache_override_tag)
        (param $ttl u32)
        (param $stale_while_revalidate u32)
        (result $err (expected (error $fastly_status)))
    )

    (@interface func (export "cache_override_v2_set")
        (param $h $request_handle)
        (param $tag $cache_override_tag)
        (param $ttl u32)
        (param $stale_while_revalidate u32)
        (param $sk (list u8))
        (result $err (expected (error $fastly_status)))
    )

    (@interface func (export "downstream_client_ip_addr")
        ;; must be a 16-byte array
        (param $addr_octets_out (@witx pointer (@witx char8)))
        (result $err (expected $num_bytes (error $fastly_status)))
    )

    (@interface func (export "downstream_client_h2_fingerprint")
        (param $h2fp_out (@witx pointer (@witx char8)))
        (param $h2fp_max_len (@witx usize))
        (param $nwritten_out (@witx pointer (@witx usize)))
        (result $err (expected (error $fastly_status)))
    )

    (@interface func (export "downstream_client_request_id")
        (param $reqid_out (@witx pointer (@witx char8)))
        (param $reqid_max_len (@witx usize))
        (param $nwritten_out (@witx pointer (@witx usize)))
        (result $err (expected (error $fastly_status)))
    )

    (@interface func (export "downstream_client_oh_fingerprint")
        (param $ohfp_out (@witx pointer (@witx char8)))
        (param $ohfp_max_len (@witx usize))
        (param $nwritten_out (@witx pointer (@witx usize)))
        (result $err (expected (error $fastly_status)))
    )

    (@interface func (export "downstream_tls_cipher_openssl_name")
        (param $cipher_out (@witx pointer (@witx char8)))
        (param $cipher_max_len (@witx usize))
        (param $nwritten_out (@witx pointer (@witx usize)))
        (result $err (expected (error $fastly_status)))
    )

    (@interface func (export "downstream_tls_protocol")
        (param $protocol_out (@witx pointer (@witx char8)))
        (param $protocol_max_len (@witx usize))
        (param $nwritten_out (@witx pointer (@witx usize)))
        (result $err (expected (error $fastly_status)))
    )

    (@interface func (export "downstream_tls_client_hello")
        (param $chello_out (@witx pointer (@witx char8)))
        (param $chello_max_len (@witx usize))
        (param $nwritten_out (@witx pointer (@witx usize)))
        (result $err (expected (error $fastly_status)))
    )

    (@interface func (export "downstream_tls_raw_client_certificate")
        (param $raw_client_cert_out (@witx pointer (@witx char8)))
        (param $raw_client_cert_max_len (@witx usize))
        (param $nwritten_out (@witx pointer (@witx usize)))
        (result $err (expected (error $fastly_status)))
    )

    (@interface func (export "downstream_tls_client_cert_verify_result")
        (result $err (expected $client_cert_verify_result (error $fastly_status)))
    )

    (@interface func (export "downstream_tls_ja3_md5")
        ;; must be a 16-byte array
        (param $cja3_md5_out (@witx pointer (@witx char8)))
        (result $err (expected $num_bytes (error $fastly_status)))
    )

    (@interface func (export "downstream_tls_ja4")
        (param $ja4_out (@witx pointer (@witx char8)))
        (param $ja4_max_len (@witx usize))
        (param $nwritten_out (@witx pointer (@witx usize)))
        (result $err (expected (error $fastly_status)))
    )

    (@interface func (export "new")
        (result $err (expected $request_handle (error $fastly_status)))
    )

    (@interface func (export "header_names_get")
        (param $h $request_handle)
        (param $buf (@witx pointer (@witx char8)))
        (param $buf_len (@witx usize))
        (param $cursor $multi_value_cursor)
        (param $ending_cursor_out (@witx pointer $multi_value_cursor_result))
        (param $nwritten_out (@witx pointer (@witx usize)))
        (result $err (expected (error $fastly_status)))
    )

    (@interface func (export "original_header_names_get")
        (param $buf (@witx pointer (@witx char8)))
        (param $buf_len (@witx usize))
        (param $cursor $multi_value_cursor)
        (param $ending_cursor_out (@witx pointer $multi_value_cursor_result))
        (param $nwritten_out (@witx pointer (@witx usize)))
        (result $err (expected (error $fastly_status)))
    )

    (@interface func (export "original_header_count")
        (result $err (expected $header_count (error $fastly_status)))
    )

    (@interface func (export "header_value_get")
        (param $h $request_handle)
        (param $name (list u8))
        (param $value (@witx pointer (@witx char8)))
        (param $value_max_len (@witx usize))
        (param $nwritten_out (@witx pointer (@witx usize)))
        (result $err (expected (error $fastly_status)))
    )

    (@interface func (export "header_values_get")
        (param $h $request_handle)
        (param $name (list u8))
        (param $buf (@witx pointer (@witx char8)))
        (param $buf_len (@witx usize))
        (param $cursor $multi_value_cursor)
        (param $ending_cursor_out (@witx pointer $multi_value_cursor_result))
        (param $nwritten_out (@witx pointer (@witx usize)))
        (result $err (expected (error $fastly_status)))
    )

    (@interface func (export "header_values_set")
        (param $h $request_handle)
        (param $name (list u8))
        ;;; contains multiple values separated by \0
        (param $values (list (@witx char8)))
        (result $err (expected (error $fastly_status)))
    )

    (@interface func (export "header_insert")
        (param $h $request_handle)
        (param $name (list u8))
        (param $value (list u8))
        (result $err (expected (error $fastly_status)))
    )

    (@interface func (export "header_append")
        (param $h $request_handle)
        (param $name (list u8))
        (param $value (list u8))
        (result $err (expected (error $fastly_status)))
    )

    (@interface func (export "header_remove")
        (param $h $request_handle)
        (param $name (list u8))
        (result $err (expected (error $fastly_status)))
    )

    (@interface func (export "method_get")
        (param $h $request_handle)
        (param $buf (@witx pointer (@witx char8)))
        (param $buf_len (@witx usize))
        (param $nwritten_out (@witx pointer (@witx usize)))
        (result $err (expected (error $fastly_status)))
    )

    (@interface func (export "method_set")
        (param $h $request_handle)
        (param $method string)
        (result $err (expected (error $fastly_status)))
    )

    (@interface func (export "uri_get")
        (param $h $request_handle)
        (param $buf (@witx pointer (@witx char8)))
        (param $buf_len (@witx usize))
        (param $nwritten_out (@witx pointer (@witx usize)))
        (result $err (expected (error $fastly_status)))
    )

    (@interface func (export "uri_set")
        (param $h $request_handle)
        (param $uri string)
        (result $err (expected (error $fastly_status)))
    )

    (@interface func (export "version_get")
        (param $h $request_handle)
        (result $err (expected $http_version (error $fastly_status)))
    )

    (@interface func (export "version_set")
        (param $h $request_handle)
        (param $version $http_version)
        (result $err (expected (error $fastly_status)))
    )

    (@interface func (export "send")
        (param $h $request_handle)
        (param $b $body_handle)
        (param $backend string)
        (result $err (expected
                (tuple $response_handle $body_handle)
                (error $fastly_status)))
    )

    ;; The behavior of this method is identical to the original except for the `$error_detail`
    ;; out-parameter.
    ;;
    ;; If the returned `$fastly_status` is OK, `$error_detail` will not be read. Otherwise,
    ;; the status is returned identically to the original `send`, but `$error_detail` is populated.
    ;; Since `$send_error_detail` provides much more granular information about failures, it should
    ;; be used by SDKs as the primary source of error information in favor of `$fastly_status`.
    ;;
    ;; Make sure to initialize `$error_detail` with the full complement of mask values that the
    ;; guest supports. If the corresponding bits in the mask are not set, the host will not populate
    ;; fields in the `$error_detail` struct even if there are values available for those fields.
    ;; This allows forward compatibility when new fields are added.
    (@interface func (export "send_v2")
        (param $h $request_handle)
        (param $b $body_handle)
        (param $backend string)
        (param $error_detail (@witx pointer $send_error_detail))
        (result $err (expected
                (tuple $response_handle $body_handle)
                (error $fastly_status)))
    )

    (@interface func (export "send_async")
        (param $h $request_handle)
        (param $b $body_handle)
        (param $backend string)
        (result $err (expected $pending_request_handle
                (error $fastly_status)))
    )

    (@interface func (export "send_async_streaming")
        (param $h $request_handle)
        (param $b $body_handle)
        (param $backend string)
        (result $err (expected $pending_request_handle (error $fastly_status)))
    )

    (@interface func (export "pending_req_poll")
        (param $h $pending_request_handle)
        (result $err (expected
                (tuple $is_done
                    $response_handle
                    $body_handle)
                (error $fastly_status)))
    )

    ;; See `send_v2` for an explanation of the `$error_detail` out-parameter.
    (@interface func (export "pending_req_poll_v2")
        (param $h $pending_request_handle)
        (param $error_detail (@witx pointer $send_error_detail))
        (result $err (expected
                (tuple $is_done
                    $response_handle
                    $body_handle)
                (error $fastly_status)))
    )

    (@interface func (export "pending_req_wait")
        (param $h $pending_request_handle)
        (result $err (expected
                (tuple $response_handle $body_handle)
                (error $fastly_status)))
    )

    ;; See `send_v2` for an explanation of the `$error_detail` out-parameter.
    (@interface func (export "pending_req_wait_v2")
        (param $h $pending_request_handle)
        (param $error_detail (@witx pointer $send_error_detail))
        (result $err (expected
                (tuple $response_handle $body_handle)
                (error $fastly_status)))
    )

    (@interface func (export "pending_req_select")
        (param $hs (list $pending_request_handle))
        (result $err (expected
                (tuple $done_idx $response_handle $body_handle)
                (error $fastly_status)))
    )

    ;; See `send_v2` for an explanation of the `$error_detail` out-parameter.
    (@interface func (export "pending_req_select_v2")
        (param $hs (list $pending_request_handle))
        (param $error_detail (@witx pointer $send_error_detail))
        (result $err (expected
                (tuple $done_idx $response_handle $body_handle)
                (error $fastly_status)))
    )

    ;;; Returns whether or not the original client request arrived with a
    ;;; Fastly-Key belonging to a user with the rights to purge content on this
    ;;; service.
    (@interface func (export "fastly_key_is_valid")
        (result $err (expected $is_valid (error $fastly_status)))
    )

    (@interface func (export "close")
        (param $h $request_handle)
        (result $err (expected (error $fastly_status)))
    )

    (@interface func (export "auto_decompress_response_set")
        (param $h $request_handle)
        (param $encodings $content_encodings)
        (result $err (expected (error $fastly_status)))
    )

    (@interface func (export "upgrade_websocket")
        (param $backend_name string)
        (result $err (expected (error $fastly_status)))
    )

    (@interface func (export "redirect_to_websocket_proxy")
        (param $backend_name string)
        (result $err (expected (error $fastly_status)))
    )

    (@interface func (export "redirect_to_grip_proxy")
        (param $backend_name string)
        (result $err (expected (error $fastly_status)))
    )

    (@interface func (export "redirect_to_websocket_proxy_v2")
        (param $h $request_handle)
        (param $backend_name string)
        (result $err (expected (error $fastly_status)))
    )

    (@interface func (export "redirect_to_grip_proxy_v2")
        (param $h $request_handle)
        (param $backend_name string)
        (result $err (expected (error $fastly_status)))
    )

    ;;; Adjust how this requests's framing headers are determined.
    (@interface func (export "framing_headers_mode_set")
        (param $h $request_handle)
        (param $mode $framing_headers_mode)
        (result $err (expected (error $fastly_status)))
    )

    ;;; Create a backend for later use
    (@interface func (export "register_dynamic_backend")
        (param $name_prefix string)
        (param $target string)
        (param $backend_config_mask $backend_config_options)
        (param $backend_configuration (@witx pointer $dynamic_backend_config))
        (result $err (expected (error $fastly_status)))
    )
)

(module $fastly_http_resp
    (@interface func (export "new")
        (result $err (expected $response_handle (error $fastly_status)))
    )

    ;; The following directly mirror header & version methods on req

    (@interface func (export "header_names_get")
        (param $h $response_handle)
        (param $buf (@witx pointer (@witx char8)))
        (param $buf_len (@witx usize))
        (param $cursor $multi_value_cursor)
        (param $ending_cursor_out (@witx pointer $multi_value_cursor_result))
        (param $nwritten_out (@witx pointer (@witx usize)))
        (result $err (expected (error $fastly_status)))
    )

    (@interface func (export "header_value_get")
        (param $h $response_handle)
        (param $name (list u8))
        (param $value (@witx pointer (@witx char8)))
        (param $value_max_len (@witx usize))
        (param $nwritten_out (@witx pointer (@witx usize)))
        (result $err (expected (error $fastly_status)))
    )

    (@interface func (export "header_values_get")
        (param $h $response_handle)
        (param $name (list u8))
        (param $buf (@witx pointer (@witx char8)))
        (param $buf_len (@witx usize))
        (param $cursor $multi_value_cursor)
        (param $ending_cursor_out (@witx pointer $multi_value_cursor_result))
        (param $nwritten_out (@witx pointer (@witx usize)))
        (result $err (expected (error $fastly_status)))
    )

    (@interface func (export "header_values_set")
        (param $h $response_handle)
        (param $name (list u8))
        ;;; contains multiple values separated by \0
        (param $values (list (@witx char8)))
        (result $err (expected (error $fastly_status)))
    )

    (@interface func (export "header_insert")
        (param $h $response_handle)
        (param $name (list u8))
        (param $value (list u8))
        (result $err (expected (error $fastly_status)))
    )

    (@interface func (export "header_append")
        (param $h $response_handle)
        (param $name (list u8))
        (param $value (list u8))
        (result $err (expected (error $fastly_status)))
    )

    (@interface func (export "header_remove")
        (param $h $response_handle)
        (param $name (list u8))
        (result $err (expected (error $fastly_status)))
    )

    (@interface func (export "version_get")
        (param $h $response_handle)
        (result $err (expected $http_version (error $fastly_status)))
    )

    (@interface func (export "version_set")
        (param $h $response_handle)
        (param $version $http_version)
        (result $err (expected (error $fastly_status)))
    )
    ;; End directly mirror header & version methods on req

    (@interface func (export "send_downstream")
        (param $h $response_handle)
        (param $b $body_handle)
        (param $streaming u32)
        (result $err (expected (error $fastly_status)))
    )

    (@interface func (export "status_get")
        (param $h $response_handle)
        (result $err (expected $http_status (error $fastly_status)))
    )

    (@interface func (export "status_set")
        (param $h $response_handle)
        (param $status $http_status)
        (result $err (expected (error $fastly_status)))
    )

    (@interface func (export "close")
        (param $h $response_handle)
        (result $err (expected (error $fastly_status)))
    )

    ;;; Adjust how this response's framing headers are determined.
    (@interface func (export "framing_headers_mode_set")
        (param $h $response_handle)
        (param $mode $framing_headers_mode)
        (result $err (expected (error $fastly_status)))
    )

    ;;; Adjust the response's connection reuse mode.
    (@interface func (export "http_keepalive_mode_set")
        (param $h $response_handle)
        (param $mode $http_keepalive_mode)
        (result $err (expected (error $fastly_status)))
    )
)

(module $fastly_dictionary
    (@interface func (export "open")
        (param $name string)
        (result $err (expected $dictionary_handle (error $fastly_status)))
    )

    (@interface func (export "get")
        (param $h $dictionary_handle)
        (param $key string)
        (param $value (@witx pointer (@witx char8)))
        (param $value_max_len (@witx usize))
        (result $err (expected $num_bytes (error $fastly_status)))
    )
)

(module $fastly_geo
    (@interface func (export "lookup")
        (param $addr_octets (@witx const_pointer (@witx char8)))
        (param $addr_len (@witx usize))
        (param $buf (@witx pointer (@witx char8)))
        (param $buf_len (@witx usize))
        (param $nwritten_out (@witx pointer (@witx usize)))
        (result $err (expected (error $fastly_status)))
    )
)

(module $fastly_device_detection
    (@interface func (export "lookup")
        (param $user_agent string)

        (param $buf (@witx pointer (@witx char8)))
        (param $buf_len (@witx usize))
        (param $nwritten_out (@witx pointer (@witx usize)))
        (result $err (expected (error $fastly_status)))
    )
)

(module $fastly_erl
    (@interface func (export "check_rate")
        (param $rc string)
        (param $entry string)
        (param $delta u32)
        (param $window u32)
        (param $limit u32)
        (param $pb string)
        (param $ttl u32)

        (result $err (expected $blocked (error $fastly_status)))
    )

    (@interface func (export "ratecounter_increment")
        (param $rc string)
        (param $entry string)
        (param $delta u32)

        (result $err (expected (error $fastly_status)))
    )

    (@interface func (export "ratecounter_lookup_rate")
        (param $rc string)
        (param $entry string)
        (param $window u32)

        (result $err (expected $rate (error $fastly_status)))
    )

    (@interface func (export "ratecounter_lookup_count")
        (param $rc string)
        (param $entry string)
        (param $duration u32)

        (result $err (expected $count (error $fastly_status)))
    )

    (@interface func (export "penaltybox_add")
        (param $pb string)
        (param $entry string)
        (param $ttl u32)

        (result $err (expected (error $fastly_status)))
    )

    (@interface func (export "penaltybox_has")
        (param $pb string)
        (param $entry string)

        (result $err (expected $has (error $fastly_status)))
    )
)

(module $fastly_object_store
    (@interface func (export "open")
        (param $name string)
        (result $err (expected $object_store_handle (error $fastly_status)))
    )

    (@interface func (export "lookup")
        (param $store $object_store_handle)
        (param $key string)
        (param $body_handle_out (@witx pointer $body_handle))
        (result $err (expected (error $fastly_status)))
    )

    (@interface func (export "lookup_async")
        (param $store $object_store_handle)
        (param $key string)
        (param $pending_handle_out (@witx pointer $pending_object_store_lookup_handle))
        (result $err (expected (error $fastly_status)))
    )

    (@interface func (export "pending_lookup_wait")
        (param $pending_objstr_handle $pending_object_store_lookup_handle)
        (param $body_handle_out (@witx pointer $body_handle))
        (result $err (expected (error $fastly_status)))
    )

    ;; NOTE: this is not yet a public interface, and should not be included in the Viceroy ABIs
    (@interface func (export "lookup_as_fd")
        (param $store $object_store_handle)
        (param $key string)
        (param $fd_out (@witx pointer u32))
        (result $err (expected (error $fastly_status)))
    )

    (@interface func (export "insert")
        (param $store $object_store_handle)
        (param $key string)
        (param $body_handle $body_handle)
        (result $err (expected (error $fastly_status)))
    )

    (@interface func (export "insert_async")
        (param $store $object_store_handle)
        (param $key string)
        (param $body_handle $body_handle)
        (param $pending_handle_out (@witx pointer $pending_object_store_insert_handle))
        (result $err (expected (error $fastly_status)))
    )

    (@interface func (export "pending_insert_wait")
        (param $pending_objstr_handle $pending_object_store_insert_handle)
        (result $err (expected (error $fastly_status)))
    )

    (@interface func (export "delete_async")
        (param $store $object_store_handle)
        (param $key string)
        (param $pending_handle_out (@witx pointer $pending_object_store_delete_handle))
        (result $err (expected (error $fastly_status)))
    )

    (@interface func (export "pending_delete_wait")
        (param $pending_objstr_handle $pending_object_store_delete_handle)
        (result $err (expected (error $fastly_status)))
    )
)

(module $fastly_secret_store
    (@interface func (export "open")
        (param $name string)
        (result $err (expected $secret_store_handle (error $fastly_status)))
    )

    (@interface func (export "get")
        (param $store $secret_store_handle)
        (param $key string)
        (result $err (expected $secret_handle (error $fastly_status)))
    )

    (@interface func (export "plaintext")
        (param $secret $secret_handle)
        (param $buf (@witx pointer (@witx char8)))
        (param $buf_len (@witx usize))
        (param $nwritten_out (@witx pointer (@witx usize)))
        (result $err (expected (error $fastly_status)))
    )

    (@interface func (export "from_bytes")
        (param $buf (@witx pointer (@witx char8)))
        (param $buf_len (@witx usize))
        (result $err (expected $secret_handle (error $fastly_status)))
    )
)

(module $fastly_backend
    ;; Returns 1 if a backend with this name exists.
    (@interface func (export "exists")
        (param $backend string)
        (result $err (expected
                $backend_exists
                (error $fastly_status)))
    )

    (@interface func (export "is_healthy")
        (param $backend string)
        (result $err (expected $backend_health (error $fastly_status)))
    )

    ;; Returns 1 if the backend is a "dynamic" backend.
    (@interface func (export "is_dynamic")
        (param $backend string)
        (result $err (expected $is_dynamic (error $fastly_status)))
    )

    ;; Get the host of this backend.
    (@interface func (export "get_host")
        (param $backend string)
        (param $value (@witx pointer (@witx char8)))
        (param $value_max_len (@witx usize))
        (param $nwritten_out (@witx pointer (@witx usize)))
        (result $err (expected (error $fastly_status)))
    )

    ;; Get the "override host" for this backend.
    ;;
    ;; This is used to change the `Host` header sent to the backend. See the Fastly documentation
    ;; on this topic here: https://docs.fastly.com/en/guides/specifying-an-override-host
    (@interface func (export "get_override_host")
        (param $backend string)
        (param $value (@witx pointer (@witx char8)))
        (param $value_max_len (@witx usize))
        (param $nwritten_out (@witx pointer (@witx usize)))
        (result $err (expected (error $fastly_status)))
    )

    ;; Get the remote TCP port of the backend connection for the request.
    (@interface func (export "get_port")
        (param $backend string)
        (result $err (expected
                $port
                (error $fastly_status)))
    )

    ;; Get the connection timeout of the backend.
    (@interface func (export "get_connect_timeout_ms")
        (param $backend string)
        (result $err (expected
                $timeout_ms
                (error $fastly_status)))
    )

    ;; Get the first byte timeout of the backend.
    (@interface func (export "get_first_byte_timeout_ms")
        (param $backend string)
        (result $err (expected
                $timeout_ms
                (error $fastly_status)))
    )

    ;; Get the between byte timeout of the backend.
    (@interface func (export "get_between_bytes_timeout_ms")
        (param $backend string)
        (result $err (expected
                $timeout_ms
                (error $fastly_status)))
    )

    ;; Returns 1 if the backend is configured to use SSL.
    (@interface func (export "is_ssl")
        (param $backend string)
        (result $err (expected $is_ssl (error $fastly_status)))
    )

    ;; Get the minimum SSL version this backend will use.
    (@interface func (export "get_ssl_min_version")
        (param $backend string)
        (result $err (expected $tls_version (error $fastly_status)))
    )

    ;; Get the maximum SSL version this backend will use.
    (@interface func (export "get_ssl_max_version")
        (param $backend string)
        (result $err (expected $tls_version (error $fastly_status)))
    )
)

(module $fastly_async_io
    ;;; Blocks until one of the given objects is ready for I/O, or the optional timeout expires.
    ;;;
    ;;; Valid object handles includes bodies and pending requests. See the `async_item_handle`
    ;;; definition for more details, including what I/O actions are associated with each handle
    ;;; type.
    ;;;
    ;;; The timeout is specified in milliseconds, or 0 if no timeout is desired.
    ;;;
    ;;; Returns the _index_ (not handle!) of the first object that is ready, or u32::MAX if the
    ;;; timeout expires before any objects are ready for I/O.
    (@interface func (export "select")
        (param $hs (list $async_item_handle))
        (param $timeout_ms u32)
        (result $err (expected $ready_idx (error $fastly_status)))
    )

    ;;; Returns 1 if the given async item is "ready" for its associated I/O action, 0 otherwise.
    ;;;
    ;;; If an object is ready, the I/O action is guaranteed to complete without blocking.
    ;;;
    ;;; Valid object handles includes bodies and pending requests. See the `async_item_handle`
    ;;; definition for more details, including what I/O actions are associated with each handle
    ;;; type.
    (@interface func (export "is_ready")
        (param $handle $async_item_handle)
        (result $err (expected $is_done (error $fastly_status)))
    )
)

(module $fastly_purge
    (@interface func (export "purge_surrogate_key")
        (param $surrogate_key string)
        (param $options_mask $purge_options_mask)
        (param $options (@witx pointer $purge_options))
        (result $err (expected (error $fastly_status)))
    )
)