// Code generated by wit-bindgen-go. DO NOT EDIT.

// Package types represents the imported interface "wasi:http/types@0.2.0".
package types

import (
	monotonicclock "gitea.rebus.ninja/lore/wasm-nats-stream-client/gen/wasi/clocks/monotonic-clock"
	ioerror "gitea.rebus.ninja/lore/wasm-nats-stream-client/gen/wasi/io/error"
	"gitea.rebus.ninja/lore/wasm-nats-stream-client/gen/wasi/io/poll"
	"gitea.rebus.ninja/lore/wasm-nats-stream-client/gen/wasi/io/streams"
	"github.com/bytecodealliance/wasm-tools-go/cm"
)

// Duration represents the type alias "wasi:http/types@0.2.0#duration".
//
// See [monotonicclock.Duration] for more information.
type Duration = monotonicclock.Duration

// InputStream represents the imported type alias "wasi:http/types@0.2.0#input-stream".
//
// See [streams.InputStream] for more information.
type InputStream = streams.InputStream

// OutputStream represents the imported type alias "wasi:http/types@0.2.0#output-stream".
//
// See [streams.OutputStream] for more information.
type OutputStream = streams.OutputStream

// IOError represents the imported type alias "wasi:http/types@0.2.0#io-error".
//
// See [ioerror.Error] for more information.
type IOError = ioerror.Error

// Pollable represents the imported type alias "wasi:http/types@0.2.0#pollable".
//
// See [poll.Pollable] for more information.
type Pollable = poll.Pollable

// Method represents the variant "wasi:http/types@0.2.0#method".
//
//	variant method {
//		get,
//		head,
//		post,
//		put,
//		delete,
//		connect,
//		options,
//		trace,
//		patch,
//		other(string),
//	}
type Method cm.Variant[uint8, string, string]

// MethodGet returns a [Method] of case "get".
func MethodGet() Method {
	var data struct{}
	return cm.New[Method](0, data)
}

// Get returns true if [Method] represents the variant case "get".
func (self *Method) Get() bool {
	return self.Tag() == 0
}

// MethodHead returns a [Method] of case "head".
func MethodHead() Method {
	var data struct{}
	return cm.New[Method](1, data)
}

// Head returns true if [Method] represents the variant case "head".
func (self *Method) Head() bool {
	return self.Tag() == 1
}

// MethodPost returns a [Method] of case "post".
func MethodPost() Method {
	var data struct{}
	return cm.New[Method](2, data)
}

// Post returns true if [Method] represents the variant case "post".
func (self *Method) Post() bool {
	return self.Tag() == 2
}

// MethodPut returns a [Method] of case "put".
func MethodPut() Method {
	var data struct{}
	return cm.New[Method](3, data)
}

// Put returns true if [Method] represents the variant case "put".
func (self *Method) Put() bool {
	return self.Tag() == 3
}

// MethodDelete returns a [Method] of case "delete".
func MethodDelete() Method {
	var data struct{}
	return cm.New[Method](4, data)
}

// Delete returns true if [Method] represents the variant case "delete".
func (self *Method) Delete() bool {
	return self.Tag() == 4
}

// MethodConnect returns a [Method] of case "connect".
func MethodConnect() Method {
	var data struct{}
	return cm.New[Method](5, data)
}

// Connect returns true if [Method] represents the variant case "connect".
func (self *Method) Connect() bool {
	return self.Tag() == 5
}

// MethodOptions returns a [Method] of case "options".
func MethodOptions() Method {
	var data struct{}
	return cm.New[Method](6, data)
}

// Options returns true if [Method] represents the variant case "options".
func (self *Method) Options() bool {
	return self.Tag() == 6
}

// MethodTrace returns a [Method] of case "trace".
func MethodTrace() Method {
	var data struct{}
	return cm.New[Method](7, data)
}

// Trace returns true if [Method] represents the variant case "trace".
func (self *Method) Trace() bool {
	return self.Tag() == 7
}

// MethodPatch returns a [Method] of case "patch".
func MethodPatch() Method {
	var data struct{}
	return cm.New[Method](8, data)
}

// Patch returns true if [Method] represents the variant case "patch".
func (self *Method) Patch() bool {
	return self.Tag() == 8
}

// MethodOther returns a [Method] of case "other".
func MethodOther(data string) Method {
	return cm.New[Method](9, data)
}

// Other returns a non-nil *[string] if [Method] represents the variant case "other".
func (self *Method) Other() *string {
	return cm.Case[string](self, 9)
}

var stringsMethod = [10]string{
	"get",
	"head",
	"post",
	"put",
	"delete",
	"connect",
	"options",
	"trace",
	"patch",
	"other",
}

// String implements [fmt.Stringer], returning the variant case name of v.
func (v Method) String() string {
	return stringsMethod[v.Tag()]
}

// Scheme represents the variant "wasi:http/types@0.2.0#scheme".
//
//	variant scheme {
//		HTTP,
//		HTTPS,
//		other(string),
//	}
type Scheme cm.Variant[uint8, string, string]

// SchemeHTTP returns a [Scheme] of case "HTTP".
func SchemeHTTP() Scheme {
	var data struct{}
	return cm.New[Scheme](0, data)
}

// HTTP returns true if [Scheme] represents the variant case "HTTP".
func (self *Scheme) HTTP() bool {
	return self.Tag() == 0
}

// SchemeHTTPS returns a [Scheme] of case "HTTPS".
func SchemeHTTPS() Scheme {
	var data struct{}
	return cm.New[Scheme](1, data)
}

// HTTPS returns true if [Scheme] represents the variant case "HTTPS".
func (self *Scheme) HTTPS() bool {
	return self.Tag() == 1
}

// SchemeOther returns a [Scheme] of case "other".
func SchemeOther(data string) Scheme {
	return cm.New[Scheme](2, data)
}

// Other returns a non-nil *[string] if [Scheme] represents the variant case "other".
func (self *Scheme) Other() *string {
	return cm.Case[string](self, 2)
}

var stringsScheme = [3]string{
	"HTTP",
	"HTTPS",
	"other",
}

// String implements [fmt.Stringer], returning the variant case name of v.
func (v Scheme) String() string {
	return stringsScheme[v.Tag()]
}

// DNSErrorPayload represents the record "wasi:http/types@0.2.0#DNS-error-payload".
//
//	record DNS-error-payload {
//		rcode: option<string>,
//		info-code: option<u16>,
//	}
type DNSErrorPayload struct {
	_        cm.HostLayout
	Rcode    cm.Option[string]
	InfoCode cm.Option[uint16]
}

// TLSAlertReceivedPayload represents the record "wasi:http/types@0.2.0#TLS-alert-received-payload".
//
//	record TLS-alert-received-payload {
//		alert-id: option<u8>,
//		alert-message: option<string>,
//	}
type TLSAlertReceivedPayload struct {
	_            cm.HostLayout
	AlertID      cm.Option[uint8]
	AlertMessage cm.Option[string]
}

// FieldSizePayload represents the record "wasi:http/types@0.2.0#field-size-payload".
//
//	record field-size-payload {
//		field-name: option<string>,
//		field-size: option<u32>,
//	}
type FieldSizePayload struct {
	_         cm.HostLayout
	FieldName cm.Option[string]
	FieldSize cm.Option[uint32]
}

// ErrorCode represents the variant "wasi:http/types@0.2.0#error-code".
//
//	variant error-code {
//		DNS-timeout,
//		DNS-error(DNS-error-payload),
//		destination-not-found,
//		destination-unavailable,
//		destination-IP-prohibited,
//		destination-IP-unroutable,
//		connection-refused,
//		connection-terminated,
//		connection-timeout,
//		connection-read-timeout,
//		connection-write-timeout,
//		connection-limit-reached,
//		TLS-protocol-error,
//		TLS-certificate-error,
//		TLS-alert-received(TLS-alert-received-payload),
//		HTTP-request-denied,
//		HTTP-request-length-required,
//		HTTP-request-body-size(option<u64>),
//		HTTP-request-method-invalid,
//		HTTP-request-URI-invalid,
//		HTTP-request-URI-too-long,
//		HTTP-request-header-section-size(option<u32>),
//		HTTP-request-header-size(option<field-size-payload>),
//		HTTP-request-trailer-section-size(option<u32>),
//		HTTP-request-trailer-size(field-size-payload),
//		HTTP-response-incomplete,
//		HTTP-response-header-section-size(option<u32>),
//		HTTP-response-header-size(field-size-payload),
//		HTTP-response-body-size(option<u64>),
//		HTTP-response-trailer-section-size(option<u32>),
//		HTTP-response-trailer-size(field-size-payload),
//		HTTP-response-transfer-coding(option<string>),
//		HTTP-response-content-coding(option<string>),
//		HTTP-response-timeout,
//		HTTP-upgrade-failed,
//		HTTP-protocol-error,
//		loop-detected,
//		configuration-error,
//		internal-error(option<string>),
//	}
type ErrorCode cm.Variant[uint8, OptionFieldSizePayloadShape, cm.Option[uint64]]

// ErrorCodeDNSTimeout returns a [ErrorCode] of case "DNS-timeout".
func ErrorCodeDNSTimeout() ErrorCode {
	var data struct{}
	return cm.New[ErrorCode](0, data)
}

// DNSTimeout returns true if [ErrorCode] represents the variant case "DNS-timeout".
func (self *ErrorCode) DNSTimeout() bool {
	return self.Tag() == 0
}

// ErrorCodeDNSError returns a [ErrorCode] of case "DNS-error".
func ErrorCodeDNSError(data DNSErrorPayload) ErrorCode {
	return cm.New[ErrorCode](1, data)
}

// DNSError returns a non-nil *[DNSErrorPayload] if [ErrorCode] represents the variant case "DNS-error".
func (self *ErrorCode) DNSError() *DNSErrorPayload {
	return cm.Case[DNSErrorPayload](self, 1)
}

// ErrorCodeDestinationNotFound returns a [ErrorCode] of case "destination-not-found".
func ErrorCodeDestinationNotFound() ErrorCode {
	var data struct{}
	return cm.New[ErrorCode](2, data)
}

// DestinationNotFound returns true if [ErrorCode] represents the variant case "destination-not-found".
func (self *ErrorCode) DestinationNotFound() bool {
	return self.Tag() == 2
}

// ErrorCodeDestinationUnavailable returns a [ErrorCode] of case "destination-unavailable".
func ErrorCodeDestinationUnavailable() ErrorCode {
	var data struct{}
	return cm.New[ErrorCode](3, data)
}

// DestinationUnavailable returns true if [ErrorCode] represents the variant case "destination-unavailable".
func (self *ErrorCode) DestinationUnavailable() bool {
	return self.Tag() == 3
}

// ErrorCodeDestinationIPProhibited returns a [ErrorCode] of case "destination-IP-prohibited".
func ErrorCodeDestinationIPProhibited() ErrorCode {
	var data struct{}
	return cm.New[ErrorCode](4, data)
}

// DestinationIPProhibited returns true if [ErrorCode] represents the variant case "destination-IP-prohibited".
func (self *ErrorCode) DestinationIPProhibited() bool {
	return self.Tag() == 4
}

// ErrorCodeDestinationIPUnroutable returns a [ErrorCode] of case "destination-IP-unroutable".
func ErrorCodeDestinationIPUnroutable() ErrorCode {
	var data struct{}
	return cm.New[ErrorCode](5, data)
}

// DestinationIPUnroutable returns true if [ErrorCode] represents the variant case "destination-IP-unroutable".
func (self *ErrorCode) DestinationIPUnroutable() bool {
	return self.Tag() == 5
}

// ErrorCodeConnectionRefused returns a [ErrorCode] of case "connection-refused".
func ErrorCodeConnectionRefused() ErrorCode {
	var data struct{}
	return cm.New[ErrorCode](6, data)
}

// ConnectionRefused returns true if [ErrorCode] represents the variant case "connection-refused".
func (self *ErrorCode) ConnectionRefused() bool {
	return self.Tag() == 6
}

// ErrorCodeConnectionTerminated returns a [ErrorCode] of case "connection-terminated".
func ErrorCodeConnectionTerminated() ErrorCode {
	var data struct{}
	return cm.New[ErrorCode](7, data)
}

// ConnectionTerminated returns true if [ErrorCode] represents the variant case "connection-terminated".
func (self *ErrorCode) ConnectionTerminated() bool {
	return self.Tag() == 7
}

// ErrorCodeConnectionTimeout returns a [ErrorCode] of case "connection-timeout".
func ErrorCodeConnectionTimeout() ErrorCode {
	var data struct{}
	return cm.New[ErrorCode](8, data)
}

// ConnectionTimeout returns true if [ErrorCode] represents the variant case "connection-timeout".
func (self *ErrorCode) ConnectionTimeout() bool {
	return self.Tag() == 8
}

// ErrorCodeConnectionReadTimeout returns a [ErrorCode] of case "connection-read-timeout".
func ErrorCodeConnectionReadTimeout() ErrorCode {
	var data struct{}
	return cm.New[ErrorCode](9, data)
}

// ConnectionReadTimeout returns true if [ErrorCode] represents the variant case "connection-read-timeout".
func (self *ErrorCode) ConnectionReadTimeout() bool {
	return self.Tag() == 9
}

// ErrorCodeConnectionWriteTimeout returns a [ErrorCode] of case "connection-write-timeout".
func ErrorCodeConnectionWriteTimeout() ErrorCode {
	var data struct{}
	return cm.New[ErrorCode](10, data)
}

// ConnectionWriteTimeout returns true if [ErrorCode] represents the variant case "connection-write-timeout".
func (self *ErrorCode) ConnectionWriteTimeout() bool {
	return self.Tag() == 10
}

// ErrorCodeConnectionLimitReached returns a [ErrorCode] of case "connection-limit-reached".
func ErrorCodeConnectionLimitReached() ErrorCode {
	var data struct{}
	return cm.New[ErrorCode](11, data)
}

// ConnectionLimitReached returns true if [ErrorCode] represents the variant case "connection-limit-reached".
func (self *ErrorCode) ConnectionLimitReached() bool {
	return self.Tag() == 11
}

// ErrorCodeTLSProtocolError returns a [ErrorCode] of case "TLS-protocol-error".
func ErrorCodeTLSProtocolError() ErrorCode {
	var data struct{}
	return cm.New[ErrorCode](12, data)
}

// TLSProtocolError returns true if [ErrorCode] represents the variant case "TLS-protocol-error".
func (self *ErrorCode) TLSProtocolError() bool {
	return self.Tag() == 12
}

// ErrorCodeTLSCertificateError returns a [ErrorCode] of case "TLS-certificate-error".
func ErrorCodeTLSCertificateError() ErrorCode {
	var data struct{}
	return cm.New[ErrorCode](13, data)
}

// TLSCertificateError returns true if [ErrorCode] represents the variant case "TLS-certificate-error".
func (self *ErrorCode) TLSCertificateError() bool {
	return self.Tag() == 13
}

// ErrorCodeTLSAlertReceived returns a [ErrorCode] of case "TLS-alert-received".
func ErrorCodeTLSAlertReceived(data TLSAlertReceivedPayload) ErrorCode {
	return cm.New[ErrorCode](14, data)
}

// TLSAlertReceived returns a non-nil *[TLSAlertReceivedPayload] if [ErrorCode] represents the variant case "TLS-alert-received".
func (self *ErrorCode) TLSAlertReceived() *TLSAlertReceivedPayload {
	return cm.Case[TLSAlertReceivedPayload](self, 14)
}

// ErrorCodeHTTPRequestDenied returns a [ErrorCode] of case "HTTP-request-denied".
func ErrorCodeHTTPRequestDenied() ErrorCode {
	var data struct{}
	return cm.New[ErrorCode](15, data)
}

// HTTPRequestDenied returns true if [ErrorCode] represents the variant case "HTTP-request-denied".
func (self *ErrorCode) HTTPRequestDenied() bool {
	return self.Tag() == 15
}

// ErrorCodeHTTPRequestLengthRequired returns a [ErrorCode] of case "HTTP-request-length-required".
func ErrorCodeHTTPRequestLengthRequired() ErrorCode {
	var data struct{}
	return cm.New[ErrorCode](16, data)
}

// HTTPRequestLengthRequired returns true if [ErrorCode] represents the variant case "HTTP-request-length-required".
func (self *ErrorCode) HTTPRequestLengthRequired() bool {
	return self.Tag() == 16
}

// ErrorCodeHTTPRequestBodySize returns a [ErrorCode] of case "HTTP-request-body-size".
func ErrorCodeHTTPRequestBodySize(data cm.Option[uint64]) ErrorCode {
	return cm.New[ErrorCode](17, data)
}

// HTTPRequestBodySize returns a non-nil *[cm.Option[uint64]] if [ErrorCode] represents the variant case "HTTP-request-body-size".
func (self *ErrorCode) HTTPRequestBodySize() *cm.Option[uint64] {
	return cm.Case[cm.Option[uint64]](self, 17)
}

// ErrorCodeHTTPRequestMethodInvalid returns a [ErrorCode] of case "HTTP-request-method-invalid".
func ErrorCodeHTTPRequestMethodInvalid() ErrorCode {
	var data struct{}
	return cm.New[ErrorCode](18, data)
}

// HTTPRequestMethodInvalid returns true if [ErrorCode] represents the variant case "HTTP-request-method-invalid".
func (self *ErrorCode) HTTPRequestMethodInvalid() bool {
	return self.Tag() == 18
}

// ErrorCodeHTTPRequestURIInvalid returns a [ErrorCode] of case "HTTP-request-URI-invalid".
func ErrorCodeHTTPRequestURIInvalid() ErrorCode {
	var data struct{}
	return cm.New[ErrorCode](19, data)
}

// HTTPRequestURIInvalid returns true if [ErrorCode] represents the variant case "HTTP-request-URI-invalid".
func (self *ErrorCode) HTTPRequestURIInvalid() bool {
	return self.Tag() == 19
}

// ErrorCodeHTTPRequestURITooLong returns a [ErrorCode] of case "HTTP-request-URI-too-long".
func ErrorCodeHTTPRequestURITooLong() ErrorCode {
	var data struct{}
	return cm.New[ErrorCode](20, data)
}

// HTTPRequestURITooLong returns true if [ErrorCode] represents the variant case "HTTP-request-URI-too-long".
func (self *ErrorCode) HTTPRequestURITooLong() bool {
	return self.Tag() == 20
}

// ErrorCodeHTTPRequestHeaderSectionSize returns a [ErrorCode] of case "HTTP-request-header-section-size".
func ErrorCodeHTTPRequestHeaderSectionSize(data cm.Option[uint32]) ErrorCode {
	return cm.New[ErrorCode](21, data)
}

// HTTPRequestHeaderSectionSize returns a non-nil *[cm.Option[uint32]] if [ErrorCode] represents the variant case "HTTP-request-header-section-size".
func (self *ErrorCode) HTTPRequestHeaderSectionSize() *cm.Option[uint32] {
	return cm.Case[cm.Option[uint32]](self, 21)
}

// ErrorCodeHTTPRequestHeaderSize returns a [ErrorCode] of case "HTTP-request-header-size".
func ErrorCodeHTTPRequestHeaderSize(data cm.Option[FieldSizePayload]) ErrorCode {
	return cm.New[ErrorCode](22, data)
}

// HTTPRequestHeaderSize returns a non-nil *[cm.Option[FieldSizePayload]] if [ErrorCode] represents the variant case "HTTP-request-header-size".
func (self *ErrorCode) HTTPRequestHeaderSize() *cm.Option[FieldSizePayload] {
	return cm.Case[cm.Option[FieldSizePayload]](self, 22)
}

// ErrorCodeHTTPRequestTrailerSectionSize returns a [ErrorCode] of case "HTTP-request-trailer-section-size".
func ErrorCodeHTTPRequestTrailerSectionSize(data cm.Option[uint32]) ErrorCode {
	return cm.New[ErrorCode](23, data)
}

// HTTPRequestTrailerSectionSize returns a non-nil *[cm.Option[uint32]] if [ErrorCode] represents the variant case "HTTP-request-trailer-section-size".
func (self *ErrorCode) HTTPRequestTrailerSectionSize() *cm.Option[uint32] {
	return cm.Case[cm.Option[uint32]](self, 23)
}

// ErrorCodeHTTPRequestTrailerSize returns a [ErrorCode] of case "HTTP-request-trailer-size".
func ErrorCodeHTTPRequestTrailerSize(data FieldSizePayload) ErrorCode {
	return cm.New[ErrorCode](24, data)
}

// HTTPRequestTrailerSize returns a non-nil *[FieldSizePayload] if [ErrorCode] represents the variant case "HTTP-request-trailer-size".
func (self *ErrorCode) HTTPRequestTrailerSize() *FieldSizePayload {
	return cm.Case[FieldSizePayload](self, 24)
}

// ErrorCodeHTTPResponseIncomplete returns a [ErrorCode] of case "HTTP-response-incomplete".
func ErrorCodeHTTPResponseIncomplete() ErrorCode {
	var data struct{}
	return cm.New[ErrorCode](25, data)
}

// HTTPResponseIncomplete returns true if [ErrorCode] represents the variant case "HTTP-response-incomplete".
func (self *ErrorCode) HTTPResponseIncomplete() bool {
	return self.Tag() == 25
}

// ErrorCodeHTTPResponseHeaderSectionSize returns a [ErrorCode] of case "HTTP-response-header-section-size".
func ErrorCodeHTTPResponseHeaderSectionSize(data cm.Option[uint32]) ErrorCode {
	return cm.New[ErrorCode](26, data)
}

// HTTPResponseHeaderSectionSize returns a non-nil *[cm.Option[uint32]] if [ErrorCode] represents the variant case "HTTP-response-header-section-size".
func (self *ErrorCode) HTTPResponseHeaderSectionSize() *cm.Option[uint32] {
	return cm.Case[cm.Option[uint32]](self, 26)
}

// ErrorCodeHTTPResponseHeaderSize returns a [ErrorCode] of case "HTTP-response-header-size".
func ErrorCodeHTTPResponseHeaderSize(data FieldSizePayload) ErrorCode {
	return cm.New[ErrorCode](27, data)
}

// HTTPResponseHeaderSize returns a non-nil *[FieldSizePayload] if [ErrorCode] represents the variant case "HTTP-response-header-size".
func (self *ErrorCode) HTTPResponseHeaderSize() *FieldSizePayload {
	return cm.Case[FieldSizePayload](self, 27)
}

// ErrorCodeHTTPResponseBodySize returns a [ErrorCode] of case "HTTP-response-body-size".
func ErrorCodeHTTPResponseBodySize(data cm.Option[uint64]) ErrorCode {
	return cm.New[ErrorCode](28, data)
}

// HTTPResponseBodySize returns a non-nil *[cm.Option[uint64]] if [ErrorCode] represents the variant case "HTTP-response-body-size".
func (self *ErrorCode) HTTPResponseBodySize() *cm.Option[uint64] {
	return cm.Case[cm.Option[uint64]](self, 28)
}

// ErrorCodeHTTPResponseTrailerSectionSize returns a [ErrorCode] of case "HTTP-response-trailer-section-size".
func ErrorCodeHTTPResponseTrailerSectionSize(data cm.Option[uint32]) ErrorCode {
	return cm.New[ErrorCode](29, data)
}

// HTTPResponseTrailerSectionSize returns a non-nil *[cm.Option[uint32]] if [ErrorCode] represents the variant case "HTTP-response-trailer-section-size".
func (self *ErrorCode) HTTPResponseTrailerSectionSize() *cm.Option[uint32] {
	return cm.Case[cm.Option[uint32]](self, 29)
}

// ErrorCodeHTTPResponseTrailerSize returns a [ErrorCode] of case "HTTP-response-trailer-size".
func ErrorCodeHTTPResponseTrailerSize(data FieldSizePayload) ErrorCode {
	return cm.New[ErrorCode](30, data)
}

// HTTPResponseTrailerSize returns a non-nil *[FieldSizePayload] if [ErrorCode] represents the variant case "HTTP-response-trailer-size".
func (self *ErrorCode) HTTPResponseTrailerSize() *FieldSizePayload {
	return cm.Case[FieldSizePayload](self, 30)
}

// ErrorCodeHTTPResponseTransferCoding returns a [ErrorCode] of case "HTTP-response-transfer-coding".
func ErrorCodeHTTPResponseTransferCoding(data cm.Option[string]) ErrorCode {
	return cm.New[ErrorCode](31, data)
}

// HTTPResponseTransferCoding returns a non-nil *[cm.Option[string]] if [ErrorCode] represents the variant case "HTTP-response-transfer-coding".
func (self *ErrorCode) HTTPResponseTransferCoding() *cm.Option[string] {
	return cm.Case[cm.Option[string]](self, 31)
}

// ErrorCodeHTTPResponseContentCoding returns a [ErrorCode] of case "HTTP-response-content-coding".
func ErrorCodeHTTPResponseContentCoding(data cm.Option[string]) ErrorCode {
	return cm.New[ErrorCode](32, data)
}

// HTTPResponseContentCoding returns a non-nil *[cm.Option[string]] if [ErrorCode] represents the variant case "HTTP-response-content-coding".
func (self *ErrorCode) HTTPResponseContentCoding() *cm.Option[string] {
	return cm.Case[cm.Option[string]](self, 32)
}

// ErrorCodeHTTPResponseTimeout returns a [ErrorCode] of case "HTTP-response-timeout".
func ErrorCodeHTTPResponseTimeout() ErrorCode {
	var data struct{}
	return cm.New[ErrorCode](33, data)
}

// HTTPResponseTimeout returns true if [ErrorCode] represents the variant case "HTTP-response-timeout".
func (self *ErrorCode) HTTPResponseTimeout() bool {
	return self.Tag() == 33
}

// ErrorCodeHTTPUpgradeFailed returns a [ErrorCode] of case "HTTP-upgrade-failed".
func ErrorCodeHTTPUpgradeFailed() ErrorCode {
	var data struct{}
	return cm.New[ErrorCode](34, data)
}

// HTTPUpgradeFailed returns true if [ErrorCode] represents the variant case "HTTP-upgrade-failed".
func (self *ErrorCode) HTTPUpgradeFailed() bool {
	return self.Tag() == 34
}

// ErrorCodeHTTPProtocolError returns a [ErrorCode] of case "HTTP-protocol-error".
func ErrorCodeHTTPProtocolError() ErrorCode {
	var data struct{}
	return cm.New[ErrorCode](35, data)
}

// HTTPProtocolError returns true if [ErrorCode] represents the variant case "HTTP-protocol-error".
func (self *ErrorCode) HTTPProtocolError() bool {
	return self.Tag() == 35
}

// ErrorCodeLoopDetected returns a [ErrorCode] of case "loop-detected".
func ErrorCodeLoopDetected() ErrorCode {
	var data struct{}
	return cm.New[ErrorCode](36, data)
}

// LoopDetected returns true if [ErrorCode] represents the variant case "loop-detected".
func (self *ErrorCode) LoopDetected() bool {
	return self.Tag() == 36
}

// ErrorCodeConfigurationError returns a [ErrorCode] of case "configuration-error".
func ErrorCodeConfigurationError() ErrorCode {
	var data struct{}
	return cm.New[ErrorCode](37, data)
}

// ConfigurationError returns true if [ErrorCode] represents the variant case "configuration-error".
func (self *ErrorCode) ConfigurationError() bool {
	return self.Tag() == 37
}

// ErrorCodeInternalError returns a [ErrorCode] of case "internal-error".
func ErrorCodeInternalError(data cm.Option[string]) ErrorCode {
	return cm.New[ErrorCode](38, data)
}

// InternalError returns a non-nil *[cm.Option[string]] if [ErrorCode] represents the variant case "internal-error".
func (self *ErrorCode) InternalError() *cm.Option[string] {
	return cm.Case[cm.Option[string]](self, 38)
}

var stringsErrorCode = [39]string{
	"DNS-timeout",
	"DNS-error",
	"destination-not-found",
	"destination-unavailable",
	"destination-IP-prohibited",
	"destination-IP-unroutable",
	"connection-refused",
	"connection-terminated",
	"connection-timeout",
	"connection-read-timeout",
	"connection-write-timeout",
	"connection-limit-reached",
	"TLS-protocol-error",
	"TLS-certificate-error",
	"TLS-alert-received",
	"HTTP-request-denied",
	"HTTP-request-length-required",
	"HTTP-request-body-size",
	"HTTP-request-method-invalid",
	"HTTP-request-URI-invalid",
	"HTTP-request-URI-too-long",
	"HTTP-request-header-section-size",
	"HTTP-request-header-size",
	"HTTP-request-trailer-section-size",
	"HTTP-request-trailer-size",
	"HTTP-response-incomplete",
	"HTTP-response-header-section-size",
	"HTTP-response-header-size",
	"HTTP-response-body-size",
	"HTTP-response-trailer-section-size",
	"HTTP-response-trailer-size",
	"HTTP-response-transfer-coding",
	"HTTP-response-content-coding",
	"HTTP-response-timeout",
	"HTTP-upgrade-failed",
	"HTTP-protocol-error",
	"loop-detected",
	"configuration-error",
	"internal-error",
}

// String implements [fmt.Stringer], returning the variant case name of v.
func (v ErrorCode) String() string {
	return stringsErrorCode[v.Tag()]
}

// HeaderError represents the variant "wasi:http/types@0.2.0#header-error".
//
//	variant header-error {
//		invalid-syntax,
//		forbidden,
//		immutable,
//	}
type HeaderError uint8

const (
	HeaderErrorInvalidSyntax HeaderError = iota
	HeaderErrorForbidden
	HeaderErrorImmutable
)

var stringsHeaderError = [3]string{
	"invalid-syntax",
	"forbidden",
	"immutable",
}

// String implements [fmt.Stringer], returning the enum case name of e.
func (e HeaderError) String() string {
	return stringsHeaderError[e]
}

// FieldKey represents the string "wasi:http/types@0.2.0#field-key".
//
//	type field-key = string
type FieldKey string

// FieldValue represents the list "wasi:http/types@0.2.0#field-value".
//
//	type field-value = list<u8>
type FieldValue cm.List[uint8]

// Fields represents the imported resource "wasi:http/types@0.2.0#fields".
//
//	resource fields
type Fields cm.Resource

// ResourceDrop represents the imported resource-drop for resource "fields".
//
// Drops a resource handle.
//
//go:nosplit
func (self Fields) ResourceDrop() {
	self0 := cm.Reinterpret[uint32](self)
	wasmimport_FieldsResourceDrop((uint32)(self0))
	return
}

// NewFields represents the imported constructor for resource "fields".
//
//	constructor()
//
//go:nosplit
func NewFields() (result Fields) {
	result0 := wasmimport_NewFields()
	result = cm.Reinterpret[Fields]((uint32)(result0))
	return
}

// FieldsFromList represents the imported static function "from-list".
//
//	from-list: static func(entries: list<tuple<field-key, field-value>>) -> result<fields,
//	header-error>
//
//go:nosplit
func FieldsFromList(entries cm.List[cm.Tuple[FieldKey, FieldValue]]) (result cm.Result[Fields, Fields, HeaderError]) {
	entries0, entries1 := cm.LowerList(entries)
	wasmimport_FieldsFromList((*cm.Tuple[FieldKey, FieldValue])(entries0), (uint32)(entries1), &result)
	return
}

// Append represents the imported method "append".
//
//	append: func(name: field-key, value: field-value) -> result<_, header-error>
//
//go:nosplit
func (self Fields) Append(name FieldKey, value FieldValue) (result cm.Result[HeaderError, struct{}, HeaderError]) {
	self0 := cm.Reinterpret[uint32](self)
	name0, name1 := cm.LowerString(name)
	value0, value1 := cm.LowerList(value)
	wasmimport_FieldsAppend((uint32)(self0), (*uint8)(name0), (uint32)(name1), (*uint8)(value0), (uint32)(value1), &result)
	return
}

// Clone represents the imported method "clone".
//
//	clone: func() -> fields
//
//go:nosplit
func (self Fields) Clone() (result Fields) {
	self0 := cm.Reinterpret[uint32](self)
	result0 := wasmimport_FieldsClone((uint32)(self0))
	result = cm.Reinterpret[Fields]((uint32)(result0))
	return
}

// Delete represents the imported method "delete".
//
//	delete: func(name: field-key) -> result<_, header-error>
//
//go:nosplit
func (self Fields) Delete(name FieldKey) (result cm.Result[HeaderError, struct{}, HeaderError]) {
	self0 := cm.Reinterpret[uint32](self)
	name0, name1 := cm.LowerString(name)
	wasmimport_FieldsDelete((uint32)(self0), (*uint8)(name0), (uint32)(name1), &result)
	return
}

// Entries represents the imported method "entries".
//
//	entries: func() -> list<tuple<field-key, field-value>>
//
//go:nosplit
func (self Fields) Entries() (result cm.List[cm.Tuple[FieldKey, FieldValue]]) {
	self0 := cm.Reinterpret[uint32](self)
	wasmimport_FieldsEntries((uint32)(self0), &result)
	return
}

// Get represents the imported method "get".
//
//	get: func(name: field-key) -> list<field-value>
//
//go:nosplit
func (self Fields) Get(name FieldKey) (result cm.List[FieldValue]) {
	self0 := cm.Reinterpret[uint32](self)
	name0, name1 := cm.LowerString(name)
	wasmimport_FieldsGet((uint32)(self0), (*uint8)(name0), (uint32)(name1), &result)
	return
}

// Has represents the imported method "has".
//
//	has: func(name: field-key) -> bool
//
//go:nosplit
func (self Fields) Has(name FieldKey) (result bool) {
	self0 := cm.Reinterpret[uint32](self)
	name0, name1 := cm.LowerString(name)
	result0 := wasmimport_FieldsHas((uint32)(self0), (*uint8)(name0), (uint32)(name1))
	result = cm.U32ToBool((uint32)(result0))
	return
}

// Set represents the imported method "set".
//
//	set: func(name: field-key, value: list<field-value>) -> result<_, header-error>
//
//go:nosplit
func (self Fields) Set(name FieldKey, value cm.List[FieldValue]) (result cm.Result[HeaderError, struct{}, HeaderError]) {
	self0 := cm.Reinterpret[uint32](self)
	name0, name1 := cm.LowerString(name)
	value0, value1 := cm.LowerList(value)
	wasmimport_FieldsSet((uint32)(self0), (*uint8)(name0), (uint32)(name1), (*FieldValue)(value0), (uint32)(value1), &result)
	return
}

// Headers represents the imported type alias "wasi:http/types@0.2.0#headers".
//
// See [Fields] for more information.
type Headers = Fields

// Trailers represents the imported type alias "wasi:http/types@0.2.0#trailers".
//
// See [Fields] for more information.
type Trailers = Fields

// IncomingRequest represents the imported resource "wasi:http/types@0.2.0#incoming-request".
//
//	resource incoming-request
type IncomingRequest cm.Resource

// ResourceDrop represents the imported resource-drop for resource "incoming-request".
//
// Drops a resource handle.
//
//go:nosplit
func (self IncomingRequest) ResourceDrop() {
	self0 := cm.Reinterpret[uint32](self)
	wasmimport_IncomingRequestResourceDrop((uint32)(self0))
	return
}

// Authority represents the imported method "authority".
//
//	authority: func() -> option<string>
//
//go:nosplit
func (self IncomingRequest) Authority() (result cm.Option[string]) {
	self0 := cm.Reinterpret[uint32](self)
	wasmimport_IncomingRequestAuthority((uint32)(self0), &result)
	return
}

// Consume represents the imported method "consume".
//
//	consume: func() -> result<incoming-body>
//
//go:nosplit
func (self IncomingRequest) Consume() (result cm.Result[IncomingBody, IncomingBody, struct{}]) {
	self0 := cm.Reinterpret[uint32](self)
	wasmimport_IncomingRequestConsume((uint32)(self0), &result)
	return
}

// Headers represents the imported method "headers".
//
//	headers: func() -> headers
//
//go:nosplit
func (self IncomingRequest) Headers() (result Headers) {
	self0 := cm.Reinterpret[uint32](self)
	result0 := wasmimport_IncomingRequestHeaders((uint32)(self0))
	result = cm.Reinterpret[Headers]((uint32)(result0))
	return
}

// Method represents the imported method "method".
//
//	method: func() -> method
//
//go:nosplit
func (self IncomingRequest) Method() (result Method) {
	self0 := cm.Reinterpret[uint32](self)
	wasmimport_IncomingRequestMethod((uint32)(self0), &result)
	return
}

// PathWithQuery represents the imported method "path-with-query".
//
//	path-with-query: func() -> option<string>
//
//go:nosplit
func (self IncomingRequest) PathWithQuery() (result cm.Option[string]) {
	self0 := cm.Reinterpret[uint32](self)
	wasmimport_IncomingRequestPathWithQuery((uint32)(self0), &result)
	return
}

// Scheme represents the imported method "scheme".
//
//	scheme: func() -> option<scheme>
//
//go:nosplit
func (self IncomingRequest) Scheme() (result cm.Option[Scheme]) {
	self0 := cm.Reinterpret[uint32](self)
	wasmimport_IncomingRequestScheme((uint32)(self0), &result)
	return
}

// OutgoingRequest represents the imported resource "wasi:http/types@0.2.0#outgoing-request".
//
//	resource outgoing-request
type OutgoingRequest cm.Resource

// ResourceDrop represents the imported resource-drop for resource "outgoing-request".
//
// Drops a resource handle.
//
//go:nosplit
func (self OutgoingRequest) ResourceDrop() {
	self0 := cm.Reinterpret[uint32](self)
	wasmimport_OutgoingRequestResourceDrop((uint32)(self0))
	return
}

// NewOutgoingRequest represents the imported constructor for resource "outgoing-request".
//
//	constructor(headers: headers)
//
//go:nosplit
func NewOutgoingRequest(headers Headers) (result OutgoingRequest) {
	headers0 := cm.Reinterpret[uint32](headers)
	result0 := wasmimport_NewOutgoingRequest((uint32)(headers0))
	result = cm.Reinterpret[OutgoingRequest]((uint32)(result0))
	return
}

// Authority represents the imported method "authority".
//
//	authority: func() -> option<string>
//
//go:nosplit
func (self OutgoingRequest) Authority() (result cm.Option[string]) {
	self0 := cm.Reinterpret[uint32](self)
	wasmimport_OutgoingRequestAuthority((uint32)(self0), &result)
	return
}

// Body represents the imported method "body".
//
//	body: func() -> result<outgoing-body>
//
//go:nosplit
func (self OutgoingRequest) Body() (result cm.Result[OutgoingBody, OutgoingBody, struct{}]) {
	self0 := cm.Reinterpret[uint32](self)
	wasmimport_OutgoingRequestBody((uint32)(self0), &result)
	return
}

// Headers represents the imported method "headers".
//
//	headers: func() -> headers
//
//go:nosplit
func (self OutgoingRequest) Headers() (result Headers) {
	self0 := cm.Reinterpret[uint32](self)
	result0 := wasmimport_OutgoingRequestHeaders((uint32)(self0))
	result = cm.Reinterpret[Headers]((uint32)(result0))
	return
}

// Method represents the imported method "method".
//
//	method: func() -> method
//
//go:nosplit
func (self OutgoingRequest) Method() (result Method) {
	self0 := cm.Reinterpret[uint32](self)
	wasmimport_OutgoingRequestMethod((uint32)(self0), &result)
	return
}

// PathWithQuery represents the imported method "path-with-query".
//
//	path-with-query: func() -> option<string>
//
//go:nosplit
func (self OutgoingRequest) PathWithQuery() (result cm.Option[string]) {
	self0 := cm.Reinterpret[uint32](self)
	wasmimport_OutgoingRequestPathWithQuery((uint32)(self0), &result)
	return
}

// Scheme represents the imported method "scheme".
//
//	scheme: func() -> option<scheme>
//
//go:nosplit
func (self OutgoingRequest) Scheme() (result cm.Option[Scheme]) {
	self0 := cm.Reinterpret[uint32](self)
	wasmimport_OutgoingRequestScheme((uint32)(self0), &result)
	return
}

// SetAuthority represents the imported method "set-authority".
//
//	set-authority: func(authority: option<string>) -> result
//
//go:nosplit
func (self OutgoingRequest) SetAuthority(authority cm.Option[string]) (result cm.BoolResult) {
	self0 := cm.Reinterpret[uint32](self)
	authority0, authority1, authority2 := lower_OptionString(authority)
	result0 := wasmimport_OutgoingRequestSetAuthority((uint32)(self0), (uint32)(authority0), (*uint8)(authority1), (uint32)(authority2))
	result = (cm.BoolResult)(cm.U32ToBool((uint32)(result0)))
	return
}

// SetMethod represents the imported method "set-method".
//
//	set-method: func(method: method) -> result
//
//go:nosplit
func (self OutgoingRequest) SetMethod(method Method) (result cm.BoolResult) {
	self0 := cm.Reinterpret[uint32](self)
	method0, method1, method2 := lower_Method(method)
	result0 := wasmimport_OutgoingRequestSetMethod((uint32)(self0), (uint32)(method0), (*uint8)(method1), (uint32)(method2))
	result = (cm.BoolResult)(cm.U32ToBool((uint32)(result0)))
	return
}

// SetPathWithQuery represents the imported method "set-path-with-query".
//
//	set-path-with-query: func(path-with-query: option<string>) -> result
//
//go:nosplit
func (self OutgoingRequest) SetPathWithQuery(pathWithQuery cm.Option[string]) (result cm.BoolResult) {
	self0 := cm.Reinterpret[uint32](self)
	pathWithQuery0, pathWithQuery1, pathWithQuery2 := lower_OptionString(pathWithQuery)
	result0 := wasmimport_OutgoingRequestSetPathWithQuery((uint32)(self0), (uint32)(pathWithQuery0), (*uint8)(pathWithQuery1), (uint32)(pathWithQuery2))
	result = (cm.BoolResult)(cm.U32ToBool((uint32)(result0)))
	return
}

// SetScheme represents the imported method "set-scheme".
//
//	set-scheme: func(scheme: option<scheme>) -> result
//
//go:nosplit
func (self OutgoingRequest) SetScheme(scheme cm.Option[Scheme]) (result cm.BoolResult) {
	self0 := cm.Reinterpret[uint32](self)
	scheme0, scheme1, scheme2, scheme3 := lower_OptionScheme(scheme)
	result0 := wasmimport_OutgoingRequestSetScheme((uint32)(self0), (uint32)(scheme0), (uint32)(scheme1), (*uint8)(scheme2), (uint32)(scheme3))
	result = (cm.BoolResult)(cm.U32ToBool((uint32)(result0)))
	return
}

// RequestOptions represents the imported resource "wasi:http/types@0.2.0#request-options".
//
//	resource request-options
type RequestOptions cm.Resource

// ResourceDrop represents the imported resource-drop for resource "request-options".
//
// Drops a resource handle.
//
//go:nosplit
func (self RequestOptions) ResourceDrop() {
	self0 := cm.Reinterpret[uint32](self)
	wasmimport_RequestOptionsResourceDrop((uint32)(self0))
	return
}

// NewRequestOptions represents the imported constructor for resource "request-options".
//
//	constructor()
//
//go:nosplit
func NewRequestOptions() (result RequestOptions) {
	result0 := wasmimport_NewRequestOptions()
	result = cm.Reinterpret[RequestOptions]((uint32)(result0))
	return
}

// BetweenBytesTimeout represents the imported method "between-bytes-timeout".
//
//	between-bytes-timeout: func() -> option<duration>
//
//go:nosplit
func (self RequestOptions) BetweenBytesTimeout() (result cm.Option[Duration]) {
	self0 := cm.Reinterpret[uint32](self)
	wasmimport_RequestOptionsBetweenBytesTimeout((uint32)(self0), &result)
	return
}

// ConnectTimeout represents the imported method "connect-timeout".
//
//	connect-timeout: func() -> option<duration>
//
//go:nosplit
func (self RequestOptions) ConnectTimeout() (result cm.Option[Duration]) {
	self0 := cm.Reinterpret[uint32](self)
	wasmimport_RequestOptionsConnectTimeout((uint32)(self0), &result)
	return
}

// FirstByteTimeout represents the imported method "first-byte-timeout".
//
//	first-byte-timeout: func() -> option<duration>
//
//go:nosplit
func (self RequestOptions) FirstByteTimeout() (result cm.Option[Duration]) {
	self0 := cm.Reinterpret[uint32](self)
	wasmimport_RequestOptionsFirstByteTimeout((uint32)(self0), &result)
	return
}

// SetBetweenBytesTimeout represents the imported method "set-between-bytes-timeout".
//
//	set-between-bytes-timeout: func(duration: option<duration>) -> result
//
//go:nosplit
func (self RequestOptions) SetBetweenBytesTimeout(duration cm.Option[Duration]) (result cm.BoolResult) {
	self0 := cm.Reinterpret[uint32](self)
	duration0, duration1 := lower_OptionDuration(duration)
	result0 := wasmimport_RequestOptionsSetBetweenBytesTimeout((uint32)(self0), (uint32)(duration0), (uint64)(duration1))
	result = (cm.BoolResult)(cm.U32ToBool((uint32)(result0)))
	return
}

// SetConnectTimeout represents the imported method "set-connect-timeout".
//
//	set-connect-timeout: func(duration: option<duration>) -> result
//
//go:nosplit
func (self RequestOptions) SetConnectTimeout(duration cm.Option[Duration]) (result cm.BoolResult) {
	self0 := cm.Reinterpret[uint32](self)
	duration0, duration1 := lower_OptionDuration(duration)
	result0 := wasmimport_RequestOptionsSetConnectTimeout((uint32)(self0), (uint32)(duration0), (uint64)(duration1))
	result = (cm.BoolResult)(cm.U32ToBool((uint32)(result0)))
	return
}

// SetFirstByteTimeout represents the imported method "set-first-byte-timeout".
//
//	set-first-byte-timeout: func(duration: option<duration>) -> result
//
//go:nosplit
func (self RequestOptions) SetFirstByteTimeout(duration cm.Option[Duration]) (result cm.BoolResult) {
	self0 := cm.Reinterpret[uint32](self)
	duration0, duration1 := lower_OptionDuration(duration)
	result0 := wasmimport_RequestOptionsSetFirstByteTimeout((uint32)(self0), (uint32)(duration0), (uint64)(duration1))
	result = (cm.BoolResult)(cm.U32ToBool((uint32)(result0)))
	return
}

// ResponseOutparam represents the imported resource "wasi:http/types@0.2.0#response-outparam".
//
//	resource response-outparam
type ResponseOutparam cm.Resource

// ResourceDrop represents the imported resource-drop for resource "response-outparam".
//
// Drops a resource handle.
//
//go:nosplit
func (self ResponseOutparam) ResourceDrop() {
	self0 := cm.Reinterpret[uint32](self)
	wasmimport_ResponseOutparamResourceDrop((uint32)(self0))
	return
}

// ResponseOutparamSet represents the imported static function "set".
//
//	set: static func(param: response-outparam, response: result<outgoing-response,
//	error-code>)
//
//go:nosplit
func ResponseOutparamSet(param ResponseOutparam, response cm.Result[ErrorCodeShape, OutgoingResponse, ErrorCode]) {
	param0 := cm.Reinterpret[uint32](param)
	response0, response1, response2, response3, response4, response5, response6, response7 := lower_ResultOutgoingResponseErrorCode(response)
	wasmimport_ResponseOutparamSet((uint32)(param0), (uint32)(response0), (uint32)(response1), (uint32)(response2), (uint64)(response3), (uint32)(response4), (uint32)(response5), (uint32)(response6), (uint32)(response7))
	return
}

// StatusCode represents the u16 "wasi:http/types@0.2.0#status-code".
//
//	type status-code = u16
type StatusCode uint16

// IncomingResponse represents the imported resource "wasi:http/types@0.2.0#incoming-response".
//
//	resource incoming-response
type IncomingResponse cm.Resource

// ResourceDrop represents the imported resource-drop for resource "incoming-response".
//
// Drops a resource handle.
//
//go:nosplit
func (self IncomingResponse) ResourceDrop() {
	self0 := cm.Reinterpret[uint32](self)
	wasmimport_IncomingResponseResourceDrop((uint32)(self0))
	return
}

// Consume represents the imported method "consume".
//
//	consume: func() -> result<incoming-body>
//
//go:nosplit
func (self IncomingResponse) Consume() (result cm.Result[IncomingBody, IncomingBody, struct{}]) {
	self0 := cm.Reinterpret[uint32](self)
	wasmimport_IncomingResponseConsume((uint32)(self0), &result)
	return
}

// Headers represents the imported method "headers".
//
//	headers: func() -> headers
//
//go:nosplit
func (self IncomingResponse) Headers() (result Headers) {
	self0 := cm.Reinterpret[uint32](self)
	result0 := wasmimport_IncomingResponseHeaders((uint32)(self0))
	result = cm.Reinterpret[Headers]((uint32)(result0))
	return
}

// Status represents the imported method "status".
//
//	status: func() -> status-code
//
//go:nosplit
func (self IncomingResponse) Status() (result StatusCode) {
	self0 := cm.Reinterpret[uint32](self)
	result0 := wasmimport_IncomingResponseStatus((uint32)(self0))
	result = (StatusCode)((uint32)(result0))
	return
}

// IncomingBody represents the imported resource "wasi:http/types@0.2.0#incoming-body".
//
//	resource incoming-body
type IncomingBody cm.Resource

// ResourceDrop represents the imported resource-drop for resource "incoming-body".
//
// Drops a resource handle.
//
//go:nosplit
func (self IncomingBody) ResourceDrop() {
	self0 := cm.Reinterpret[uint32](self)
	wasmimport_IncomingBodyResourceDrop((uint32)(self0))
	return
}

// IncomingBodyFinish represents the imported static function "finish".
//
//	finish: static func(this: incoming-body) -> future-trailers
//
//go:nosplit
func IncomingBodyFinish(this IncomingBody) (result FutureTrailers) {
	this0 := cm.Reinterpret[uint32](this)
	result0 := wasmimport_IncomingBodyFinish((uint32)(this0))
	result = cm.Reinterpret[FutureTrailers]((uint32)(result0))
	return
}

// Stream represents the imported method "stream".
//
//	%stream: func() -> result<input-stream>
//
//go:nosplit
func (self IncomingBody) Stream() (result cm.Result[InputStream, InputStream, struct{}]) {
	self0 := cm.Reinterpret[uint32](self)
	wasmimport_IncomingBodyStream((uint32)(self0), &result)
	return
}

// FutureTrailers represents the imported resource "wasi:http/types@0.2.0#future-trailers".
//
//	resource future-trailers
type FutureTrailers cm.Resource

// ResourceDrop represents the imported resource-drop for resource "future-trailers".
//
// Drops a resource handle.
//
//go:nosplit
func (self FutureTrailers) ResourceDrop() {
	self0 := cm.Reinterpret[uint32](self)
	wasmimport_FutureTrailersResourceDrop((uint32)(self0))
	return
}

// Get represents the imported method "get".
//
//	get: func() -> option<result<result<option<trailers>, error-code>>>
//
//go:nosplit
func (self FutureTrailers) Get() (result cm.Option[cm.Result[cm.Result[ErrorCodeShape, cm.Option[Trailers], ErrorCode], cm.Result[ErrorCodeShape, cm.Option[Trailers], ErrorCode], struct{}]]) {
	self0 := cm.Reinterpret[uint32](self)
	wasmimport_FutureTrailersGet((uint32)(self0), &result)
	return
}

// Subscribe represents the imported method "subscribe".
//
//	subscribe: func() -> pollable
//
//go:nosplit
func (self FutureTrailers) Subscribe() (result Pollable) {
	self0 := cm.Reinterpret[uint32](self)
	result0 := wasmimport_FutureTrailersSubscribe((uint32)(self0))
	result = cm.Reinterpret[Pollable]((uint32)(result0))
	return
}

// OutgoingResponse represents the imported resource "wasi:http/types@0.2.0#outgoing-response".
//
//	resource outgoing-response
type OutgoingResponse cm.Resource

// ResourceDrop represents the imported resource-drop for resource "outgoing-response".
//
// Drops a resource handle.
//
//go:nosplit
func (self OutgoingResponse) ResourceDrop() {
	self0 := cm.Reinterpret[uint32](self)
	wasmimport_OutgoingResponseResourceDrop((uint32)(self0))
	return
}

// NewOutgoingResponse represents the imported constructor for resource "outgoing-response".
//
//	constructor(headers: headers)
//
//go:nosplit
func NewOutgoingResponse(headers Headers) (result OutgoingResponse) {
	headers0 := cm.Reinterpret[uint32](headers)
	result0 := wasmimport_NewOutgoingResponse((uint32)(headers0))
	result = cm.Reinterpret[OutgoingResponse]((uint32)(result0))
	return
}

// Body represents the imported method "body".
//
//	body: func() -> result<outgoing-body>
//
//go:nosplit
func (self OutgoingResponse) Body() (result cm.Result[OutgoingBody, OutgoingBody, struct{}]) {
	self0 := cm.Reinterpret[uint32](self)
	wasmimport_OutgoingResponseBody((uint32)(self0), &result)
	return
}

// Headers represents the imported method "headers".
//
//	headers: func() -> headers
//
//go:nosplit
func (self OutgoingResponse) Headers() (result Headers) {
	self0 := cm.Reinterpret[uint32](self)
	result0 := wasmimport_OutgoingResponseHeaders((uint32)(self0))
	result = cm.Reinterpret[Headers]((uint32)(result0))
	return
}

// SetStatusCode represents the imported method "set-status-code".
//
//	set-status-code: func(status-code: status-code) -> result
//
//go:nosplit
func (self OutgoingResponse) SetStatusCode(statusCode StatusCode) (result cm.BoolResult) {
	self0 := cm.Reinterpret[uint32](self)
	statusCode0 := (uint32)(statusCode)
	result0 := wasmimport_OutgoingResponseSetStatusCode((uint32)(self0), (uint32)(statusCode0))
	result = (cm.BoolResult)(cm.U32ToBool((uint32)(result0)))
	return
}

// StatusCode represents the imported method "status-code".
//
//	status-code: func() -> status-code
//
//go:nosplit
func (self OutgoingResponse) StatusCode() (result StatusCode) {
	self0 := cm.Reinterpret[uint32](self)
	result0 := wasmimport_OutgoingResponseStatusCode((uint32)(self0))
	result = (StatusCode)((uint32)(result0))
	return
}

// OutgoingBody represents the imported resource "wasi:http/types@0.2.0#outgoing-body".
//
//	resource outgoing-body
type OutgoingBody cm.Resource

// ResourceDrop represents the imported resource-drop for resource "outgoing-body".
//
// Drops a resource handle.
//
//go:nosplit
func (self OutgoingBody) ResourceDrop() {
	self0 := cm.Reinterpret[uint32](self)
	wasmimport_OutgoingBodyResourceDrop((uint32)(self0))
	return
}

// OutgoingBodyFinish represents the imported static function "finish".
//
//	finish: static func(this: outgoing-body, trailers: option<trailers>) -> result<_,
//	error-code>
//
//go:nosplit
func OutgoingBodyFinish(this OutgoingBody, trailers cm.Option[Trailers]) (result cm.Result[ErrorCode, struct{}, ErrorCode]) {
	this0 := cm.Reinterpret[uint32](this)
	trailers0, trailers1 := lower_OptionTrailers(trailers)
	wasmimport_OutgoingBodyFinish((uint32)(this0), (uint32)(trailers0), (uint32)(trailers1), &result)
	return
}

// Write represents the imported method "write".
//
//	write: func() -> result<output-stream>
//
//go:nosplit
func (self OutgoingBody) Write() (result cm.Result[OutputStream, OutputStream, struct{}]) {
	self0 := cm.Reinterpret[uint32](self)
	wasmimport_OutgoingBodyWrite((uint32)(self0), &result)
	return
}

// FutureIncomingResponse represents the imported resource "wasi:http/types@0.2.0#future-incoming-response".
//
//	resource future-incoming-response
type FutureIncomingResponse cm.Resource

// ResourceDrop represents the imported resource-drop for resource "future-incoming-response".
//
// Drops a resource handle.
//
//go:nosplit
func (self FutureIncomingResponse) ResourceDrop() {
	self0 := cm.Reinterpret[uint32](self)
	wasmimport_FutureIncomingResponseResourceDrop((uint32)(self0))
	return
}

// Get represents the imported method "get".
//
//	get: func() -> option<result<result<incoming-response, error-code>>>
//
//go:nosplit
func (self FutureIncomingResponse) Get() (result cm.Option[cm.Result[cm.Result[ErrorCodeShape, IncomingResponse, ErrorCode], cm.Result[ErrorCodeShape, IncomingResponse, ErrorCode], struct{}]]) {
	self0 := cm.Reinterpret[uint32](self)
	wasmimport_FutureIncomingResponseGet((uint32)(self0), &result)
	return
}

// Subscribe represents the imported method "subscribe".
//
//	subscribe: func() -> pollable
//
//go:nosplit
func (self FutureIncomingResponse) Subscribe() (result Pollable) {
	self0 := cm.Reinterpret[uint32](self)
	result0 := wasmimport_FutureIncomingResponseSubscribe((uint32)(self0))
	result = cm.Reinterpret[Pollable]((uint32)(result0))
	return
}

// HTTPErrorCode represents the imported function "http-error-code".
//
//	http-error-code: func(err: borrow<io-error>) -> option<error-code>
//
//go:nosplit
func HTTPErrorCode(err IOError) (result cm.Option[ErrorCode]) {
	err0 := cm.Reinterpret[uint32](err)
	wasmimport_HTTPErrorCode((uint32)(err0), &result)
	return
}
