http

type CORSOrigin struct {
	Pattern     string
	Regex       bool
	Methods     []string
	Headers     []string
	Expose      []string
	MaxAge      int
	Credentials bool
}

type CORSPolicy struct {
	Origins []CORSOrigin
}

type ClientError struct {
	// Name is a name for this class of errors.
	Name string
	// Message contains the specific error details.
	Message string
	// Service is the name of the service.
	Service string
	// Method is the name of the service method.
	Method string
	// Is the error temporary?
	Temporary bool
	// Is the error a timeout?
	Timeout bool
	// Is the error a server-side fault?
	Fault bool
	// The original error if any
	Err error
}

type ConnConfigureFunc func(conn *websocket.Conn, cancel context.CancelFunc) *websocket.Conn

type DebugDoer interface {
	Doer
	// Fprint prints the HTTP request and response details.
	Fprint(io.Writer)
}

type Decoder interface {
	// Decode decodes into v.
	Decode(v any) error
}

type Dialer interface {
	// DialContext creates a client connection to the websocket server.
	DialContext(ctx context.Context, url string, h http.Header) (*websocket.Conn, *http.Response, error)
}

type Doer interface {
	Do(*http.Request) (*http.Response, error)
}

type Encoder interface {
	// Encode encodes v.
	Encode(v any) error
}

type EncodingFunc func(v any) error

type ErrorResponse = ProblemResponse

type FileResponse struct {
	// Name is the content name used to infer its media type.
	Name string
	// ModTime is the content modification time. A zero value omits Last-Modified.
	ModTime time.Time
	// Content is the seekable content served in the response.
	Content io.ReadSeeker
}

type FormValuesMarshaler interface {
	// MarshalFormValues appends the encoded representation of the receiver to
	// the given values using the given field prefix.
	MarshalFormValues(values url.Values, prefix string) error
}

type FormValuesUnmarshaler interface {
	// UnmarshalFormValues decodes the receiver from the given values using the
	// given field prefix.
	UnmarshalFormValues(values url.Values, prefix string) error
}

type HandlerLifecycle struct {
	// contains filtered or unexported fields
}

type MiddlewareMuxer interface {
	Muxer
	// Use appends a middleware to the list of middlewares to be applied
	// to the Muxer. Use must be called before Handle or before mounting a
	// generated server.
	Use(func(http.Handler) http.Handler)
}

type Mounter interface {
	Mount(Muxer)
}

type MultipartFile struct {
	// Filename is the uploaded filename from the part headers.
	Filename string
	// ContentType is the part content type.
	ContentType string
	// Data contains the full part payload.
	Data []byte
}

type MultipartForm struct {
	// Values contains non-file part values keyed by form field name.
	Values url.Values
	// Files contains file parts keyed by form field name.
	Files map[string][]MultipartFile
}

type MultipartPartContract struct {
	// Name is the multipart form field name.
	Name string
	// MediaType is the default media type for the part value.
	MediaType string
	// Required reports whether the request body requires the part.
	Required bool
}

type MultipartRequestContract struct {
	// ContentType is the request media type.
	ContentType string
	// Parts lists the designed multipart fields in body order.
	Parts []MultipartPartContract
}

type Muxer interface {
	// Handle registers the handler function for the given method
	// and pattern.
	Handle(method, pattern string, handler http.HandlerFunc)

	// ServeHTTP dispatches the request to the handler whose method
	// matches the request method and whose pattern most closely
	// matches the request URL.
	ServeHTTP(http.ResponseWriter, *http.Request)

	// Vars returns the path variables captured for the given
	// request.
	Vars(*http.Request) map[string]string
}

type ProblemResponse struct {
	Type      string  `json:"type" xml:"type" form:"type"`
	Title     string  `json:"title" xml:"title" form:"title"`
	Status    int     `json:"status" xml:"status" form:"status"`
	Detail    string  `json:"detail" xml:"detail" form:"detail"`
	Instance  string  `json:"instance" xml:"instance" form:"instance"`
	Code      string  `json:"code" xml:"code" form:"code"`
	RetryHint *string `json:"retry_hint,omitempty" xml:"retry_hint,omitempty" form:"retry_hint,omitempty"`
}

type RequestMetadata struct {
	// Method is the request method.
	Method string
	// Path is the decoded request URL path.
	Path string
	// Host is the effective host after trusted-proxy processing.
	Host string
	// Scheme is the effective http or https scheme after trusted-proxy processing.
	Scheme string
	// ClientAddr is the effective client IP after trusted-proxy processing.
	ClientAddr string
	// PeerAddr is the direct network peer IP and is never forwarded.
	PeerAddr string
	// RequestID is the X-Request-Id header value.
	RequestID string
	// UserAgent is the request User-Agent value.
	UserAgent string
	// Origin is the request Origin value.
	Origin string
	// SecFetchSite is the request Sec-Fetch-Site value.
	SecFetchSite string
	// contains filtered or unexported fields
}

type RequestMetadataPolicy struct {
	// contains filtered or unexported fields
}

type ResolverMuxer interface {
	MiddlewareMuxer
	ResolvePattern(*http.Request) string
}

type ResponseContractCase struct {
	// ID is stable while the service response contract is unchanged.
	ID string
	// Kind identifies a successful result or service error response.
	Kind ResponseContractCaseKind
	// Transport identifies the response protocol.
	Transport ResponseContractTransport
	// StatusCode is the exact declared HTTP status code.
	StatusCode int
	// ErrorName is the expected Loom-Error header value for an error case.
	ErrorName string
	// ContentTypes lists the allowed response media types.
	ContentTypes []string
	// RequiredHeaders lists declared response headers that must be present.
	RequiredHeaders []string
	// RequiredCookies lists declared response cookies that must be present.
	RequiredCookies []string
	// Multipart describes the designed multipart request, if present.
	Multipart *MultipartRequestContract
	// SSE describes stream assertions for an SSE success case.
	SSE *SSEResponseContract
	// WebSocket describes stream assertions for a WebSocket success case.
	WebSocket *WebSocketResponseContract
}

type ResponseContractCaseKind string

type ResponseContractTransport string

type RuntimeCORSPolicy struct {
	// contains filtered or unexported fields
}

type SSEControl interface {
	Open(context.Context) error
	SendComment(context.Context, string) error
}

type SSEEvent struct {
	ID   string
	Type string
	Data string
}

type SSEMessage struct {
	ID          string
	Type        string
	Data        string
	RetryMillis int64
}

type SSEResponseContract struct {
	// Direction is the designed stream direction.
	Direction string
	// MessageType is the designed streaming result type name.
	MessageType string
	// DataField is the result field encoded into SSE data, if any.
	DataField string
	// DataEncoding identifies whether SSE data is JSON or plain text.
	DataEncoding string
	// IDField is the result field encoded into SSE id, if any.
	IDField string
	// EventField is the result field encoded into SSE event, if any.
	EventField string
	// RetryField is the result field encoded into SSE retry, if any.
	RetryField string
	// IDRequired reports whether every event must include an ID.
	IDRequired bool
	// EventTypeRequired reports whether every event must include a type.
	EventTypeRequired bool
	// EventTypes lists allowed projection discriminator values, if constrained.
	EventTypes []string
	// Terminal identifies the expected stream completion behavior.
	Terminal string
}

type SSEResponseContractObservation struct {
	// Response is the HTTP handshake response.
	Response *http.Response
	// Events contains parsed SSE frames observed before completion.
	Events []SSEEvent
	// TerminalError is the final error returned by the stream reader.
	TerminalError error
}

type SSEStreamReader struct {
	// contains filtered or unexported fields
}

type SSEStreamWriter struct {
	// contains filtered or unexported fields
}

type Server interface {
	Use(func(http.Handler) http.Handler)
}

type Servers []Server

type Statuser interface {
	// StatusCode return the HTTP status code used to encode the response
	// when not defined in the design.
	StatusCode() int
}

type StreamWritePolicy struct {
	// contains filtered or unexported fields
}

type UnaryHandlerSpec[Payload, Result any] struct {
	// Service is the designed service name.
	Service string
	// Method is the designed service method name.
	Method string
	// Decode converts an HTTP request into the service payload. A nil
	// function supplies the zero value of Payload.
	Decode func(*http.Request) (Payload, error)
	// Invoke calls the typed service endpoint.
	Invoke func(context.Context, Payload) (Result, error)
	// EncodeResponse writes a successful typed result.
	EncodeResponse func(context.Context, http.ResponseWriter, Result) error
	// EncodeError writes a request or endpoint error.
	EncodeError func(context.Context, http.ResponseWriter, error) error
	// HandleFailure receives errors that cannot be written as responses.
	HandleFailure func(context.Context, http.ResponseWriter, error)
}

type UnaryResult[Result any] struct {
	// Value is the raw value returned by the service endpoint.
	Value any
}

type Upgrader interface {
	// Upgrade upgrades the HTTP connection to the websocket protocol.
	Upgrade(w http.ResponseWriter, r *http.Request, responseHeader http.Header) (*websocket.Conn, error)
}

type WebSocketResponseContract struct {
	// Direction is the designed stream direction.
	Direction string
	// InboundMessageType is the designed client-to-server message type name.
	InboundMessageType string
	// OutboundMessageType is the designed server-to-client message type name.
	OutboundMessageType string
	// HandshakeHeaders lists required WebSocket upgrade response headers.
	HandshakeHeaders []string
	// Terminal identifies the expected stream completion behavior.
	Terminal string
}

type WebSocketResponseContractObservation struct {
	// Response is the HTTP upgrade response.
	Response *http.Response
	// Messages contains server-to-client JSON messages in wire order.
	Messages []json.RawMessage
	// TerminalError is the final error returned by the WebSocket reader. It is
	// nil when the contract terminates with one final response message.
	TerminalError error
}

type WebSocketStream struct {
	// contains filtered or unexported fields
}