// Code generated by protoc-gen-go. DO NOT EDIT.
// versions:
// 	protoc-gen-go v1.36.6
// 	protoc        (unknown)
// source: http/http.proto

package http

import (
	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
	reflect "reflect"
	sync "sync"
	unsafe "unsafe"
)

const (
	// Verify that this generated code is sufficiently up-to-date.
	_ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion)
	// Verify that runtime/protoimpl is sufficiently up-to-date.
	_ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20)
)

// URL is a net.URL see: https://pkg.go.dev/net/url#URL
type URL struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// scheme is the url scheme name
	Scheme string `protobuf:"bytes,1,opt,name=scheme,proto3" json:"scheme,omitempty"`
	// opaque is encoded opaque data
	Opaque string `protobuf:"bytes,2,opt,name=opaque,proto3" json:"opaque,omitempty"`
	// user is username and password information
	User *Userinfo `protobuf:"bytes,3,opt,name=user,proto3" json:"user,omitempty"`
	// host can be in the format host or host:port
	Host string `protobuf:"bytes,4,opt,name=host,proto3" json:"host,omitempty"`
	// path (relative paths may omit leading slash)
	Path string `protobuf:"bytes,5,opt,name=path,proto3" json:"path,omitempty"`
	// raw_path is encoded path hint (see EscapedPath method)
	RawPath string `protobuf:"bytes,6,opt,name=raw_path,json=rawPath,proto3" json:"raw_path,omitempty"`
	// force is append a query ('?') even if RawQuery is empty
	ForceQuery bool `protobuf:"varint,7,opt,name=force_query,json=forceQuery,proto3" json:"force_query,omitempty"`
	// raw_query is encoded query values, without '?'
	RawQuery string `protobuf:"bytes,8,opt,name=raw_query,json=rawQuery,proto3" json:"raw_query,omitempty"`
	// fragment is fragment for references, without '#'
	Fragment      string `protobuf:"bytes,9,opt,name=fragment,proto3" json:"fragment,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *URL) Reset() {
	*x = URL{}
	mi := &file_http_http_proto_msgTypes[0]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *URL) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*URL) ProtoMessage() {}

func (x *URL) ProtoReflect() protoreflect.Message {
	mi := &file_http_http_proto_msgTypes[0]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use URL.ProtoReflect.Descriptor instead.
func (*URL) Descriptor() ([]byte, []int) {
	return file_http_http_proto_rawDescGZIP(), []int{0}
}

func (x *URL) GetScheme() string {
	if x != nil {
		return x.Scheme
	}
	return ""
}

func (x *URL) GetOpaque() string {
	if x != nil {
		return x.Opaque
	}
	return ""
}

func (x *URL) GetUser() *Userinfo {
	if x != nil {
		return x.User
	}
	return nil
}

func (x *URL) GetHost() string {
	if x != nil {
		return x.Host
	}
	return ""
}

func (x *URL) GetPath() string {
	if x != nil {
		return x.Path
	}
	return ""
}

func (x *URL) GetRawPath() string {
	if x != nil {
		return x.RawPath
	}
	return ""
}

func (x *URL) GetForceQuery() bool {
	if x != nil {
		return x.ForceQuery
	}
	return false
}

func (x *URL) GetRawQuery() string {
	if x != nil {
		return x.RawQuery
	}
	return ""
}

func (x *URL) GetFragment() string {
	if x != nil {
		return x.Fragment
	}
	return ""
}

// UserInfo is net.Userinfo see: https://pkg.go.dev/net/url#Userinfo
type Userinfo struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// username is the username for the user
	Username string `protobuf:"bytes,1,opt,name=username,proto3" json:"username,omitempty"`
	// password is the password for the user
	Password string `protobuf:"bytes,2,opt,name=password,proto3" json:"password,omitempty"`
	// password_set is a boolean which is true if the password is set
	PasswordSet   bool `protobuf:"varint,3,opt,name=password_set,json=passwordSet,proto3" json:"password_set,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *Userinfo) Reset() {
	*x = Userinfo{}
	mi := &file_http_http_proto_msgTypes[1]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *Userinfo) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*Userinfo) ProtoMessage() {}

func (x *Userinfo) ProtoReflect() protoreflect.Message {
	mi := &file_http_http_proto_msgTypes[1]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use Userinfo.ProtoReflect.Descriptor instead.
func (*Userinfo) Descriptor() ([]byte, []int) {
	return file_http_http_proto_rawDescGZIP(), []int{1}
}

func (x *Userinfo) GetUsername() string {
	if x != nil {
		return x.Username
	}
	return ""
}

func (x *Userinfo) GetPassword() string {
	if x != nil {
		return x.Password
	}
	return ""
}

func (x *Userinfo) GetPasswordSet() bool {
	if x != nil {
		return x.PasswordSet
	}
	return false
}

type Element struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// key is a element key in a key value pair
	Key string `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"`
	// values are a list of strings corresponding to the key
	Values        []string `protobuf:"bytes,2,rep,name=values,proto3" json:"values,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *Element) Reset() {
	*x = Element{}
	mi := &file_http_http_proto_msgTypes[2]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *Element) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*Element) ProtoMessage() {}

func (x *Element) ProtoReflect() protoreflect.Message {
	mi := &file_http_http_proto_msgTypes[2]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use Element.ProtoReflect.Descriptor instead.
func (*Element) Descriptor() ([]byte, []int) {
	return file_http_http_proto_rawDescGZIP(), []int{2}
}

func (x *Element) GetKey() string {
	if x != nil {
		return x.Key
	}
	return ""
}

func (x *Element) GetValues() []string {
	if x != nil {
		return x.Values
	}
	return nil
}

type Certificates struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// cert is the certificate body
	Cert          [][]byte `protobuf:"bytes,1,rep,name=cert,proto3" json:"cert,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *Certificates) Reset() {
	*x = Certificates{}
	mi := &file_http_http_proto_msgTypes[3]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *Certificates) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*Certificates) ProtoMessage() {}

func (x *Certificates) ProtoReflect() protoreflect.Message {
	mi := &file_http_http_proto_msgTypes[3]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use Certificates.ProtoReflect.Descriptor instead.
func (*Certificates) Descriptor() ([]byte, []int) {
	return file_http_http_proto_rawDescGZIP(), []int{3}
}

func (x *Certificates) GetCert() [][]byte {
	if x != nil {
		return x.Cert
	}
	return nil
}

// ConnectionState is tls.ConnectionState see: https://pkg.go.dev/crypto/tls#ConnectionState
type ConnectionState struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// version is the TLS version used by the connection (e.g. VersionTLS12)
	Version uint32 `protobuf:"varint,1,opt,name=version,proto3" json:"version,omitempty"`
	// handshake_complete is true if the handshake has concluded
	HandshakeComplete bool `protobuf:"varint,2,opt,name=handshake_complete,json=handshakeComplete,proto3" json:"handshake_complete,omitempty"`
	// did_resume is true if this connection was successfully resumed from a
	// previous session with a session ticket or similar mechanism
	DidResume bool `protobuf:"varint,3,opt,name=did_resume,json=didResume,proto3" json:"did_resume,omitempty"`
	// cipher_suite is the cipher suite negotiated for the connection
	CipherSuite uint32 `protobuf:"varint,4,opt,name=cipher_suite,json=cipherSuite,proto3" json:"cipher_suite,omitempty"`
	// negotiated_protocol is the application protocol negotiated with ALPN
	NegotiatedProtocol string `protobuf:"bytes,5,opt,name=negotiated_protocol,json=negotiatedProtocol,proto3" json:"negotiated_protocol,omitempty"`
	// server_name is the value of the Server Name Indication extension sent by
	// the client
	ServerName string `protobuf:"bytes,6,opt,name=server_name,json=serverName,proto3" json:"server_name,omitempty"`
	// peer_certificates are the parsed certificates sent by the peer, in the
	// order in which they were sent
	PeerCertificates *Certificates `protobuf:"bytes,7,opt,name=peer_certificates,json=peerCertificates,proto3" json:"peer_certificates,omitempty"`
	// verified_chains is a list of one or more chains where the first element is
	// PeerCertificates[0] and the last element is from Config.RootCAs (on the
	// client side) or Config.ClientCAs (on the server side).
	VerifiedChains []*Certificates `protobuf:"bytes,8,rep,name=verified_chains,json=verifiedChains,proto3" json:"verified_chains,omitempty"`
	// signed_certificate_timestamps is a list of SCTs provided by the peer
	// through the TLS handshake for the leaf certificate, if any
	SignedCertificateTimestamps [][]byte `protobuf:"bytes,9,rep,name=signed_certificate_timestamps,json=signedCertificateTimestamps,proto3" json:"signed_certificate_timestamps,omitempty"`
	// ocsp_response is a stapled Online Certificate Status Protocol (OCSP)
	// response provided by the peer for the leaf certificate, if any.
	OcspResponse  []byte `protobuf:"bytes,10,opt,name=ocsp_response,json=ocspResponse,proto3" json:"ocsp_response,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *ConnectionState) Reset() {
	*x = ConnectionState{}
	mi := &file_http_http_proto_msgTypes[4]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *ConnectionState) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*ConnectionState) ProtoMessage() {}

func (x *ConnectionState) ProtoReflect() protoreflect.Message {
	mi := &file_http_http_proto_msgTypes[4]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use ConnectionState.ProtoReflect.Descriptor instead.
func (*ConnectionState) Descriptor() ([]byte, []int) {
	return file_http_http_proto_rawDescGZIP(), []int{4}
}

func (x *ConnectionState) GetVersion() uint32 {
	if x != nil {
		return x.Version
	}
	return 0
}

func (x *ConnectionState) GetHandshakeComplete() bool {
	if x != nil {
		return x.HandshakeComplete
	}
	return false
}

func (x *ConnectionState) GetDidResume() bool {
	if x != nil {
		return x.DidResume
	}
	return false
}

func (x *ConnectionState) GetCipherSuite() uint32 {
	if x != nil {
		return x.CipherSuite
	}
	return 0
}

func (x *ConnectionState) GetNegotiatedProtocol() string {
	if x != nil {
		return x.NegotiatedProtocol
	}
	return ""
}

func (x *ConnectionState) GetServerName() string {
	if x != nil {
		return x.ServerName
	}
	return ""
}

func (x *ConnectionState) GetPeerCertificates() *Certificates {
	if x != nil {
		return x.PeerCertificates
	}
	return nil
}

func (x *ConnectionState) GetVerifiedChains() []*Certificates {
	if x != nil {
		return x.VerifiedChains
	}
	return nil
}

func (x *ConnectionState) GetSignedCertificateTimestamps() [][]byte {
	if x != nil {
		return x.SignedCertificateTimestamps
	}
	return nil
}

func (x *ConnectionState) GetOcspResponse() []byte {
	if x != nil {
		return x.OcspResponse
	}
	return nil
}

// Request is an http.Request see: https://pkg.go.dev/net/http#Request
type Request struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// method specifies the HTTP method (GET, POST, PUT, etc.)
	Method string `protobuf:"bytes,1,opt,name=method,proto3" json:"method,omitempty"`
	// url specifies either the URI being requested (for server requests)
	// or the URL to access (for client requests)
	Url *URL `protobuf:"bytes,2,opt,name=url,proto3" json:"url,omitempty"`
	// proto is the protocol version for incoming server requests
	Proto string `protobuf:"bytes,3,opt,name=proto,proto3" json:"proto,omitempty"`
	// proto_major is the major version
	ProtoMajor int32 `protobuf:"varint,4,opt,name=proto_major,json=protoMajor,proto3" json:"proto_major,omitempty"`
	// proto_minor is the minor version
	ProtoMinor int32 `protobuf:"varint,5,opt,name=proto_minor,json=protoMinor,proto3" json:"proto_minor,omitempty"`
	// header contains the request header fields either received
	// by the server or to be sent by the client
	Header []*Element `protobuf:"bytes,6,rep,name=header,proto3" json:"header,omitempty"`
	// content_length records the length of the associated content
	ContentLength int64 `protobuf:"varint,8,opt,name=content_length,json=contentLength,proto3" json:"content_length,omitempty"`
	// transfer_encoding lists the transfer encodings from outermost to
	// innermost
	TransferEncoding []string `protobuf:"bytes,9,rep,name=transfer_encoding,json=transferEncoding,proto3" json:"transfer_encoding,omitempty"`
	// host specifies the host on which the URL is sought
	Host string `protobuf:"bytes,10,opt,name=host,proto3" json:"host,omitempty"`
	// form contains the parsed form data, including both the URL
	// field's query parameters and the PATCH, POST, or PUT form data
	Form []*Element `protobuf:"bytes,11,rep,name=form,proto3" json:"form,omitempty"`
	// post_form contains the parsed form data from PATCH, POST
	// or PUT body parameters
	PostForm []*Element `protobuf:"bytes,12,rep,name=post_form,json=postForm,proto3" json:"post_form,omitempty"`
	// trailer_keys specifies additional headers that are sent after the request
	TrailerKeys []string `protobuf:"bytes,13,rep,name=trailer_keys,json=trailerKeys,proto3" json:"trailer_keys,omitempty"`
	// remote_addr allows HTTP servers and other software to record
	// the network address that sent the request
	RemoteAddr string `protobuf:"bytes,14,opt,name=remote_addr,json=remoteAddr,proto3" json:"remote_addr,omitempty"`
	// request_uri is the unmodified request-target
	RequestUri string `protobuf:"bytes,15,opt,name=request_uri,json=requestUri,proto3" json:"request_uri,omitempty"`
	// tls connection state
	Tls           *ConnectionState `protobuf:"bytes,16,opt,name=tls,proto3" json:"tls,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *Request) Reset() {
	*x = Request{}
	mi := &file_http_http_proto_msgTypes[5]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *Request) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*Request) ProtoMessage() {}

func (x *Request) ProtoReflect() protoreflect.Message {
	mi := &file_http_http_proto_msgTypes[5]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use Request.ProtoReflect.Descriptor instead.
func (*Request) Descriptor() ([]byte, []int) {
	return file_http_http_proto_rawDescGZIP(), []int{5}
}

func (x *Request) GetMethod() string {
	if x != nil {
		return x.Method
	}
	return ""
}

func (x *Request) GetUrl() *URL {
	if x != nil {
		return x.Url
	}
	return nil
}

func (x *Request) GetProto() string {
	if x != nil {
		return x.Proto
	}
	return ""
}

func (x *Request) GetProtoMajor() int32 {
	if x != nil {
		return x.ProtoMajor
	}
	return 0
}

func (x *Request) GetProtoMinor() int32 {
	if x != nil {
		return x.ProtoMinor
	}
	return 0
}

func (x *Request) GetHeader() []*Element {
	if x != nil {
		return x.Header
	}
	return nil
}

func (x *Request) GetContentLength() int64 {
	if x != nil {
		return x.ContentLength
	}
	return 0
}

func (x *Request) GetTransferEncoding() []string {
	if x != nil {
		return x.TransferEncoding
	}
	return nil
}

func (x *Request) GetHost() string {
	if x != nil {
		return x.Host
	}
	return ""
}

func (x *Request) GetForm() []*Element {
	if x != nil {
		return x.Form
	}
	return nil
}

func (x *Request) GetPostForm() []*Element {
	if x != nil {
		return x.PostForm
	}
	return nil
}

func (x *Request) GetTrailerKeys() []string {
	if x != nil {
		return x.TrailerKeys
	}
	return nil
}

func (x *Request) GetRemoteAddr() string {
	if x != nil {
		return x.RemoteAddr
	}
	return ""
}

func (x *Request) GetRequestUri() string {
	if x != nil {
		return x.RequestUri
	}
	return ""
}

func (x *Request) GetTls() *ConnectionState {
	if x != nil {
		return x.Tls
	}
	return nil
}

type ResponseWriter struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// header returns the header map that will be sent by
	// WriteHeader.
	Header []*Element `protobuf:"bytes,1,rep,name=header,proto3" json:"header,omitempty"`
	// server_addr is the address of the gRPC server hosting the Writer service
	ServerAddr    string `protobuf:"bytes,2,opt,name=server_addr,json=serverAddr,proto3" json:"server_addr,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *ResponseWriter) Reset() {
	*x = ResponseWriter{}
	mi := &file_http_http_proto_msgTypes[6]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *ResponseWriter) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*ResponseWriter) ProtoMessage() {}

func (x *ResponseWriter) ProtoReflect() protoreflect.Message {
	mi := &file_http_http_proto_msgTypes[6]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use ResponseWriter.ProtoReflect.Descriptor instead.
func (*ResponseWriter) Descriptor() ([]byte, []int) {
	return file_http_http_proto_rawDescGZIP(), []int{6}
}

func (x *ResponseWriter) GetHeader() []*Element {
	if x != nil {
		return x.Header
	}
	return nil
}

func (x *ResponseWriter) GetServerAddr() string {
	if x != nil {
		return x.ServerAddr
	}
	return ""
}

type HTTPRequest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// response_writer is used by an HTTP handler to construct an HTTP response
	ResponseWriter *ResponseWriter `protobuf:"bytes,1,opt,name=response_writer,json=responseWriter,proto3" json:"response_writer,omitempty"`
	// request is an http request
	Request       *Request `protobuf:"bytes,2,opt,name=request,proto3" json:"request,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *HTTPRequest) Reset() {
	*x = HTTPRequest{}
	mi := &file_http_http_proto_msgTypes[7]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *HTTPRequest) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*HTTPRequest) ProtoMessage() {}

func (x *HTTPRequest) ProtoReflect() protoreflect.Message {
	mi := &file_http_http_proto_msgTypes[7]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use HTTPRequest.ProtoReflect.Descriptor instead.
func (*HTTPRequest) Descriptor() ([]byte, []int) {
	return file_http_http_proto_rawDescGZIP(), []int{7}
}

func (x *HTTPRequest) GetResponseWriter() *ResponseWriter {
	if x != nil {
		return x.ResponseWriter
	}
	return nil
}

func (x *HTTPRequest) GetRequest() *Request {
	if x != nil {
		return x.Request
	}
	return nil
}

type HTTPResponse struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// header is the http headers for the response
	Header        []*Element `protobuf:"bytes,1,rep,name=header,proto3" json:"header,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *HTTPResponse) Reset() {
	*x = HTTPResponse{}
	mi := &file_http_http_proto_msgTypes[8]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *HTTPResponse) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*HTTPResponse) ProtoMessage() {}

func (x *HTTPResponse) ProtoReflect() protoreflect.Message {
	mi := &file_http_http_proto_msgTypes[8]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use HTTPResponse.ProtoReflect.Descriptor instead.
func (*HTTPResponse) Descriptor() ([]byte, []int) {
	return file_http_http_proto_rawDescGZIP(), []int{8}
}

func (x *HTTPResponse) GetHeader() []*Element {
	if x != nil {
		return x.Header
	}
	return nil
}

type HandleSimpleHTTPRequest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// method specifies the HTTP method (GET, POST, PUT, etc.)
	Method string `protobuf:"bytes,1,opt,name=method,proto3" json:"method,omitempty"`
	// url specifies either the URI being requested
	Url string `protobuf:"bytes,2,opt,name=url,proto3" json:"url,omitempty"`
	// request_headers contains the request header fields received by the server
	RequestHeaders []*Element `protobuf:"bytes,3,rep,name=request_headers,json=requestHeaders,proto3" json:"request_headers,omitempty"`
	// body is the request payload in bytes
	Body []byte `protobuf:"bytes,4,opt,name=body,proto3" json:"body,omitempty"`
	// response_headers contains headers that are to be sent by the server to the client
	ResponseHeaders []*Element `protobuf:"bytes,5,rep,name=response_headers,json=responseHeaders,proto3" json:"response_headers,omitempty"`
	unknownFields   protoimpl.UnknownFields
	sizeCache       protoimpl.SizeCache
}

func (x *HandleSimpleHTTPRequest) Reset() {
	*x = HandleSimpleHTTPRequest{}
	mi := &file_http_http_proto_msgTypes[9]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *HandleSimpleHTTPRequest) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*HandleSimpleHTTPRequest) ProtoMessage() {}

func (x *HandleSimpleHTTPRequest) ProtoReflect() protoreflect.Message {
	mi := &file_http_http_proto_msgTypes[9]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use HandleSimpleHTTPRequest.ProtoReflect.Descriptor instead.
func (*HandleSimpleHTTPRequest) Descriptor() ([]byte, []int) {
	return file_http_http_proto_rawDescGZIP(), []int{9}
}

func (x *HandleSimpleHTTPRequest) GetMethod() string {
	if x != nil {
		return x.Method
	}
	return ""
}

func (x *HandleSimpleHTTPRequest) GetUrl() string {
	if x != nil {
		return x.Url
	}
	return ""
}

func (x *HandleSimpleHTTPRequest) GetRequestHeaders() []*Element {
	if x != nil {
		return x.RequestHeaders
	}
	return nil
}

func (x *HandleSimpleHTTPRequest) GetBody() []byte {
	if x != nil {
		return x.Body
	}
	return nil
}

func (x *HandleSimpleHTTPRequest) GetResponseHeaders() []*Element {
	if x != nil {
		return x.ResponseHeaders
	}
	return nil
}

type HandleSimpleHTTPResponse struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// code is the response code
	Code int32 `protobuf:"varint,1,opt,name=code,proto3" json:"code,omitempty"`
	// headers contains the request header fields either received
	// by the server or to be sent by the client
	Headers []*Element `protobuf:"bytes,2,rep,name=headers,proto3" json:"headers,omitempty"`
	// body is the response payload in bytes
	Body          []byte `protobuf:"bytes,3,opt,name=body,proto3" json:"body,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *HandleSimpleHTTPResponse) Reset() {
	*x = HandleSimpleHTTPResponse{}
	mi := &file_http_http_proto_msgTypes[10]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *HandleSimpleHTTPResponse) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*HandleSimpleHTTPResponse) ProtoMessage() {}

func (x *HandleSimpleHTTPResponse) ProtoReflect() protoreflect.Message {
	mi := &file_http_http_proto_msgTypes[10]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use HandleSimpleHTTPResponse.ProtoReflect.Descriptor instead.
func (*HandleSimpleHTTPResponse) Descriptor() ([]byte, []int) {
	return file_http_http_proto_rawDescGZIP(), []int{10}
}

func (x *HandleSimpleHTTPResponse) GetCode() int32 {
	if x != nil {
		return x.Code
	}
	return 0
}

func (x *HandleSimpleHTTPResponse) GetHeaders() []*Element {
	if x != nil {
		return x.Headers
	}
	return nil
}

func (x *HandleSimpleHTTPResponse) GetBody() []byte {
	if x != nil {
		return x.Body
	}
	return nil
}

var File_http_http_proto protoreflect.FileDescriptor

const file_http_http_proto_rawDesc = "" +
	"\n" +
	"\x0fhttp/http.proto\x12\x04http\"\xf6\x01\n" +
	"\x03URL\x12\x16\n" +
	"\x06scheme\x18\x01 \x01(\tR\x06scheme\x12\x16\n" +
	"\x06opaque\x18\x02 \x01(\tR\x06opaque\x12\"\n" +
	"\x04user\x18\x03 \x01(\v2\x0e.http.UserinfoR\x04user\x12\x12\n" +
	"\x04host\x18\x04 \x01(\tR\x04host\x12\x12\n" +
	"\x04path\x18\x05 \x01(\tR\x04path\x12\x19\n" +
	"\braw_path\x18\x06 \x01(\tR\arawPath\x12\x1f\n" +
	"\vforce_query\x18\a \x01(\bR\n" +
	"forceQuery\x12\x1b\n" +
	"\traw_query\x18\b \x01(\tR\brawQuery\x12\x1a\n" +
	"\bfragment\x18\t \x01(\tR\bfragment\"e\n" +
	"\bUserinfo\x12\x1a\n" +
	"\busername\x18\x01 \x01(\tR\busername\x12\x1a\n" +
	"\bpassword\x18\x02 \x01(\tR\bpassword\x12!\n" +
	"\fpassword_set\x18\x03 \x01(\bR\vpasswordSet\"3\n" +
	"\aElement\x12\x10\n" +
	"\x03key\x18\x01 \x01(\tR\x03key\x12\x16\n" +
	"\x06values\x18\x02 \x03(\tR\x06values\"\"\n" +
	"\fCertificates\x12\x12\n" +
	"\x04cert\x18\x01 \x03(\fR\x04cert\"\xd5\x03\n" +
	"\x0fConnectionState\x12\x18\n" +
	"\aversion\x18\x01 \x01(\rR\aversion\x12-\n" +
	"\x12handshake_complete\x18\x02 \x01(\bR\x11handshakeComplete\x12\x1d\n" +
	"\n" +
	"did_resume\x18\x03 \x01(\bR\tdidResume\x12!\n" +
	"\fcipher_suite\x18\x04 \x01(\rR\vcipherSuite\x12/\n" +
	"\x13negotiated_protocol\x18\x05 \x01(\tR\x12negotiatedProtocol\x12\x1f\n" +
	"\vserver_name\x18\x06 \x01(\tR\n" +
	"serverName\x12?\n" +
	"\x11peer_certificates\x18\a \x01(\v2\x12.http.CertificatesR\x10peerCertificates\x12;\n" +
	"\x0fverified_chains\x18\b \x03(\v2\x12.http.CertificatesR\x0everifiedChains\x12B\n" +
	"\x1dsigned_certificate_timestamps\x18\t \x03(\fR\x1bsignedCertificateTimestamps\x12#\n" +
	"\rocsp_response\x18\n" +
	" \x01(\fR\focspResponse\"\x82\x04\n" +
	"\aRequest\x12\x16\n" +
	"\x06method\x18\x01 \x01(\tR\x06method\x12\x1b\n" +
	"\x03url\x18\x02 \x01(\v2\t.http.URLR\x03url\x12\x14\n" +
	"\x05proto\x18\x03 \x01(\tR\x05proto\x12\x1f\n" +
	"\vproto_major\x18\x04 \x01(\x05R\n" +
	"protoMajor\x12\x1f\n" +
	"\vproto_minor\x18\x05 \x01(\x05R\n" +
	"protoMinor\x12%\n" +
	"\x06header\x18\x06 \x03(\v2\r.http.ElementR\x06header\x12%\n" +
	"\x0econtent_length\x18\b \x01(\x03R\rcontentLength\x12+\n" +
	"\x11transfer_encoding\x18\t \x03(\tR\x10transferEncoding\x12\x12\n" +
	"\x04host\x18\n" +
	" \x01(\tR\x04host\x12!\n" +
	"\x04form\x18\v \x03(\v2\r.http.ElementR\x04form\x12*\n" +
	"\tpost_form\x18\f \x03(\v2\r.http.ElementR\bpostForm\x12!\n" +
	"\ftrailer_keys\x18\r \x03(\tR\vtrailerKeys\x12\x1f\n" +
	"\vremote_addr\x18\x0e \x01(\tR\n" +
	"remoteAddr\x12\x1f\n" +
	"\vrequest_uri\x18\x0f \x01(\tR\n" +
	"requestUri\x12'\n" +
	"\x03tls\x18\x10 \x01(\v2\x15.http.ConnectionStateR\x03tls\"X\n" +
	"\x0eResponseWriter\x12%\n" +
	"\x06header\x18\x01 \x03(\v2\r.http.ElementR\x06header\x12\x1f\n" +
	"\vserver_addr\x18\x02 \x01(\tR\n" +
	"serverAddr\"u\n" +
	"\vHTTPRequest\x12=\n" +
	"\x0fresponse_writer\x18\x01 \x01(\v2\x14.http.ResponseWriterR\x0eresponseWriter\x12'\n" +
	"\arequest\x18\x02 \x01(\v2\r.http.RequestR\arequest\"5\n" +
	"\fHTTPResponse\x12%\n" +
	"\x06header\x18\x01 \x03(\v2\r.http.ElementR\x06header\"\xc9\x01\n" +
	"\x17HandleSimpleHTTPRequest\x12\x16\n" +
	"\x06method\x18\x01 \x01(\tR\x06method\x12\x10\n" +
	"\x03url\x18\x02 \x01(\tR\x03url\x126\n" +
	"\x0frequest_headers\x18\x03 \x03(\v2\r.http.ElementR\x0erequestHeaders\x12\x12\n" +
	"\x04body\x18\x04 \x01(\fR\x04body\x128\n" +
	"\x10response_headers\x18\x05 \x03(\v2\r.http.ElementR\x0fresponseHeaders\"k\n" +
	"\x18HandleSimpleHTTPResponse\x12\x12\n" +
	"\x04code\x18\x01 \x01(\x05R\x04code\x12'\n" +
	"\aheaders\x18\x02 \x03(\v2\r.http.ElementR\aheaders\x12\x12\n" +
	"\x04body\x18\x03 \x01(\fR\x04body2\x86\x01\n" +
	"\x04HTTP\x12/\n" +
	"\x06Handle\x12\x11.http.HTTPRequest\x1a\x12.http.HTTPResponse\x12M\n" +
	"\fHandleSimple\x12\x1d.http.HandleSimpleHTTPRequest\x1a\x1e.http.HandleSimpleHTTPResponseB/Z-github.com/ava-labs/avalanchego/proto/pb/httpb\x06proto3"

var (
	file_http_http_proto_rawDescOnce sync.Once
	file_http_http_proto_rawDescData []byte
)

func file_http_http_proto_rawDescGZIP() []byte {
	file_http_http_proto_rawDescOnce.Do(func() {
		file_http_http_proto_rawDescData = protoimpl.X.CompressGZIP(unsafe.Slice(unsafe.StringData(file_http_http_proto_rawDesc), len(file_http_http_proto_rawDesc)))
	})
	return file_http_http_proto_rawDescData
}

var file_http_http_proto_msgTypes = make([]protoimpl.MessageInfo, 11)
var file_http_http_proto_goTypes = []any{
	(*URL)(nil),                      // 0: http.URL
	(*Userinfo)(nil),                 // 1: http.Userinfo
	(*Element)(nil),                  // 2: http.Element
	(*Certificates)(nil),             // 3: http.Certificates
	(*ConnectionState)(nil),          // 4: http.ConnectionState
	(*Request)(nil),                  // 5: http.Request
	(*ResponseWriter)(nil),           // 6: http.ResponseWriter
	(*HTTPRequest)(nil),              // 7: http.HTTPRequest
	(*HTTPResponse)(nil),             // 8: http.HTTPResponse
	(*HandleSimpleHTTPRequest)(nil),  // 9: http.HandleSimpleHTTPRequest
	(*HandleSimpleHTTPResponse)(nil), // 10: http.HandleSimpleHTTPResponse
}
var file_http_http_proto_depIdxs = []int32{
	1,  // 0: http.URL.user:type_name -> http.Userinfo
	3,  // 1: http.ConnectionState.peer_certificates:type_name -> http.Certificates
	3,  // 2: http.ConnectionState.verified_chains:type_name -> http.Certificates
	0,  // 3: http.Request.url:type_name -> http.URL
	2,  // 4: http.Request.header:type_name -> http.Element
	2,  // 5: http.Request.form:type_name -> http.Element
	2,  // 6: http.Request.post_form:type_name -> http.Element
	4,  // 7: http.Request.tls:type_name -> http.ConnectionState
	2,  // 8: http.ResponseWriter.header:type_name -> http.Element
	6,  // 9: http.HTTPRequest.response_writer:type_name -> http.ResponseWriter
	5,  // 10: http.HTTPRequest.request:type_name -> http.Request
	2,  // 11: http.HTTPResponse.header:type_name -> http.Element
	2,  // 12: http.HandleSimpleHTTPRequest.request_headers:type_name -> http.Element
	2,  // 13: http.HandleSimpleHTTPRequest.response_headers:type_name -> http.Element
	2,  // 14: http.HandleSimpleHTTPResponse.headers:type_name -> http.Element
	7,  // 15: http.HTTP.Handle:input_type -> http.HTTPRequest
	9,  // 16: http.HTTP.HandleSimple:input_type -> http.HandleSimpleHTTPRequest
	8,  // 17: http.HTTP.Handle:output_type -> http.HTTPResponse
	10, // 18: http.HTTP.HandleSimple:output_type -> http.HandleSimpleHTTPResponse
	17, // [17:19] is the sub-list for method output_type
	15, // [15:17] is the sub-list for method input_type
	15, // [15:15] is the sub-list for extension type_name
	15, // [15:15] is the sub-list for extension extendee
	0,  // [0:15] is the sub-list for field type_name
}

func init() { file_http_http_proto_init() }
func file_http_http_proto_init() {
	if File_http_http_proto != nil {
		return
	}
	type x struct{}
	out := protoimpl.TypeBuilder{
		File: protoimpl.DescBuilder{
			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
			RawDescriptor: unsafe.Slice(unsafe.StringData(file_http_http_proto_rawDesc), len(file_http_http_proto_rawDesc)),
			NumEnums:      0,
			NumMessages:   11,
			NumExtensions: 0,
			NumServices:   1,
		},
		GoTypes:           file_http_http_proto_goTypes,
		DependencyIndexes: file_http_http_proto_depIdxs,
		MessageInfos:      file_http_http_proto_msgTypes,
	}.Build()
	File_http_http_proto = out.File
	file_http_http_proto_goTypes = nil
	file_http_http_proto_depIdxs = nil
}
