// Generated by Lisette bindgen
// Source: net/http (Go stdlib)
// Go: 1.25.10
// Lisette: 0.2.1

import "go:bufio"
import "go:context"
import "go:crypto/tls"
import "go:io"
import "go:io/fs"
import "go:log"
import "go:mime/multipart"
import "go:net"
import "go:net/url"
import "go:time"

pub enum ConnState: int {
  StateActive = 1,
  StateClosed = 4,
  StateHijacked = 3,
  StateIdle = 2,
  StateNew = 0,
}

pub const StateActive: ConnState = 1

pub const StateClosed: ConnState = 4

pub const StateHijacked: ConnState = 3

pub const StateIdle: ConnState = 2

pub const StateNew: ConnState = 0

pub enum SameSite: int {
  SameSiteDefaultMode = 1,
  SameSiteLaxMode = 2,
  SameSiteNoneMode = 4,
  SameSiteStrictMode = 3,
}

pub const SameSiteDefaultMode: SameSite = 1

pub const SameSiteLaxMode: SameSite = 2

pub const SameSiteNoneMode: SameSite = 4

pub const SameSiteStrictMode: SameSite = 3

/// AllowQuerySemicolons returns a handler that serves requests by converting any
/// unescaped semicolons in the URL query to ampersands, and invoking the handler h.
/// 
/// This restores the pre-Go 1.17 behavior of splitting query parameters on both
/// semicolons and ampersands. (See golang.org/issue/25192). Note that this
/// behavior doesn't match that of many proxies, and the mismatch can lead to
/// security issues.
/// 
/// AllowQuerySemicolons should be invoked before [Request.ParseForm] is called.
pub fn AllowQuerySemicolons(h: Handler) -> Handler

/// CanonicalHeaderKey returns the canonical format of the
/// header key s. The canonicalization converts the first
/// letter and any letter following a hyphen to upper case;
/// the rest are converted to lowercase. For example, the
/// canonical key for "accept-encoding" is "Accept-Encoding".
/// If s contains a space or invalid header field bytes, it is
/// returned without modifications.
pub fn CanonicalHeaderKey(s: string) -> string

/// DetectContentType implements the algorithm described
/// at https://mimesniff.spec.whatwg.org/ to determine the
/// Content-Type of the given data. It considers at most the
/// first 512 bytes of data. DetectContentType always returns
/// a valid MIME type: if it cannot determine a more specific one, it
/// returns "application/octet-stream".
pub fn DetectContentType(data: Slice<byte>) -> string

/// Error replies to the request with the specified error message and HTTP code.
/// It does not otherwise end the request; the caller should ensure no further
/// writes are done to w.
/// The error message should be plain text.
/// 
/// Error deletes the Content-Length header,
/// sets Content-Type to “text/plain; charset=utf-8”,
/// and sets X-Content-Type-Options to “nosniff”.
/// This configures the header properly for the error message,
/// in case the caller had set it up expecting a successful output.
pub fn Error(w: ResponseWriter, error: string, code: int)

/// FS converts fsys to a [FileSystem] implementation,
/// for use with [FileServer] and [NewFileTransport].
/// The files provided by fsys must implement [io.Seeker].
pub fn FS(fsys: fs.FS) -> FileSystem

/// FileServer returns a handler that serves HTTP requests
/// with the contents of the file system rooted at root.
/// 
/// As a special case, the returned file server redirects any request
/// ending in "/index.html" to the same path, without the final
/// "index.html".
/// 
/// To use the operating system's file system implementation,
/// use [http.Dir]:
/// 
/// 	http.Handle("/", http.FileServer(http.Dir("/tmp")))
/// 
/// To use an [fs.FS] implementation, use [http.FileServerFS] instead.
pub fn FileServer(root: FileSystem) -> Handler

/// FileServerFS returns a handler that serves HTTP requests
/// with the contents of the file system fsys.
/// The files provided by fsys must implement [io.Seeker].
/// 
/// As a special case, the returned file server redirects any request
/// ending in "/index.html" to the same path, without the final
/// "index.html".
/// 
/// 	http.Handle("/", http.FileServerFS(fsys))
pub fn FileServerFS(root: fs.FS) -> Handler

/// Get issues a GET to the specified URL. If the response is one of
/// the following redirect codes, Get follows the redirect, up to a
/// maximum of 10 redirects:
/// 
/// 	301 (Moved Permanently)
/// 	302 (Found)
/// 	303 (See Other)
/// 	307 (Temporary Redirect)
/// 	308 (Permanent Redirect)
/// 
/// An error is returned if there were too many redirects or if there
/// was an HTTP protocol error. A non-2xx response doesn't cause an
/// error. Any returned error will be of type [*url.Error]. The url.Error
/// value's Timeout method will report true if the request timed out.
/// 
/// When err is nil, resp always contains a non-nil resp.Body.
/// Caller should close resp.Body when done reading from it.
/// 
/// Get is a wrapper around DefaultClient.Get.
/// 
/// To make a request with custom headers, use [NewRequest] and
/// DefaultClient.Do.
/// 
/// To make a request with a specified context.Context, use [NewRequestWithContext]
/// and DefaultClient.Do.
pub fn Get(url: string) -> Result<Ref<Response>, error>

/// Handle registers the handler for the given pattern in [DefaultServeMux].
/// The documentation for [ServeMux] explains how patterns are matched.
pub fn Handle(pattern: string, handler: Handler)

/// HandleFunc registers the handler function for the given pattern in [DefaultServeMux].
/// The documentation for [ServeMux] explains how patterns are matched.
pub fn HandleFunc(
  pattern: string,
  handler: fn(ResponseWriter, Ref<Request>) -> (),
)

/// Head issues a HEAD to the specified URL. If the response is one of
/// the following redirect codes, Head follows the redirect, up to a
/// maximum of 10 redirects:
/// 
/// 	301 (Moved Permanently)
/// 	302 (Found)
/// 	303 (See Other)
/// 	307 (Temporary Redirect)
/// 	308 (Permanent Redirect)
/// 
/// Head is a wrapper around DefaultClient.Head.
/// 
/// To make a request with a specified [context.Context], use [NewRequestWithContext]
/// and DefaultClient.Do.
pub fn Head(url: string) -> Result<Ref<Response>, error>

/// ListenAndServe listens on the TCP network address addr and then calls
/// [Serve] with handler to handle requests on incoming connections.
/// Accepted connections are configured to enable TCP keep-alives.
/// 
/// The handler is typically nil, in which case [DefaultServeMux] is used.
/// 
/// ListenAndServe always returns a non-nil error.
pub fn ListenAndServe(addr: string, handler: Handler) -> Result<(), error>

/// ListenAndServeTLS acts identically to [ListenAndServe], except that it
/// expects HTTPS connections. Additionally, files containing a certificate and
/// matching private key for the server must be provided. If the certificate
/// is signed by a certificate authority, the certFile should be the concatenation
/// of the server's certificate, any intermediates, and the CA's certificate.
pub fn ListenAndServeTLS(
  addr: string,
  certFile: string,
  keyFile: string,
  handler: Handler,
) -> Result<(), error>

/// MaxBytesHandler returns a [Handler] that runs h with its [ResponseWriter] and [Request.Body] wrapped by a MaxBytesReader.
pub fn MaxBytesHandler(h: Handler, n: int64) -> Handler

/// MaxBytesReader is similar to [io.LimitReader] but is intended for
/// limiting the size of incoming request bodies. In contrast to
/// io.LimitReader, MaxBytesReader's result is a ReadCloser, returns a
/// non-nil error of type [*MaxBytesError] for a Read beyond the limit,
/// and closes the underlying reader when its Close method is called.
/// 
/// MaxBytesReader prevents clients from accidentally or maliciously
/// sending a large request and wasting server resources. If possible,
/// it tells the [ResponseWriter] to close the connection after the limit
/// has been reached.
pub fn MaxBytesReader(w: ResponseWriter, r: io.ReadCloser, n: int64) -> io.ReadCloser

/// NewCrossOriginProtection returns a new [CrossOriginProtection] value.
pub fn NewCrossOriginProtection() -> Ref<CrossOriginProtection>

/// NewFileTransport returns a new [RoundTripper], serving the provided
/// [FileSystem]. The returned RoundTripper ignores the URL host in its
/// incoming requests, as well as most other properties of the
/// request.
/// 
/// The typical use case for NewFileTransport is to register the "file"
/// protocol with a [Transport], as in:
/// 
/// 	t := &http.Transport{}
/// 	t.RegisterProtocol("file", http.NewFileTransport(http.Dir("/")))
/// 	c := &http.Client{Transport: t}
/// 	res, err := c.Get("file:///etc/passwd")
/// 	...
pub fn NewFileTransport(fs: FileSystem) -> RoundTripper

/// NewFileTransportFS returns a new [RoundTripper], serving the provided
/// file system fsys. The returned RoundTripper ignores the URL host in its
/// incoming requests, as well as most other properties of the
/// request. The files provided by fsys must implement [io.Seeker].
/// 
/// The typical use case for NewFileTransportFS is to register the "file"
/// protocol with a [Transport], as in:
/// 
/// 	fsys := os.DirFS("/")
/// 	t := &http.Transport{}
/// 	t.RegisterProtocol("file", http.NewFileTransportFS(fsys))
/// 	c := &http.Client{Transport: t}
/// 	res, err := c.Get("file:///etc/passwd")
/// 	...
pub fn NewFileTransportFS(fsys: fs.FS) -> RoundTripper

/// NewRequest wraps [NewRequestWithContext] using [context.Background].
pub fn NewRequest(method: string, url: string, body: io.Reader) -> Result<Ref<Request>, error>

/// NewRequestWithContext returns a new [Request] given a method, URL, and
/// optional body.
/// 
/// If the provided body is also an [io.Closer], the returned
/// [Request.Body] is set to body and will be closed (possibly
/// asynchronously) by the Client methods Do, Post, and PostForm,
/// and [Transport.RoundTrip].
/// 
/// NewRequestWithContext returns a Request suitable for use with
/// [Client.Do] or [Transport.RoundTrip]. To create a request for use with
/// testing a Server Handler, either use the [net/http/httptest.NewRequest] function,
/// use [ReadRequest], or manually update the Request fields.
/// For an outgoing client request, the context
/// controls the entire lifetime of a request and its response:
/// obtaining a connection, sending the request, and reading the
/// response headers and body. See the [Request] type's documentation for
/// the difference between inbound and outbound request fields.
/// 
/// If body is of type [*bytes.Buffer], [*bytes.Reader], or
/// [*strings.Reader], the returned request's ContentLength is set to its
/// exact value (instead of -1), GetBody is populated (so 307 and 308
/// redirects can replay the body), and Body is set to [NoBody] if the
/// ContentLength is 0.
pub fn NewRequestWithContext(
  ctx: context.Context,
  method: string,
  url: string,
  body: io.Reader,
) -> Result<Ref<Request>, error>

/// NewResponseController creates a [ResponseController] for a request.
/// 
/// The ResponseWriter should be the original value passed to the [Handler.ServeHTTP] method,
/// or have an Unwrap method returning the original ResponseWriter.
/// 
/// If the ResponseWriter implements any of the following methods, the ResponseController
/// will call them as appropriate:
/// 
/// 	Flush()
/// 	FlushError() error // alternative Flush returning an error
/// 	Hijack() (net.Conn, *bufio.ReadWriter, error)
/// 	SetReadDeadline(deadline time.Time) error
/// 	SetWriteDeadline(deadline time.Time) error
/// 	EnableFullDuplex() error
/// 
/// If the ResponseWriter does not support a method, ResponseController returns
/// an error matching [ErrNotSupported].
pub fn NewResponseController(rw: ResponseWriter) -> Ref<ResponseController>

/// NewServeMux allocates and returns a new [ServeMux].
pub fn NewServeMux() -> Ref<ServeMux>

/// NotFound replies to the request with an HTTP 404 not found error.
pub fn NotFound(w: ResponseWriter, r: Ref<Request>)

/// NotFoundHandler returns a simple request handler
/// that replies to each request with a “404 page not found” reply.
pub fn NotFoundHandler() -> Handler

/// ParseCookie parses a Cookie header value and returns all the cookies
/// which were set in it. Since the same cookie name can appear multiple times
/// the returned Values can contain more than one value for a given key.
pub fn ParseCookie(line: string) -> Result<Slice<Ref<Cookie>>, error>

/// ParseHTTPVersion parses an HTTP version string according to RFC 7230, section 2.6.
/// "HTTP/1.0" returns (1, 0, true). Note that strings without
/// a minor version, such as "HTTP/2", are not valid.
pub fn ParseHTTPVersion(vers: string) -> Option<(int, int)>

/// ParseSetCookie parses a Set-Cookie header value and returns a cookie.
/// It returns an error on syntax error.
pub fn ParseSetCookie(line: string) -> Result<Ref<Cookie>, error>

/// ParseTime parses a time header (such as the Date: header),
/// trying each of the three formats allowed by HTTP/1.1:
/// [TimeFormat], [time.RFC850], and [time.ANSIC].
pub fn ParseTime(text: string) -> Result<time.Time, error>

/// Post issues a POST to the specified URL.
/// 
/// Caller should close resp.Body when done reading from it.
/// 
/// If the provided body is an [io.Closer], it is closed after the
/// request.
/// 
/// Post is a wrapper around DefaultClient.Post.
/// 
/// To set custom headers, use [NewRequest] and DefaultClient.Do.
/// 
/// See the [Client.Do] method documentation for details on how redirects
/// are handled.
/// 
/// To make a request with a specified context.Context, use [NewRequestWithContext]
/// and DefaultClient.Do.
pub fn Post(url: string, contentType: string, body: io.Reader) -> Result<Ref<Response>, error>

/// PostForm issues a POST to the specified URL, with data's keys and
/// values URL-encoded as the request body.
/// 
/// The Content-Type header is set to application/x-www-form-urlencoded.
/// To set other headers, use [NewRequest] and DefaultClient.Do.
/// 
/// When err is nil, resp always contains a non-nil resp.Body.
/// Caller should close resp.Body when done reading from it.
/// 
/// PostForm is a wrapper around DefaultClient.PostForm.
/// 
/// See the [Client.Do] method documentation for details on how redirects
/// are handled.
/// 
/// To make a request with a specified [context.Context], use [NewRequestWithContext]
/// and DefaultClient.Do.
pub fn PostForm(url: string, data: url.Values) -> Result<Ref<Response>, error>

/// ProxyFromEnvironment returns the URL of the proxy to use for a
/// given request, as indicated by the environment variables
/// HTTP_PROXY, HTTPS_PROXY and NO_PROXY (or the lowercase versions
/// thereof). Requests use the proxy from the environment variable
/// matching their scheme, unless excluded by NO_PROXY.
/// 
/// The environment values may be either a complete URL or a
/// "host[:port]", in which case the "http" scheme is assumed.
/// An error is returned if the value is a different form.
/// 
/// A nil URL and nil error are returned if no proxy is defined in the
/// environment, or a proxy should not be used for the given request,
/// as defined by NO_PROXY.
/// 
/// As a special case, if req.URL.Host is "localhost" (with or without
/// a port number), then a nil URL and nil error will be returned.
pub fn ProxyFromEnvironment(req: Ref<Request>) -> Result<Ref<url.URL>, error>

/// ProxyURL returns a proxy function (for use in a [Transport])
/// that always returns the same URL.
pub fn ProxyURL(fixedURL: Ref<url.URL>) -> Option<fn(Ref<Request>) -> Result<Ref<url.URL>, error>>

/// ReadRequest reads and parses an incoming request from b.
/// 
/// ReadRequest is a low-level function and should only be used for
/// specialized applications; most code should use the [Server] to read
/// requests and handle them via the [Handler] interface. ReadRequest
/// only supports HTTP/1.x requests. For HTTP/2, use golang.org/x/net/http2.
pub fn ReadRequest(b: Ref<bufio.Reader>) -> Result<Ref<Request>, error>

/// ReadResponse reads and returns an HTTP response from r.
/// The req parameter optionally specifies the [Request] that corresponds
/// to this [Response]. If nil, a GET request is assumed.
/// Clients must call resp.Body.Close when finished reading resp.Body.
/// After that call, clients can inspect resp.Trailer to find key/value
/// pairs included in the response trailer.
pub fn ReadResponse(r: Ref<bufio.Reader>, req: Ref<Request>) -> Result<Ref<Response>, error>

/// Redirect replies to the request with a redirect to url,
/// which may be a path relative to the request path.
/// Any non-ASCII characters in url will be percent-encoded,
/// but existing percent encodings will not be changed.
/// 
/// The provided code should be in the 3xx range and is usually
/// [StatusMovedPermanently], [StatusFound] or [StatusSeeOther].
/// 
/// If the Content-Type header has not been set, [Redirect] sets it
/// to "text/html; charset=utf-8" and writes a small HTML body.
/// Setting the Content-Type header to any value, including nil,
/// disables that behavior.
pub fn Redirect(w: ResponseWriter, r: Ref<Request>, url: string, code: int)

/// RedirectHandler returns a request handler that redirects
/// each request it receives to the given url using the given
/// status code.
/// 
/// The provided code should be in the 3xx range and is usually
/// [StatusMovedPermanently], [StatusFound] or [StatusSeeOther].
pub fn RedirectHandler(url: string, code: int) -> Handler

/// Serve accepts incoming HTTP connections on the listener l,
/// creating a new service goroutine for each. The service goroutines
/// read requests and then call handler to reply to them.
/// 
/// The handler is typically nil, in which case [DefaultServeMux] is used.
/// 
/// HTTP/2 support is only enabled if the Listener returns [*tls.Conn]
/// connections and they were configured with "h2" in the TLS
/// Config.NextProtos.
/// 
/// Serve always returns a non-nil error.
pub fn Serve(l: net.Listener, handler: Handler) -> Result<(), error>

/// ServeContent replies to the request using the content in the
/// provided ReadSeeker. The main benefit of ServeContent over [io.Copy]
/// is that it handles Range requests properly, sets the MIME type, and
/// handles If-Match, If-Unmodified-Since, If-None-Match, If-Modified-Since,
/// and If-Range requests.
/// 
/// If the response's Content-Type header is not set, ServeContent
/// first tries to deduce the type from name's file extension and,
/// if that fails, falls back to reading the first block of the content
/// and passing it to [DetectContentType].
/// The name is otherwise unused; in particular it can be empty and is
/// never sent in the response.
/// 
/// If modtime is not the zero time or Unix epoch, ServeContent
/// includes it in a Last-Modified header in the response. If the
/// request includes an If-Modified-Since header, ServeContent uses
/// modtime to decide whether the content needs to be sent at all.
/// 
/// The content's Seek method must work: ServeContent uses
/// a seek to the end of the content to determine its size.
/// Note that [*os.File] implements the [io.ReadSeeker] interface.
/// 
/// If the caller has set w's ETag header formatted per RFC 7232, section 2.3,
/// ServeContent uses it to handle requests using If-Match, If-None-Match, or If-Range.
/// 
/// If an error occurs when serving the request (for example, when
/// handling an invalid range request), ServeContent responds with an
/// error message. By default, ServeContent strips the Cache-Control,
/// Content-Encoding, ETag, and Last-Modified headers from error responses.
/// The GODEBUG setting httpservecontentkeepheaders=1 causes ServeContent
/// to preserve these headers.
pub fn ServeContent(
  w: ResponseWriter,
  req: Ref<Request>,
  name: string,
  modtime: time.Time,
  content: io.ReadSeeker,
)

/// ServeFile replies to the request with the contents of the named
/// file or directory.
/// 
/// If the provided file or directory name is a relative path, it is
/// interpreted relative to the current directory and may ascend to
/// parent directories. If the provided name is constructed from user
/// input, it should be sanitized before calling [ServeFile].
/// 
/// As a precaution, ServeFile will reject requests where r.URL.Path
/// contains a ".." path element; this protects against callers who
/// might unsafely use [filepath.Join] on r.URL.Path without sanitizing
/// it and then use that filepath.Join result as the name argument.
/// 
/// As another special case, ServeFile redirects any request where r.URL.Path
/// ends in "/index.html" to the same path, without the final
/// "index.html". To avoid such redirects either modify the path or
/// use [ServeContent].
/// 
/// Outside of those two special cases, ServeFile does not use
/// r.URL.Path for selecting the file or directory to serve; only the
/// file or directory provided in the name argument is used.
pub fn ServeFile(w: ResponseWriter, r: Ref<Request>, name: string)

/// ServeFileFS replies to the request with the contents
/// of the named file or directory from the file system fsys.
/// The files provided by fsys must implement [io.Seeker].
/// 
/// If the provided name is constructed from user input, it should be
/// sanitized before calling [ServeFileFS].
/// 
/// As a precaution, ServeFileFS will reject requests where r.URL.Path
/// contains a ".." path element; this protects against callers who
/// might unsafely use [filepath.Join] on r.URL.Path without sanitizing
/// it and then use that filepath.Join result as the name argument.
/// 
/// As another special case, ServeFileFS redirects any request where r.URL.Path
/// ends in "/index.html" to the same path, without the final
/// "index.html". To avoid such redirects either modify the path or
/// use [ServeContent].
/// 
/// Outside of those two special cases, ServeFileFS does not use
/// r.URL.Path for selecting the file or directory to serve; only the
/// file or directory provided in the name argument is used.
pub fn ServeFileFS(
  w: ResponseWriter,
  r: Ref<Request>,
  fsys: fs.FS,
  name: string,
)

/// ServeTLS accepts incoming HTTPS connections on the listener l,
/// creating a new service goroutine for each. The service goroutines
/// read requests and then call handler to reply to them.
/// 
/// The handler is typically nil, in which case [DefaultServeMux] is used.
/// 
/// Additionally, files containing a certificate and matching private key
/// for the server must be provided. If the certificate is signed by a
/// certificate authority, the certFile should be the concatenation
/// of the server's certificate, any intermediates, and the CA's certificate.
/// 
/// ServeTLS always returns a non-nil error.
pub fn ServeTLS(
  l: net.Listener,
  handler: Handler,
  certFile: string,
  keyFile: string,
) -> Result<(), error>

/// SetCookie adds a Set-Cookie header to the provided [ResponseWriter]'s headers.
/// The provided cookie must have a valid Name. Invalid cookies may be
/// silently dropped.
pub fn SetCookie(w: ResponseWriter, cookie: Ref<Cookie>)

/// StatusText returns a text for the HTTP status code. It returns the empty
/// string if the code is unknown.
pub fn StatusText(code: int) -> string

/// StripPrefix returns a handler that serves HTTP requests by removing the
/// given prefix from the request URL's Path (and RawPath if set) and invoking
/// the handler h. StripPrefix handles a request for a path that doesn't begin
/// with prefix by replying with an HTTP 404 not found error. The prefix must
/// match exactly: if the prefix in the request contains escaped characters
/// the reply is also an HTTP 404 not found error.
pub fn StripPrefix(prefix: string, h: Handler) -> Handler

/// TimeoutHandler returns a [Handler] that runs h with the given time limit.
/// 
/// The new Handler calls h.ServeHTTP to handle each request, but if a
/// call runs for longer than its time limit, the handler responds with
/// a 503 Service Unavailable error and the given message in its body.
/// (If msg is empty, a suitable default message will be sent.)
/// After such a timeout, writes by h to its [ResponseWriter] will return
/// [ErrHandlerTimeout].
/// 
/// TimeoutHandler supports the [Pusher] interface but does not support
/// the [Hijacker] or [Flusher] interfaces.
pub fn TimeoutHandler(h: Handler, dt: time.Duration, msg: string) -> Handler

/// A Client is an HTTP client. Its zero value ([DefaultClient]) is a
/// usable client that uses [DefaultTransport].
/// 
/// The [Client.Transport] typically has internal state (cached TCP
/// connections), so Clients should be reused instead of created as
/// needed. Clients are safe for concurrent use by multiple goroutines.
/// 
/// A Client is higher-level than a [RoundTripper] (such as [Transport])
/// and additionally handles HTTP details such as cookies and
/// redirects.
/// 
/// When following redirects, the Client will forward all headers set on the
/// initial [Request] except:
/// 
///   - when forwarding sensitive headers like "Authorization",
///     "WWW-Authenticate", and "Cookie" to untrusted targets.
///     These headers will be ignored when following a redirect to a domain
///     that is not a subdomain match or exact match of the initial domain.
///     For example, a redirect from "foo.com" to either "foo.com" or "sub.foo.com"
///     will forward the sensitive headers, but a redirect to "bar.com" will not.
///   - when forwarding the "Cookie" header with a non-nil cookie Jar.
///     Since each redirect may mutate the state of the cookie jar,
///     a redirect may possibly alter a cookie set in the initial request.
///     When forwarding the "Cookie" header, any mutated cookies will be omitted,
///     with the expectation that the Jar will insert those mutated cookies
///     with the updated values (assuming the origin matches).
///     If Jar is nil, the initial cookies are forwarded without change.
pub struct Client {
  pub Transport: Option<RoundTripper>,
  pub CheckRedirect: Option<fn(Ref<Request>, Slice<Ref<Request>>) -> Result<(), error>>,
  pub Jar: Option<CookieJar>,
  pub Timeout: time.Duration,
}

/// The CloseNotifier interface is implemented by ResponseWriters which
/// allow detecting when the underlying connection has gone away.
/// 
/// This mechanism can be used to cancel long operations on the server
/// if the client has disconnected before the response is ready.
/// 
/// Deprecated: the CloseNotifier interface predates Go's context package.
/// New code should use [Request.Context] instead.
pub interface CloseNotifier {
  fn CloseNotify() -> Receiver<bool>
}

/// A Cookie represents an HTTP cookie as sent in the Set-Cookie header of an
/// HTTP response or the Cookie header of an HTTP request.
/// 
/// See https://tools.ietf.org/html/rfc6265 for details.
pub struct Cookie {
  pub Name: string,
  pub Value: string,
  pub Quoted: bool,
  pub Path: string,
  pub Domain: string,
  pub Expires: time.Time,
  pub RawExpires: string,
  pub MaxAge: int,
  pub Secure: bool,
  pub HttpOnly: bool,
  pub SameSite: SameSite,
  pub Partitioned: bool,
  pub Raw: string,
  pub Unparsed: Slice<string>,
}

/// A CookieJar manages storage and use of cookies in HTTP requests.
/// 
/// Implementations of CookieJar must be safe for concurrent use by multiple
/// goroutines.
/// 
/// The net/http/cookiejar package provides a CookieJar implementation.
pub interface CookieJar {
  fn Cookies(u: Ref<url.URL>) -> Slice<Ref<Cookie>>
  fn SetCookies(u: Ref<url.URL>, cookies: Slice<Ref<Cookie>>)
}

/// CrossOriginProtection implements protections against [Cross-Site Request
/// Forgery (CSRF)] by rejecting non-safe cross-origin browser requests.
/// 
/// Cross-origin requests are currently detected with the [Sec-Fetch-Site]
/// header, available in all browsers since 2023, or by comparing the hostname of
/// the [Origin] header with the Host header.
/// 
/// The GET, HEAD, and OPTIONS methods are [safe methods] and are always allowed.
/// It's important that applications do not perform any state changing actions
/// due to requests with safe methods.
/// 
/// Requests without Sec-Fetch-Site or Origin headers are currently assumed to be
/// either same-origin or non-browser requests, and are allowed.
/// 
/// The zero value of CrossOriginProtection is valid and has no trusted origins
/// or bypass patterns.
/// 
/// [Sec-Fetch-Site]: https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Sec-Fetch-Site
/// [Origin]: https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Origin
/// [Cross-Site Request Forgery (CSRF)]: https://developer.mozilla.org/en-US/docs/Web/Security/Attacks/CSRF
/// [safe methods]: https://developer.mozilla.org/en-US/docs/Glossary/Safe/HTTP
pub type CrossOriginProtection

/// A Dir implements [FileSystem] using the native file system restricted to a
/// specific directory tree.
/// 
/// While the [FileSystem.Open] method takes '/'-separated paths, a Dir's string
/// value is a directory path on the native file system, not a URL, so it is separated
/// by [filepath.Separator], which isn't necessarily '/'.
/// 
/// Note that Dir could expose sensitive files and directories. Dir will follow
/// symlinks pointing out of the directory tree, which can be especially dangerous
/// if serving from a directory in which users are able to create arbitrary symlinks.
/// Dir will also allow access to files and directories starting with a period,
/// which could expose sensitive directories like .git or sensitive files like
/// .htpasswd. To exclude files with a leading period, remove the files/directories
/// from the server or create a custom FileSystem implementation.
/// 
/// An empty Dir is treated as ".".
pub struct Dir(string)

/// A File is returned by a [FileSystem]'s Open method and can be
/// served by the [FileServer] implementation.
/// 
/// The methods should behave the same as those on an [*os.File].
pub interface File {
  fn Close() -> Result<(), error>
  fn Read(mut p: Slice<byte>) -> Partial<int, error>
  fn Readdir(count: int) -> Result<Slice<fs.FileInfo>, error>
  fn Seek(offset: int64, whence: int) -> Result<int64, error>
  fn Stat() -> Result<fs.FileInfo, error>
}

/// A FileSystem implements access to a collection of named files.
/// The elements in a file path are separated by slash ('/', U+002F)
/// characters, regardless of host operating system convention.
/// See the [FileServer] function to convert a FileSystem to a [Handler].
/// 
/// This interface predates the [fs.FS] interface, which can be used instead:
/// the [FS] adapter function converts an fs.FS to a FileSystem.
pub interface FileSystem {
  fn Open(name: string) -> Result<File, error>
}

/// The Flusher interface is implemented by ResponseWriters that allow
/// an HTTP handler to flush buffered data to the client.
/// 
/// The default HTTP/1.x and HTTP/2 [ResponseWriter] implementations
/// support [Flusher], but ResponseWriter wrappers may not. Handlers
/// should always test for this ability at runtime.
/// 
/// Note that even for ResponseWriters that support Flush,
/// if the client is connected through an HTTP proxy,
/// the buffered data may not reach the client until the response
/// completes.
pub interface Flusher {
  fn Flush()
}

/// HTTP2Config defines HTTP/2 configuration parameters common to
/// both [Transport] and [Server].
pub struct HTTP2Config {
  pub MaxConcurrentStreams: int,
  pub MaxDecoderHeaderTableSize: int,
  pub MaxEncoderHeaderTableSize: int,
  pub MaxReadFrameSize: int,
  pub MaxReceiveBufferPerConnection: int,
  pub MaxReceiveBufferPerStream: int,
  pub SendPingTimeout: time.Duration,
  pub PingTimeout: time.Duration,
  pub WriteByteTimeout: time.Duration,
  pub PermitProhibitedCipherSuites: bool,
  pub CountError: Option<fn(string) -> ()>,
}

/// A Handler responds to an HTTP request.
/// 
/// [Handler.ServeHTTP] should write reply headers and data to the [ResponseWriter]
/// and then return. Returning signals that the request is finished; it
/// is not valid to use the [ResponseWriter] or read from the
/// [Request.Body] after or concurrently with the completion of the
/// ServeHTTP call.
/// 
/// Depending on the HTTP client software, HTTP protocol version, and
/// any intermediaries between the client and the Go server, it may not
/// be possible to read from the [Request.Body] after writing to the
/// [ResponseWriter]. Cautious handlers should read the [Request.Body]
/// first, and then reply.
/// 
/// Except for reading the body, handlers should not modify the
/// provided Request.
/// 
/// If ServeHTTP panics, the server (the caller of ServeHTTP) assumes
/// that the effect of the panic was isolated to the active request.
/// It recovers the panic, logs a stack trace to the server error log,
/// and either closes the network connection or sends an HTTP/2
/// RST_STREAM, depending on the HTTP protocol. To abort a handler so
/// the client sees an interrupted response but the server doesn't log
/// an error, panic with the value [ErrAbortHandler].
pub interface Handler {
  fn ServeHTTP(responseWriter: ResponseWriter, request: Ref<Request>)
}

/// The HandlerFunc type is an adapter to allow the use of
/// ordinary functions as HTTP handlers. If f is a function
/// with the appropriate signature, HandlerFunc(f) is a
/// [Handler] that calls f.
pub type HandlerFunc = fn(ResponseWriter, Ref<Request>) -> ()

/// A Header represents the key-value pairs in an HTTP header.
/// 
/// The keys should be in canonical form, as returned by
/// [CanonicalHeaderKey].
pub struct Header(Map<string, Slice<string>>)

/// The Hijacker interface is implemented by ResponseWriters that allow
/// an HTTP handler to take over the connection.
/// 
/// The default [ResponseWriter] for HTTP/1.x connections supports
/// Hijacker, but HTTP/2 connections intentionally do not.
/// ResponseWriter wrappers may also not support Hijacker. Handlers
/// should always test for this ability at runtime.
pub interface Hijacker {
  fn Hijack() -> Result<(net.Conn, Ref<bufio.ReadWriter>), error>
}

/// MaxBytesError is returned by [MaxBytesReader] when its read limit is exceeded.
pub struct MaxBytesError {
  pub Limit: int64,
}

/// ProtocolError represents an HTTP protocol error.
/// 
/// Deprecated: Not all errors in the http package related to protocol errors
/// are of type ProtocolError.
pub struct ProtocolError {
  pub ErrorString: string,
}

/// Protocols is a set of HTTP protocols.
/// The zero value is an empty set of protocols.
/// 
/// The supported protocols are:
/// 
///   - HTTP1 is the HTTP/1.0 and HTTP/1.1 protocols.
///     HTTP1 is supported on both unsecured TCP and secured TLS connections.
/// 
///   - HTTP2 is the HTTP/2 protcol over a TLS connection.
/// 
///   - UnencryptedHTTP2 is the HTTP/2 protocol over an unsecured TCP connection.
pub type Protocols

/// PushOptions describes options for [Pusher.Push].
pub struct PushOptions {
  pub Method: string,
  pub Header: Header,
}

/// Pusher is the interface implemented by ResponseWriters that support
/// HTTP/2 server push. For more background, see
/// https://tools.ietf.org/html/rfc7540#section-8.2.
pub interface Pusher {
  fn Push(target: string, opts: Ref<PushOptions>) -> Result<(), error>
}

/// A Request represents an HTTP request received by a server
/// or to be sent by a client.
/// 
/// The field semantics differ slightly between client and server
/// usage. In addition to the notes on the fields below, see the
/// documentation for [Request.Write] and [RoundTripper].
pub struct Request {
  pub Method: string,
  pub URL: Option<Ref<url.URL>>,
  pub Proto: string,
  pub ProtoMajor: int,
  pub ProtoMinor: int,
  pub Header: Header,
  pub Body: Option<io.ReadCloser>,
  pub GetBody: Option<fn() -> Result<io.ReadCloser, error>>,
  pub ContentLength: int64,
  pub TransferEncoding: Slice<string>,
  pub Close: bool,
  pub Host: string,
  pub Form: url.Values,
  pub PostForm: url.Values,
  pub MultipartForm: Option<Ref<multipart.Form>>,
  pub Trailer: Header,
  pub RemoteAddr: string,
  pub RequestURI: string,
  pub TLS: Option<Ref<tls.ConnectionState>>,
  pub Cancel: Receiver<()>,
  pub Response: Option<Ref<Response>>,
  pub Pattern: string,
}

/// Response represents the response from an HTTP request.
/// 
/// The [Client] and [Transport] return Responses from servers once
/// the response headers have been received. The response body
/// is streamed on demand as the Body field is read.
pub struct Response {
  pub Status: string,
  pub StatusCode: int,
  pub Proto: string,
  pub ProtoMajor: int,
  pub ProtoMinor: int,
  pub Header: Header,
  pub Body: Option<io.ReadCloser>,
  pub ContentLength: int64,
  pub TransferEncoding: Slice<string>,
  pub Close: bool,
  pub Uncompressed: bool,
  pub Trailer: Header,
  pub Request: Option<Ref<Request>>,
  pub TLS: Option<Ref<tls.ConnectionState>>,
}

/// A ResponseController is used by an HTTP handler to control the response.
/// 
/// A ResponseController may not be used after the [Handler.ServeHTTP] method has returned.
pub type ResponseController

/// A ResponseWriter interface is used by an HTTP handler to
/// construct an HTTP response.
/// 
/// A ResponseWriter may not be used after [Handler.ServeHTTP] has returned.
pub interface ResponseWriter {
  fn Header() -> Header
  fn Write(b: Slice<byte>) -> Partial<int, error>
  fn WriteHeader(statusCode: int)
}

/// RoundTripper is an interface representing the ability to execute a
/// single HTTP transaction, obtaining the [Response] for a given [Request].
/// 
/// A RoundTripper must be safe for concurrent use by multiple
/// goroutines.
pub interface RoundTripper {
  fn RoundTrip(request: Ref<Request>) -> Result<Ref<Response>, error>
}

/// ServeMux is an HTTP request multiplexer.
/// It matches the URL of each incoming request against a list of registered
/// patterns and calls the handler for the pattern that
/// most closely matches the URL.
/// 
/// # Patterns
/// 
/// Patterns can match the method, host and path of a request.
/// Some examples:
/// 
///   - "/index.html" matches the path "/index.html" for any host and method.
///   - "GET /static/" matches a GET request whose path begins with "/static/".
///   - "example.com/" matches any request to the host "example.com".
///   - "example.com/{$}" matches requests with host "example.com" and path "/".
///   - "/b/{bucket}/o/{objectname...}" matches paths whose first segment is "b"
///     and whose third segment is "o". The name "bucket" denotes the second
///     segment and "objectname" denotes the remainder of the path.
/// 
/// In general, a pattern looks like
/// 
/// 	[METHOD ][HOST]/[PATH]
/// 
/// All three parts are optional; "/" is a valid pattern.
/// If METHOD is present, it must be followed by at least one space or tab.
/// 
/// Literal (that is, non-wildcard) parts of a pattern match
/// the corresponding parts of a request case-sensitively.
/// 
/// A pattern with no method matches every method. A pattern
/// with the method GET matches both GET and HEAD requests.
/// Otherwise, the method must match exactly.
/// 
/// A pattern with no host matches every host.
/// A pattern with a host matches URLs on that host only.
/// 
/// A path can include wildcard segments of the form {NAME} or {NAME...}.
/// For example, "/b/{bucket}/o/{objectname...}".
/// The wildcard name must be a valid Go identifier.
/// Wildcards must be full path segments: they must be preceded by a slash and followed by
/// either a slash or the end of the string.
/// For example, "/b_{bucket}" is not a valid pattern.
/// 
/// Normally a wildcard matches only a single path segment,
/// ending at the next literal slash (not %2F) in the request URL.
/// But if the "..." is present, then the wildcard matches the remainder of the URL path, including slashes.
/// (Therefore it is invalid for a "..." wildcard to appear anywhere but at the end of a pattern.)
/// The match for a wildcard can be obtained by calling [Request.PathValue] with the wildcard's name.
/// A trailing slash in a path acts as an anonymous "..." wildcard.
/// 
/// The special wildcard {$} matches only the end of the URL.
/// For example, the pattern "/{$}" matches only the path "/",
/// whereas the pattern "/" matches every path.
/// 
/// For matching, both pattern paths and incoming request paths are unescaped segment by segment.
/// So, for example, the path "/a%2Fb/100%25" is treated as having two segments, "a/b" and "100%".
/// The pattern "/a%2fb/" matches it, but the pattern "/a/b/" does not.
/// 
/// # Precedence
/// 
/// If two or more patterns match a request, then the most specific pattern takes precedence.
/// A pattern P1 is more specific than P2 if P1 matches a strict subset of P2’s requests;
/// that is, if P2 matches all the requests of P1 and more.
/// If neither is more specific, then the patterns conflict.
/// There is one exception to this rule, for backwards compatibility:
/// if two patterns would otherwise conflict and one has a host while the other does not,
/// then the pattern with the host takes precedence.
/// If a pattern passed to [ServeMux.Handle] or [ServeMux.HandleFunc] conflicts with
/// another pattern that is already registered, those functions panic.
/// 
/// As an example of the general rule, "/images/thumbnails/" is more specific than "/images/",
/// so both can be registered.
/// The former matches paths beginning with "/images/thumbnails/"
/// and the latter will match any other path in the "/images/" subtree.
/// 
/// As another example, consider the patterns "GET /" and "/index.html":
/// both match a GET request for "/index.html", but the former pattern
/// matches all other GET and HEAD requests, while the latter matches any
/// request for "/index.html" that uses a different method.
/// The patterns conflict.
/// 
/// # Trailing-slash redirection
/// 
/// Consider a [ServeMux] with a handler for a subtree, registered using a trailing slash or "..." wildcard.
/// If the ServeMux receives a request for the subtree root without a trailing slash,
/// it redirects the request by adding the trailing slash.
/// This behavior can be overridden with a separate registration for the path without
/// the trailing slash or "..." wildcard. For example, registering "/images/" causes ServeMux
/// to redirect a request for "/images" to "/images/", unless "/images" has
/// been registered separately.
/// 
/// # Request sanitizing
/// 
/// ServeMux also takes care of sanitizing the URL request path and the Host
/// header, stripping the port number and redirecting any request containing . or
/// .. segments or repeated slashes to an equivalent, cleaner URL.
/// Escaped path elements such as "%2e" for "." and "%2f" for "/" are preserved
/// and aren't considered separators for request routing.
/// 
/// # Compatibility
/// 
/// The pattern syntax and matching behavior of ServeMux changed significantly
/// in Go 1.22. To restore the old behavior, set the GODEBUG environment variable
/// to "httpmuxgo121=1". This setting is read once, at program startup; changes
/// during execution will be ignored.
/// 
/// The backwards-incompatible changes include:
///   - Wildcards are just ordinary literal path segments in 1.21.
///     For example, the pattern "/{x}" will match only that path in 1.21,
///     but will match any one-segment path in 1.22.
///   - In 1.21, no pattern was rejected, unless it was empty or conflicted with an existing pattern.
///     In 1.22, syntactically invalid patterns will cause [ServeMux.Handle] and [ServeMux.HandleFunc] to panic.
///     For example, in 1.21, the patterns "/{"  and "/a{x}" match themselves,
///     but in 1.22 they are invalid and will cause a panic when registered.
///   - In 1.22, each segment of a pattern is unescaped; this was not done in 1.21.
///     For example, in 1.22 the pattern "/%61" matches the path "/a" ("%61" being the URL escape sequence for "a"),
///     but in 1.21 it would match only the path "/%2561" (where "%25" is the escape for the percent sign).
///   - When matching patterns to paths, in 1.22 each segment of the path is unescaped; in 1.21, the entire path is unescaped.
///     This change mostly affects how paths with %2F escapes adjacent to slashes are treated.
///     See https://go.dev/issue/21955 for details.
pub type ServeMux

/// A Server defines parameters for running an HTTP server.
/// The zero value for Server is a valid configuration.
pub struct Server {
  pub Addr: string,
  pub Handler: Option<Handler>,
  pub DisableGeneralOptionsHandler: bool,
  pub TLSConfig: Option<Ref<tls.Config>>,
  pub ReadTimeout: time.Duration,
  pub ReadHeaderTimeout: time.Duration,
  pub WriteTimeout: time.Duration,
  pub IdleTimeout: time.Duration,
  pub MaxHeaderBytes: int,
  pub TLSNextProto: Map<string, Option<fn(Ref<Server>, Ref<tls.Conn>, Handler) -> ()>>,
  pub ConnState: Option<fn(net.Conn, ConnState) -> ()>,
  pub ErrorLog: Option<Ref<log.Logger>>,
  pub BaseContext: Option<fn(net.Listener) -> context.Context>,
  pub ConnContext: Option<fn(context.Context, net.Conn) -> context.Context>,
  pub HTTP2: Option<Ref<HTTP2Config>>,
  pub Protocols: Option<Ref<Protocols>>,
}

/// Transport is an implementation of [RoundTripper] that supports HTTP,
/// HTTPS, and HTTP proxies (for either HTTP or HTTPS with CONNECT).
/// 
/// By default, Transport caches connections for future re-use.
/// This may leave many open connections when accessing many hosts.
/// This behavior can be managed using [Transport.CloseIdleConnections] method
/// and the [Transport.MaxIdleConnsPerHost] and [Transport.DisableKeepAlives] fields.
/// 
/// Transports should be reused instead of created as needed.
/// Transports are safe for concurrent use by multiple goroutines.
/// 
/// A Transport is a low-level primitive for making HTTP and HTTPS requests.
/// For high-level functionality, such as cookies and redirects, see [Client].
/// 
/// Transport uses HTTP/1.1 for HTTP URLs and either HTTP/1.1 or HTTP/2
/// for HTTPS URLs, depending on whether the server supports HTTP/2,
/// and how the Transport is configured. The [DefaultTransport] supports HTTP/2.
/// To explicitly enable HTTP/2 on a transport, set [Transport.Protocols].
/// 
/// Responses with status codes in the 1xx range are either handled
/// automatically (100 expect-continue) or ignored. The one
/// exception is HTTP status code 101 (Switching Protocols), which is
/// considered a terminal status and returned by [Transport.RoundTrip]. To see the
/// ignored 1xx responses, use the httptrace trace package's
/// ClientTrace.Got1xxResponse.
/// 
/// Transport only retries a request upon encountering a network error
/// if the connection has been already been used successfully and if the
/// request is idempotent and either has no body or has its [Request.GetBody]
/// defined. HTTP requests are considered idempotent if they have HTTP methods
/// GET, HEAD, OPTIONS, or TRACE; or if their [Header] map contains an
/// "Idempotency-Key" or "X-Idempotency-Key" entry. If the idempotency key
/// value is a zero-length slice, the request is treated as idempotent but the
/// header is not sent on the wire.
pub struct Transport {
  pub Proxy: Option<fn(Ref<Request>) -> Result<Ref<url.URL>, error>>,
  pub OnProxyConnectResponse: Option<fn(context.Context, Ref<url.URL>, Ref<Request>, Ref<Response>) -> Result<(), error>>,
  pub DialContext: Option<fn(context.Context, string, string) -> Result<net.Conn, error>>,
  pub Dial: Option<fn(string, string) -> Result<net.Conn, error>>,
  pub DialTLSContext: Option<fn(context.Context, string, string) -> Result<net.Conn, error>>,
  pub DialTLS: Option<fn(string, string) -> Result<net.Conn, error>>,
  pub TLSClientConfig: Option<Ref<tls.Config>>,
  pub TLSHandshakeTimeout: time.Duration,
  pub DisableKeepAlives: bool,
  pub DisableCompression: bool,
  pub MaxIdleConns: int,
  pub MaxIdleConnsPerHost: int,
  pub MaxConnsPerHost: int,
  pub IdleConnTimeout: time.Duration,
  pub ResponseHeaderTimeout: time.Duration,
  pub ExpectContinueTimeout: time.Duration,
  pub TLSNextProto: Map<string, Option<fn(string, Ref<tls.Conn>) -> RoundTripper>>,
  pub ProxyConnectHeader: Header,
  pub GetProxyConnectHeader: Option<fn(context.Context, Ref<url.URL>, string) -> Result<Header, error>>,
  pub MaxResponseHeaderBytes: int64,
  pub WriteBufferSize: int,
  pub ReadBufferSize: int,
  pub ForceAttemptHTTP2: bool,
  pub HTTP2: Option<Ref<HTTP2Config>>,
  pub Protocols: Option<Ref<Protocols>>,
}

/// DefaultMaxHeaderBytes is the maximum permitted size of the headers
/// in an HTTP request.
/// This can be overridden by setting [Server.MaxHeaderBytes].
pub const DefaultMaxHeaderBytes = 1048576

/// DefaultMaxIdleConnsPerHost is the default value of [Transport]'s
/// MaxIdleConnsPerHost.
pub const DefaultMaxIdleConnsPerHost = 2

/// Common HTTP methods.
/// 
/// Unless otherwise noted, these are defined in RFC 7231 section 4.3.
pub const MethodConnect = "CONNECT"

/// Common HTTP methods.
/// 
/// Unless otherwise noted, these are defined in RFC 7231 section 4.3.
pub const MethodDelete = "DELETE"

/// Common HTTP methods.
/// 
/// Unless otherwise noted, these are defined in RFC 7231 section 4.3.
pub const MethodGet = "GET"

/// Common HTTP methods.
/// 
/// Unless otherwise noted, these are defined in RFC 7231 section 4.3.
pub const MethodHead = "HEAD"

/// Common HTTP methods.
/// 
/// Unless otherwise noted, these are defined in RFC 7231 section 4.3.
pub const MethodOptions = "OPTIONS"

/// Common HTTP methods.
/// 
/// Unless otherwise noted, these are defined in RFC 7231 section 4.3.
pub const MethodPatch = "PATCH"

/// Common HTTP methods.
/// 
/// Unless otherwise noted, these are defined in RFC 7231 section 4.3.
pub const MethodPost = "POST"

/// Common HTTP methods.
/// 
/// Unless otherwise noted, these are defined in RFC 7231 section 4.3.
pub const MethodPut = "PUT"

/// Common HTTP methods.
/// 
/// Unless otherwise noted, these are defined in RFC 7231 section 4.3.
pub const MethodTrace = "TRACE"

/// HTTP status codes as registered with IANA.
/// See: https://www.iana.org/assignments/http-status-codes/http-status-codes.xhtml
pub const StatusAccepted = 202

/// HTTP status codes as registered with IANA.
/// See: https://www.iana.org/assignments/http-status-codes/http-status-codes.xhtml
pub const StatusAlreadyReported = 208

/// HTTP status codes as registered with IANA.
/// See: https://www.iana.org/assignments/http-status-codes/http-status-codes.xhtml
pub const StatusBadGateway = 502

/// HTTP status codes as registered with IANA.
/// See: https://www.iana.org/assignments/http-status-codes/http-status-codes.xhtml
pub const StatusBadRequest = 400

/// HTTP status codes as registered with IANA.
/// See: https://www.iana.org/assignments/http-status-codes/http-status-codes.xhtml
pub const StatusConflict = 409

/// HTTP status codes as registered with IANA.
/// See: https://www.iana.org/assignments/http-status-codes/http-status-codes.xhtml
pub const StatusContinue = 100

/// HTTP status codes as registered with IANA.
/// See: https://www.iana.org/assignments/http-status-codes/http-status-codes.xhtml
pub const StatusCreated = 201

/// HTTP status codes as registered with IANA.
/// See: https://www.iana.org/assignments/http-status-codes/http-status-codes.xhtml
pub const StatusEarlyHints = 103

/// HTTP status codes as registered with IANA.
/// See: https://www.iana.org/assignments/http-status-codes/http-status-codes.xhtml
pub const StatusExpectationFailed = 417

/// HTTP status codes as registered with IANA.
/// See: https://www.iana.org/assignments/http-status-codes/http-status-codes.xhtml
pub const StatusFailedDependency = 424

/// HTTP status codes as registered with IANA.
/// See: https://www.iana.org/assignments/http-status-codes/http-status-codes.xhtml
pub const StatusForbidden = 403

/// HTTP status codes as registered with IANA.
/// See: https://www.iana.org/assignments/http-status-codes/http-status-codes.xhtml
pub const StatusFound = 302

/// HTTP status codes as registered with IANA.
/// See: https://www.iana.org/assignments/http-status-codes/http-status-codes.xhtml
pub const StatusGatewayTimeout = 504

/// HTTP status codes as registered with IANA.
/// See: https://www.iana.org/assignments/http-status-codes/http-status-codes.xhtml
pub const StatusGone = 410

/// HTTP status codes as registered with IANA.
/// See: https://www.iana.org/assignments/http-status-codes/http-status-codes.xhtml
pub const StatusHTTPVersionNotSupported = 505

/// HTTP status codes as registered with IANA.
/// See: https://www.iana.org/assignments/http-status-codes/http-status-codes.xhtml
pub const StatusIMUsed = 226

/// HTTP status codes as registered with IANA.
/// See: https://www.iana.org/assignments/http-status-codes/http-status-codes.xhtml
pub const StatusInsufficientStorage = 507

/// HTTP status codes as registered with IANA.
/// See: https://www.iana.org/assignments/http-status-codes/http-status-codes.xhtml
pub const StatusInternalServerError = 500

/// HTTP status codes as registered with IANA.
/// See: https://www.iana.org/assignments/http-status-codes/http-status-codes.xhtml
pub const StatusLengthRequired = 411

/// HTTP status codes as registered with IANA.
/// See: https://www.iana.org/assignments/http-status-codes/http-status-codes.xhtml
pub const StatusLocked = 423

/// HTTP status codes as registered with IANA.
/// See: https://www.iana.org/assignments/http-status-codes/http-status-codes.xhtml
pub const StatusLoopDetected = 508

/// HTTP status codes as registered with IANA.
/// See: https://www.iana.org/assignments/http-status-codes/http-status-codes.xhtml
pub const StatusMethodNotAllowed = 405

/// HTTP status codes as registered with IANA.
/// See: https://www.iana.org/assignments/http-status-codes/http-status-codes.xhtml
pub const StatusMisdirectedRequest = 421

/// HTTP status codes as registered with IANA.
/// See: https://www.iana.org/assignments/http-status-codes/http-status-codes.xhtml
pub const StatusMovedPermanently = 301

/// HTTP status codes as registered with IANA.
/// See: https://www.iana.org/assignments/http-status-codes/http-status-codes.xhtml
pub const StatusMultiStatus = 207

/// HTTP status codes as registered with IANA.
/// See: https://www.iana.org/assignments/http-status-codes/http-status-codes.xhtml
pub const StatusMultipleChoices = 300

/// HTTP status codes as registered with IANA.
/// See: https://www.iana.org/assignments/http-status-codes/http-status-codes.xhtml
pub const StatusNetworkAuthenticationRequired = 511

/// HTTP status codes as registered with IANA.
/// See: https://www.iana.org/assignments/http-status-codes/http-status-codes.xhtml
pub const StatusNoContent = 204

/// HTTP status codes as registered with IANA.
/// See: https://www.iana.org/assignments/http-status-codes/http-status-codes.xhtml
pub const StatusNonAuthoritativeInfo = 203

/// HTTP status codes as registered with IANA.
/// See: https://www.iana.org/assignments/http-status-codes/http-status-codes.xhtml
pub const StatusNotAcceptable = 406

/// HTTP status codes as registered with IANA.
/// See: https://www.iana.org/assignments/http-status-codes/http-status-codes.xhtml
pub const StatusNotExtended = 510

/// HTTP status codes as registered with IANA.
/// See: https://www.iana.org/assignments/http-status-codes/http-status-codes.xhtml
pub const StatusNotFound = 404

/// HTTP status codes as registered with IANA.
/// See: https://www.iana.org/assignments/http-status-codes/http-status-codes.xhtml
pub const StatusNotImplemented = 501

/// HTTP status codes as registered with IANA.
/// See: https://www.iana.org/assignments/http-status-codes/http-status-codes.xhtml
pub const StatusNotModified = 304

/// HTTP status codes as registered with IANA.
/// See: https://www.iana.org/assignments/http-status-codes/http-status-codes.xhtml
pub const StatusOK = 200

/// HTTP status codes as registered with IANA.
/// See: https://www.iana.org/assignments/http-status-codes/http-status-codes.xhtml
pub const StatusPartialContent = 206

/// HTTP status codes as registered with IANA.
/// See: https://www.iana.org/assignments/http-status-codes/http-status-codes.xhtml
pub const StatusPaymentRequired = 402

/// HTTP status codes as registered with IANA.
/// See: https://www.iana.org/assignments/http-status-codes/http-status-codes.xhtml
pub const StatusPermanentRedirect = 308

/// HTTP status codes as registered with IANA.
/// See: https://www.iana.org/assignments/http-status-codes/http-status-codes.xhtml
pub const StatusPreconditionFailed = 412

/// HTTP status codes as registered with IANA.
/// See: https://www.iana.org/assignments/http-status-codes/http-status-codes.xhtml
pub const StatusPreconditionRequired = 428

/// HTTP status codes as registered with IANA.
/// See: https://www.iana.org/assignments/http-status-codes/http-status-codes.xhtml
pub const StatusProcessing = 102

/// HTTP status codes as registered with IANA.
/// See: https://www.iana.org/assignments/http-status-codes/http-status-codes.xhtml
pub const StatusProxyAuthRequired = 407

/// HTTP status codes as registered with IANA.
/// See: https://www.iana.org/assignments/http-status-codes/http-status-codes.xhtml
pub const StatusRequestEntityTooLarge = 413

/// HTTP status codes as registered with IANA.
/// See: https://www.iana.org/assignments/http-status-codes/http-status-codes.xhtml
pub const StatusRequestHeaderFieldsTooLarge = 431

/// HTTP status codes as registered with IANA.
/// See: https://www.iana.org/assignments/http-status-codes/http-status-codes.xhtml
pub const StatusRequestTimeout = 408

/// HTTP status codes as registered with IANA.
/// See: https://www.iana.org/assignments/http-status-codes/http-status-codes.xhtml
pub const StatusRequestURITooLong = 414

/// HTTP status codes as registered with IANA.
/// See: https://www.iana.org/assignments/http-status-codes/http-status-codes.xhtml
pub const StatusRequestedRangeNotSatisfiable = 416

/// HTTP status codes as registered with IANA.
/// See: https://www.iana.org/assignments/http-status-codes/http-status-codes.xhtml
pub const StatusResetContent = 205

/// HTTP status codes as registered with IANA.
/// See: https://www.iana.org/assignments/http-status-codes/http-status-codes.xhtml
pub const StatusSeeOther = 303

/// HTTP status codes as registered with IANA.
/// See: https://www.iana.org/assignments/http-status-codes/http-status-codes.xhtml
pub const StatusServiceUnavailable = 503

/// HTTP status codes as registered with IANA.
/// See: https://www.iana.org/assignments/http-status-codes/http-status-codes.xhtml
pub const StatusSwitchingProtocols = 101

/// HTTP status codes as registered with IANA.
/// See: https://www.iana.org/assignments/http-status-codes/http-status-codes.xhtml
pub const StatusTeapot = 418

/// HTTP status codes as registered with IANA.
/// See: https://www.iana.org/assignments/http-status-codes/http-status-codes.xhtml
pub const StatusTemporaryRedirect = 307

/// HTTP status codes as registered with IANA.
/// See: https://www.iana.org/assignments/http-status-codes/http-status-codes.xhtml
pub const StatusTooEarly = 425

/// HTTP status codes as registered with IANA.
/// See: https://www.iana.org/assignments/http-status-codes/http-status-codes.xhtml
pub const StatusTooManyRequests = 429

/// HTTP status codes as registered with IANA.
/// See: https://www.iana.org/assignments/http-status-codes/http-status-codes.xhtml
pub const StatusUnauthorized = 401

/// HTTP status codes as registered with IANA.
/// See: https://www.iana.org/assignments/http-status-codes/http-status-codes.xhtml
pub const StatusUnavailableForLegalReasons = 451

/// HTTP status codes as registered with IANA.
/// See: https://www.iana.org/assignments/http-status-codes/http-status-codes.xhtml
pub const StatusUnprocessableEntity = 422

/// HTTP status codes as registered with IANA.
/// See: https://www.iana.org/assignments/http-status-codes/http-status-codes.xhtml
pub const StatusUnsupportedMediaType = 415

/// HTTP status codes as registered with IANA.
/// See: https://www.iana.org/assignments/http-status-codes/http-status-codes.xhtml
pub const StatusUpgradeRequired = 426

/// HTTP status codes as registered with IANA.
/// See: https://www.iana.org/assignments/http-status-codes/http-status-codes.xhtml
pub const StatusUseProxy = 305

/// HTTP status codes as registered with IANA.
/// See: https://www.iana.org/assignments/http-status-codes/http-status-codes.xhtml
pub const StatusVariantAlsoNegotiates = 506

/// TimeFormat is the time format to use when generating times in HTTP
/// headers. It is like [time.RFC1123] but hard-codes GMT as the time
/// zone. The time being formatted must be in UTC for Format to
/// generate the correct format.
/// 
/// For parsing this time format, see [ParseTime].
pub const TimeFormat = "Mon, 02 Jan 2006 15:04:05 GMT"

/// TrailerPrefix is a magic prefix for [ResponseWriter.Header] map keys
/// that, if present, signals that the map entry is actually for
/// the response trailers, and not the response headers. The prefix
/// is stripped after the ServeHTTP call finishes and the values are
/// sent in the trailers.
/// 
/// This mechanism is intended only for trailers that are not known
/// prior to the headers being written. If the set of trailers is fixed
/// or known before the header is written, the normal Go trailers mechanism
/// is preferred:
/// 
/// 	https://pkg.go.dev/net/http#ResponseWriter
/// 	https://pkg.go.dev/net/http#example-ResponseWriter-Trailers
pub const TrailerPrefix = "Trailer:"

/// DefaultClient is the default [Client] and is used by [Get], [Head], and [Post].
pub var DefaultClient: Ref<Client>

/// DefaultServeMux is the default [ServeMux] used by [Serve].
pub var DefaultServeMux: Ref<ServeMux>

pub var DefaultTransport: RoundTripper

/// ErrAbortHandler is a sentinel panic value to abort a handler.
/// While any panic from ServeHTTP aborts the response to the client,
/// panicking with ErrAbortHandler also suppresses logging of a stack
/// trace to the server's error log.
pub var ErrAbortHandler: error

/// Errors used by the HTTP server.
pub var ErrBodyNotAllowed: error

/// ErrBodyReadAfterClose is returned when reading a [Request] or [Response]
/// Body after the body has been closed. This typically happens when the body is
/// read after an HTTP [Handler] calls WriteHeader or Write on its
/// [ResponseWriter].
pub var ErrBodyReadAfterClose: error

/// Errors used by the HTTP server.
pub var ErrContentLength: error

/// ErrHandlerTimeout is returned on [ResponseWriter] Write calls
/// in handlers which have timed out.
pub var ErrHandlerTimeout: error

pub var ErrHeaderTooLong: Ref<ProtocolError>

/// Errors used by the HTTP server.
pub var ErrHijacked: error

/// ErrLineTooLong is returned when reading request or response bodies
/// with malformed chunked encoding.
pub var ErrLineTooLong: error

pub var ErrMissingBoundary: Ref<ProtocolError>

pub var ErrMissingContentLength: Ref<ProtocolError>

/// ErrMissingFile is returned by FormFile when the provided file field name
/// is either not present in the request or not a file field.
pub var ErrMissingFile: error

/// ErrNoCookie is returned by Request's Cookie method when a cookie is not found.
pub var ErrNoCookie: error

/// ErrNoLocation is returned by the [Response.Location] method
/// when no Location header is present.
pub var ErrNoLocation: error

pub var ErrNotMultipart: Ref<ProtocolError>

pub var ErrNotSupported: Ref<ProtocolError>

/// ErrSchemeMismatch is returned when a server returns an HTTP response to an HTTPS client.
pub var ErrSchemeMismatch: error

/// ErrServerClosed is returned by the [Server.Serve], [ServeTLS], [ListenAndServe],
/// and [ListenAndServeTLS] methods after a call to [Server.Shutdown] or [Server.Close].
pub var ErrServerClosed: error

pub var ErrShortBody: Ref<ProtocolError>

/// ErrSkipAltProtocol is a sentinel error value defined by Transport.RegisterProtocol.
pub var ErrSkipAltProtocol: error

pub var ErrUnexpectedTrailer: Ref<ProtocolError>

/// ErrUseLastResponse can be returned by Client.CheckRedirect hooks to
/// control how redirects are processed. If returned, the next request
/// is not sent and the most recent response is returned with its body
/// unclosed.
pub var ErrUseLastResponse: error

/// Errors used by the HTTP server.
pub var ErrWriteAfterFlush: error

// SKIPPED: LocalAddrContextKey - opaque-unexported-struct
// underlying type "contextKey" is unexported

/// NoBody is an [io.ReadCloser] with no bytes. Read always returns EOF
/// and Close always returns nil. It can be used in an outgoing client
/// request to explicitly signal that a request has zero bytes.
/// An alternative, however, is to simply set [Request.Body] to nil.
pub var NoBody: ()

// SKIPPED: ServerContextKey - opaque-unexported-struct
// underlying type "contextKey" is unexported

impl Client {
  /// CloseIdleConnections closes any connections on its [Transport] which
  /// were previously connected from previous requests but are now
  /// sitting idle in a "keep-alive" state. It does not interrupt any
  /// connections currently in use.
  /// 
  /// If [Client.Transport] does not have a [Client.CloseIdleConnections] method
  /// then this method does nothing.
  fn CloseIdleConnections(self: Ref<Client>)

  /// Do sends an HTTP request and returns an HTTP response, following
  /// policy (such as redirects, cookies, auth) as configured on the
  /// client.
  /// 
  /// An error is returned if caused by client policy (such as
  /// CheckRedirect), or failure to speak HTTP (such as a network
  /// connectivity problem). A non-2xx status code doesn't cause an
  /// error.
  /// 
  /// If the returned error is nil, the [Response] will contain a non-nil
  /// Body which the user is expected to close. If the Body is not both
  /// read to EOF and closed, the [Client]'s underlying [RoundTripper]
  /// (typically [Transport]) may not be able to re-use a persistent TCP
  /// connection to the server for a subsequent "keep-alive" request.
  /// 
  /// The request Body, if non-nil, will be closed by the underlying
  /// Transport, even on errors. The Body may be closed asynchronously after
  /// Do returns.
  /// 
  /// On error, any Response can be ignored. A non-nil Response with a
  /// non-nil error only occurs when CheckRedirect fails, and even then
  /// the returned [Response.Body] is already closed.
  /// 
  /// Generally [Get], [Post], or [PostForm] will be used instead of Do.
  /// 
  /// If the server replies with a redirect, the Client first uses the
  /// CheckRedirect function to determine whether the redirect should be
  /// followed. If permitted, a 301, 302, or 303 redirect causes
  /// subsequent requests to use HTTP method GET
  /// (or HEAD if the original request was HEAD), with no body.
  /// A 307 or 308 redirect preserves the original HTTP method and body,
  /// provided that the [Request.GetBody] function is defined.
  /// The [NewRequest] function automatically sets GetBody for common
  /// standard library body types.
  /// 
  /// Any returned error will be of type [*url.Error]. The url.Error
  /// value's Timeout method will report true if the request timed out.
  fn Do(self: Ref<Client>, req: Ref<Request>) -> Result<Ref<Response>, error>

  /// Get issues a GET to the specified URL. If the response is one of the
  /// following redirect codes, Get follows the redirect after calling the
  /// [Client.CheckRedirect] function:
  /// 
  /// 	301 (Moved Permanently)
  /// 	302 (Found)
  /// 	303 (See Other)
  /// 	307 (Temporary Redirect)
  /// 	308 (Permanent Redirect)
  /// 
  /// An error is returned if the [Client.CheckRedirect] function fails
  /// or if there was an HTTP protocol error. A non-2xx response doesn't
  /// cause an error. Any returned error will be of type [*url.Error]. The
  /// url.Error value's Timeout method will report true if the request
  /// timed out.
  /// 
  /// When err is nil, resp always contains a non-nil resp.Body.
  /// Caller should close resp.Body when done reading from it.
  /// 
  /// To make a request with custom headers, use [NewRequest] and [Client.Do].
  /// 
  /// To make a request with a specified context.Context, use [NewRequestWithContext]
  /// and Client.Do.
  fn Get(self: Ref<Client>, url: string) -> Result<Ref<Response>, error>

  /// Head issues a HEAD to the specified URL. If the response is one of the
  /// following redirect codes, Head follows the redirect after calling the
  /// [Client.CheckRedirect] function:
  /// 
  /// 	301 (Moved Permanently)
  /// 	302 (Found)
  /// 	303 (See Other)
  /// 	307 (Temporary Redirect)
  /// 	308 (Permanent Redirect)
  /// 
  /// To make a request with a specified [context.Context], use [NewRequestWithContext]
  /// and [Client.Do].
  fn Head(self: Ref<Client>, url: string) -> Result<Ref<Response>, error>

  /// Post issues a POST to the specified URL.
  /// 
  /// Caller should close resp.Body when done reading from it.
  /// 
  /// If the provided body is an [io.Closer], it is closed after the
  /// request.
  /// 
  /// To set custom headers, use [NewRequest] and [Client.Do].
  /// 
  /// To make a request with a specified context.Context, use [NewRequestWithContext]
  /// and [Client.Do].
  /// 
  /// See the [Client.Do] method documentation for details on how redirects
  /// are handled.
  fn Post(self: Ref<Client>, url: string, contentType: string, body: io.Reader) -> Result<Ref<Response>, error>

  /// PostForm issues a POST to the specified URL,
  /// with data's keys and values URL-encoded as the request body.
  /// 
  /// The Content-Type header is set to application/x-www-form-urlencoded.
  /// To set other headers, use [NewRequest] and [Client.Do].
  /// 
  /// When err is nil, resp always contains a non-nil resp.Body.
  /// Caller should close resp.Body when done reading from it.
  /// 
  /// See the [Client.Do] method documentation for details on how redirects
  /// are handled.
  /// 
  /// To make a request with a specified context.Context, use [NewRequestWithContext]
  /// and Client.Do.
  fn PostForm(self: Ref<Client>, url: string, data: url.Values) -> Result<Ref<Response>, error>
}

impl ConnState {
  fn String(self) -> string
}

impl Cookie {
  /// String returns the serialization of the cookie for use in a [Cookie]
  /// header (if only Name and Value are set) or a Set-Cookie response
  /// header (if other fields are set).
  /// If c is nil or c.Name is invalid, the empty string is returned.
  fn String(self: Ref<Cookie>) -> string

  /// Valid reports whether the cookie is valid.
  fn Valid(self: Ref<Cookie>) -> Result<(), error>
}

impl CrossOriginProtection {
  /// AddInsecureBypassPattern permits all requests that match the given pattern.
  /// 
  /// The pattern syntax and precedence rules are the same as [ServeMux]. Only
  /// requests that match the pattern directly are permitted. Those that ServeMux
  /// would redirect to a pattern (e.g. after cleaning the path or adding a
  /// trailing slash) are not.
  /// 
  /// AddInsecureBypassPattern can be called concurrently with other methods or
  /// request handling, and applies to future requests.
  fn AddInsecureBypassPattern(self: Ref<CrossOriginProtection>, pattern: string)

  /// AddTrustedOrigin allows all requests with an [Origin] header
  /// which exactly matches the given value.
  /// 
  /// Origin header values are of the form "scheme://host[:port]".
  /// 
  /// AddTrustedOrigin can be called concurrently with other methods
  /// or request handling, and applies to future requests.
  /// 
  /// [Origin]: https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Origin
  fn AddTrustedOrigin(self: Ref<CrossOriginProtection>, origin: string) -> Result<(), error>

  /// Check applies cross-origin checks to a request.
  /// It returns an error if the request should be rejected.
  fn Check(self: Ref<CrossOriginProtection>, req: Ref<Request>) -> Result<(), error>

  /// Handler returns a handler that applies cross-origin checks
  /// before invoking the handler h.
  /// 
  /// If a request fails cross-origin checks, the request is rejected
  /// with a 403 Forbidden status or handled with the handler passed
  /// to [CrossOriginProtection.SetDenyHandler].
  fn Handler(self: Ref<CrossOriginProtection>, h: Handler) -> Handler

  /// SetDenyHandler sets a handler to invoke when a request is rejected.
  /// The default error handler responds with a 403 Forbidden status.
  /// 
  /// SetDenyHandler can be called concurrently with other methods
  /// or request handling, and applies to future requests.
  /// 
  /// Check does not call the error handler.
  fn SetDenyHandler(self: Ref<CrossOriginProtection>, h: Handler)
}

impl Dir {
  /// Open implements [FileSystem] using [os.Open], opening files for reading rooted
  /// and relative to the directory d.
  fn Open(self, name: string) -> Result<File, error>
}

impl HandlerFunc {
  /// ServeHTTP calls f(w, r).
  fn ServeHTTP(self, w: ResponseWriter, r: Ref<Request>)
}

impl Header {
  /// Add adds the key, value pair to the header.
  /// It appends to any existing values associated with key.
  /// The key is case insensitive; it is canonicalized by
  /// [CanonicalHeaderKey].
  fn Add(self, key: string, value: string)

  /// Clone returns a copy of h or nil if h is nil.
  fn Clone(self) -> Header

  /// Del deletes the values associated with key.
  /// The key is case insensitive; it is canonicalized by
  /// [CanonicalHeaderKey].
  fn Del(self, key: string)

  /// Get gets the first value associated with the given key. If
  /// there are no values associated with the key, Get returns "".
  /// It is case insensitive; [textproto.CanonicalMIMEHeaderKey] is
  /// used to canonicalize the provided key. Get assumes that all
  /// keys are stored in canonical form. To use non-canonical keys,
  /// access the map directly.
  fn Get(self, key: string) -> string

  /// Set sets the header entries associated with key to the
  /// single element value. It replaces any existing values
  /// associated with key. The key is case insensitive; it is
  /// canonicalized by [textproto.CanonicalMIMEHeaderKey].
  /// To use non-canonical keys, assign to the map directly.
  fn Set(self, key: string, value: string)

  /// Values returns all values associated with the given key.
  /// It is case insensitive; [textproto.CanonicalMIMEHeaderKey] is
  /// used to canonicalize the provided key. To use non-canonical
  /// keys, access the map directly.
  /// The returned slice is not a copy.
  fn Values(self, key: string) -> Slice<string>

  /// Write writes a header in wire format.
  fn Write(self, w: io.Writer) -> Result<(), error>

  /// WriteSubset writes a header in wire format.
  /// If exclude is not nil, keys where exclude[key] == true are not written.
  /// Keys are not canonicalized before checking the exclude map.
  fn WriteSubset(self, w: io.Writer, exclude: Map<string, bool>) -> Result<(), error>
}

impl MaxBytesError {
  fn Error(self: Ref<MaxBytesError>) -> string
}

impl ProtocolError {
  fn Error(self: Ref<ProtocolError>) -> string

  /// Is lets http.ErrNotSupported match errors.ErrUnsupported.
  fn Is(self: Ref<ProtocolError>, err: error) -> bool
}

impl Protocols {
  /// HTTP1 reports whether p includes HTTP/1.
  fn HTTP1(self) -> bool

  /// HTTP2 reports whether p includes HTTP/2.
  fn HTTP2(self) -> bool

  /// SetHTTP1 adds or removes HTTP/1 from p.
  fn SetHTTP1(self: Ref<Protocols>, ok: bool)

  /// SetHTTP2 adds or removes HTTP/2 from p.
  fn SetHTTP2(self: Ref<Protocols>, ok: bool)

  /// SetUnencryptedHTTP2 adds or removes unencrypted HTTP/2 from p.
  fn SetUnencryptedHTTP2(self: Ref<Protocols>, ok: bool)

  fn String(self) -> string

  /// UnencryptedHTTP2 reports whether p includes unencrypted HTTP/2.
  fn UnencryptedHTTP2(self) -> bool
}

impl Request {
  /// AddCookie adds a cookie to the request. Per RFC 6265 section 5.4,
  /// AddCookie does not attach more than one [Cookie] header field. That
  /// means all cookies, if any, are written into the same line,
  /// separated by semicolon.
  /// AddCookie only sanitizes c's name and value, and does not sanitize
  /// a Cookie header already present in the request.
  fn AddCookie(self: Ref<Request>, c: Ref<Cookie>)

  /// BasicAuth returns the username and password provided in the request's
  /// Authorization header, if the request uses HTTP Basic Authentication.
  /// See RFC 2617, Section 2.
  fn BasicAuth(self: Ref<Request>) -> Option<(string, string)>

  /// Clone returns a deep copy of r with its context changed to ctx.
  /// The provided ctx must be non-nil.
  /// 
  /// Clone only makes a shallow copy of the Body field.
  /// 
  /// For an outgoing client request, the context controls the entire
  /// lifetime of a request and its response: obtaining a connection,
  /// sending the request, and reading the response headers and body.
  fn Clone(self: Ref<Request>, ctx: context.Context) -> Ref<Request>

  /// Context returns the request's context. To change the context, use
  /// [Request.Clone] or [Request.WithContext].
  /// 
  /// The returned context is always non-nil; it defaults to the
  /// background context.
  /// 
  /// For outgoing client requests, the context controls cancellation.
  /// 
  /// For incoming server requests, the context is canceled when the
  /// client's connection closes, the request is canceled (with HTTP/2),
  /// or when the ServeHTTP method returns.
  fn Context(self: Ref<Request>) -> context.Context

  /// Cookie returns the named cookie provided in the request or
  /// [ErrNoCookie] if not found.
  /// If multiple cookies match the given name, only one cookie will
  /// be returned.
  fn Cookie(self: Ref<Request>, name: string) -> Result<Ref<Cookie>, error>

  /// Cookies parses and returns the HTTP cookies sent with the request.
  fn Cookies(self: Ref<Request>) -> Slice<Ref<Cookie>>

  /// CookiesNamed parses and returns the named HTTP cookies sent with the request
  /// or an empty slice if none matched.
  fn CookiesNamed(self: Ref<Request>, name: string) -> Slice<Ref<Cookie>>

  /// FormFile returns the first file for the provided form key.
  /// FormFile calls [Request.ParseMultipartForm] and [Request.ParseForm] if necessary.
  fn FormFile(self: Ref<Request>, key: string) -> Result<(multipart.File, Ref<multipart.FileHeader>), error>

  /// FormValue returns the first value for the named component of the query.
  /// The precedence order:
  ///  1. application/x-www-form-urlencoded form body (POST, PUT, PATCH only)
  ///  2. query parameters (always)
  ///  3. multipart/form-data form body (always)
  /// 
  /// FormValue calls [Request.ParseMultipartForm] and [Request.ParseForm]
  /// if necessary and ignores any errors returned by these functions.
  /// If key is not present, FormValue returns the empty string.
  /// To access multiple values of the same key, call ParseForm and
  /// then inspect [Request.Form] directly.
  fn FormValue(self: Ref<Request>, key: string) -> string

  /// MultipartReader returns a MIME multipart reader if this is a
  /// multipart/form-data or a multipart/mixed POST request, else returns nil and an error.
  /// Use this function instead of [Request.ParseMultipartForm] to
  /// process the request body as a stream.
  fn MultipartReader(self: Ref<Request>) -> Result<Ref<multipart.Reader>, error>

  /// ParseForm populates r.Form and r.PostForm.
  /// 
  /// For all requests, ParseForm parses the raw query from the URL and updates
  /// r.Form.
  /// 
  /// For POST, PUT, and PATCH requests, it also reads the request body, parses it
  /// as a form and puts the results into both r.PostForm and r.Form. Request body
  /// parameters take precedence over URL query string values in r.Form.
  /// 
  /// If the request Body's size has not already been limited by [MaxBytesReader],
  /// the size is capped at 10MB.
  /// 
  /// For other HTTP methods, or when the Content-Type is not
  /// application/x-www-form-urlencoded, the request Body is not read, and
  /// r.PostForm is initialized to a non-nil, empty value.
  /// 
  /// [Request.ParseMultipartForm] calls ParseForm automatically.
  /// ParseForm is idempotent.
  fn ParseForm(self: Ref<Request>) -> Result<(), error>

  /// ParseMultipartForm parses a request body as multipart/form-data.
  /// The whole request body is parsed and up to a total of maxMemory bytes of
  /// its file parts are stored in memory, with the remainder stored on
  /// disk in temporary files.
  /// ParseMultipartForm calls [Request.ParseForm] if necessary.
  /// If ParseForm returns an error, ParseMultipartForm returns it but also
  /// continues parsing the request body.
  /// After one call to ParseMultipartForm, subsequent calls have no effect.
  fn ParseMultipartForm(self: Ref<Request>, maxMemory: int64) -> Result<(), error>

  /// PathValue returns the value for the named path wildcard in the [ServeMux] pattern
  /// that matched the request.
  /// It returns the empty string if the request was not matched against a pattern
  /// or there is no such wildcard in the pattern.
  fn PathValue(self: Ref<Request>, name: string) -> string

  /// PostFormValue returns the first value for the named component of the POST,
  /// PUT, or PATCH request body. URL query parameters are ignored.
  /// PostFormValue calls [Request.ParseMultipartForm] and [Request.ParseForm] if necessary and ignores
  /// any errors returned by these functions.
  /// If key is not present, PostFormValue returns the empty string.
  fn PostFormValue(self: Ref<Request>, key: string) -> string

  /// ProtoAtLeast reports whether the HTTP protocol used
  /// in the request is at least major.minor.
  fn ProtoAtLeast(self: Ref<Request>, major: int, minor: int) -> bool

  /// Referer returns the referring URL, if sent in the request.
  /// 
  /// Referer is misspelled as in the request itself, a mistake from the
  /// earliest days of HTTP.  This value can also be fetched from the
  /// [Header] map as Header["Referer"]; the benefit of making it available
  /// as a method is that the compiler can diagnose programs that use the
  /// alternate (correct English) spelling req.Referrer() but cannot
  /// diagnose programs that use Header["Referrer"].
  fn Referer(self: Ref<Request>) -> string

  /// SetBasicAuth sets the request's Authorization header to use HTTP
  /// Basic Authentication with the provided username and password.
  /// 
  /// With HTTP Basic Authentication the provided username and password
  /// are not encrypted. It should generally only be used in an HTTPS
  /// request.
  /// 
  /// The username may not contain a colon. Some protocols may impose
  /// additional requirements on pre-escaping the username and
  /// password. For instance, when used with OAuth2, both arguments must
  /// be URL encoded first with [url.QueryEscape].
  fn SetBasicAuth(self: Ref<Request>, username: string, password: string)

  /// SetPathValue sets name to value, so that subsequent calls to r.PathValue(name)
  /// return value.
  fn SetPathValue(self: Ref<Request>, name: string, value: string)

  /// UserAgent returns the client's User-Agent, if sent in the request.
  fn UserAgent(self: Ref<Request>) -> string

  /// WithContext returns a shallow copy of r with its context changed
  /// to ctx. The provided ctx must be non-nil.
  /// 
  /// For outgoing client request, the context controls the entire
  /// lifetime of a request and its response: obtaining a connection,
  /// sending the request, and reading the response headers and body.
  /// 
  /// To create a new request with a context, use [NewRequestWithContext].
  /// To make a deep copy of a request with a new context, use [Request.Clone].
  fn WithContext(self: Ref<Request>, ctx: context.Context) -> Ref<Request>

  /// Write writes an HTTP/1.1 request, which is the header and body, in wire format.
  /// This method consults the following fields of the request:
  /// 
  /// 	Host
  /// 	URL
  /// 	Method (defaults to "GET")
  /// 	Header
  /// 	ContentLength
  /// 	TransferEncoding
  /// 	Body
  /// 
  /// If Body is present, Content-Length is <= 0 and [Request.TransferEncoding]
  /// hasn't been set to "identity", Write adds "Transfer-Encoding:
  /// chunked" to the header. Body is closed after it is sent.
  fn Write(self: Ref<Request>, w: io.Writer) -> Result<(), error>

  /// WriteProxy is like [Request.Write] but writes the request in the form
  /// expected by an HTTP proxy. In particular, [Request.WriteProxy] writes the
  /// initial Request-URI line of the request with an absolute URI, per
  /// section 5.3 of RFC 7230, including the scheme and host.
  /// In either case, WriteProxy also writes a Host header, using
  /// either r.Host or r.URL.Host.
  fn WriteProxy(self: Ref<Request>, w: io.Writer) -> Result<(), error>
}

impl Response {
  /// Cookies parses and returns the cookies set in the Set-Cookie headers.
  fn Cookies(self: Ref<Response>) -> Slice<Ref<Cookie>>

  /// Location returns the URL of the response's "Location" header,
  /// if present. Relative redirects are resolved relative to
  /// [Response.Request]. [ErrNoLocation] is returned if no
  /// Location header is present.
  fn Location(self: Ref<Response>) -> Result<Ref<url.URL>, error>

  /// ProtoAtLeast reports whether the HTTP protocol used
  /// in the response is at least major.minor.
  fn ProtoAtLeast(self: Ref<Response>, major: int, minor: int) -> bool

  /// Write writes r to w in the HTTP/1.x server response format,
  /// including the status line, headers, body, and optional trailer.
  /// 
  /// This method consults the following fields of the response r:
  /// 
  /// 	StatusCode
  /// 	ProtoMajor
  /// 	ProtoMinor
  /// 	Request.Method
  /// 	TransferEncoding
  /// 	Trailer
  /// 	Body
  /// 	ContentLength
  /// 	Header, values for non-canonical keys will have unpredictable behavior
  /// 
  /// The Response Body is closed after it is sent.
  fn Write(self: Ref<Response>, w: io.Writer) -> Result<(), error>
}

impl ResponseController {
  /// EnableFullDuplex indicates that the request handler will interleave reads from [Request.Body]
  /// with writes to the [ResponseWriter].
  /// 
  /// For HTTP/1 requests, the Go HTTP server by default consumes any unread portion of
  /// the request body before beginning to write the response, preventing handlers from
  /// concurrently reading from the request and writing the response.
  /// Calling EnableFullDuplex disables this behavior and permits handlers to continue to read
  /// from the request while concurrently writing the response.
  /// 
  /// For HTTP/2 requests, the Go HTTP server always permits concurrent reads and responses.
  fn EnableFullDuplex(self: Ref<ResponseController>) -> Result<(), error>

  /// Flush flushes buffered data to the client.
  #[allow(unused_result)]
  fn Flush(self: Ref<ResponseController>) -> Result<(), error>

  /// Hijack lets the caller take over the connection.
  /// See the [Hijacker] interface for details.
  fn Hijack(self: Ref<ResponseController>) -> Result<(net.Conn, Ref<bufio.ReadWriter>), error>

  /// SetReadDeadline sets the deadline for reading the entire request, including the body.
  /// Reads from the request body after the deadline has been exceeded will return an error.
  /// A zero value means no deadline.
  /// 
  /// Setting the read deadline after it has been exceeded will not extend it.
  fn SetReadDeadline(self: Ref<ResponseController>, deadline: time.Time) -> Result<(), error>

  /// SetWriteDeadline sets the deadline for writing the response.
  /// Writes to the response body after the deadline has been exceeded will not block,
  /// but may succeed if the data has been buffered.
  /// A zero value means no deadline.
  /// 
  /// Setting the write deadline after it has been exceeded will not extend it.
  fn SetWriteDeadline(self: Ref<ResponseController>, deadline: time.Time) -> Result<(), error>
}

impl ServeMux {
  /// Handle registers the handler for the given pattern.
  /// If the given pattern conflicts with one that is already registered, Handle
  /// panics.
  fn Handle(self: Ref<ServeMux>, pattern: string, handler: Handler)

  /// HandleFunc registers the handler function for the given pattern.
  /// If the given pattern conflicts with one that is already registered, HandleFunc
  /// panics.
  fn HandleFunc(
    self: Ref<ServeMux>,
    pattern: string,
    handler: fn(ResponseWriter, Ref<Request>) -> (),
  )

  /// Handler returns the handler to use for the given request,
  /// consulting r.Method, r.Host, and r.URL.Path. It always returns
  /// a non-nil handler. If the path is not in its canonical form, the
  /// handler will be an internally-generated handler that redirects
  /// to the canonical path. If the host contains a port, it is ignored
  /// when matching handlers.
  /// 
  /// The path and host are used unchanged for CONNECT requests.
  /// 
  /// Handler also returns the registered pattern that matches the
  /// request or, in the case of internally-generated redirects,
  /// the path that will match after following the redirect.
  /// 
  /// If there is no registered handler that applies to the request,
  /// Handler returns a “page not found” or “method not supported”
  /// handler and an empty pattern.
  /// 
  /// Handler does not modify its argument. In particular, it does not
  /// populate named path wildcards, so r.PathValue will always return
  /// the empty string.
  fn Handler(self: Ref<ServeMux>, r: Ref<Request>) -> (Handler, string)

  /// ServeHTTP dispatches the request to the handler whose
  /// pattern most closely matches the request URL.
  fn ServeHTTP(self: Ref<ServeMux>, w: ResponseWriter, r: Ref<Request>)
}

impl Server {
  /// Close immediately closes all active net.Listeners and any
  /// connections in state [StateNew], [StateActive], or [StateIdle]. For a
  /// graceful shutdown, use [Server.Shutdown].
  /// 
  /// Close does not attempt to close (and does not even know about)
  /// any hijacked connections, such as WebSockets.
  /// 
  /// Close returns any error returned from closing the [Server]'s
  /// underlying Listener(s).
  #[allow(unused_result)]
  fn Close(self: Ref<Server>) -> Result<(), error>

  /// ListenAndServe listens on the TCP network address s.Addr and then
  /// calls [Serve] to handle requests on incoming connections.
  /// Accepted connections are configured to enable TCP keep-alives.
  /// 
  /// If s.Addr is blank, ":http" is used.
  /// 
  /// ListenAndServe always returns a non-nil error. After [Server.Shutdown] or [Server.Close],
  /// the returned error is [ErrServerClosed].
  fn ListenAndServe(self: Ref<Server>) -> Result<(), error>

  /// ListenAndServeTLS listens on the TCP network address s.Addr and
  /// then calls [ServeTLS] to handle requests on incoming TLS connections.
  /// Accepted connections are configured to enable TCP keep-alives.
  /// 
  /// Filenames containing a certificate and matching private key for the
  /// server must be provided if neither the [Server]'s TLSConfig.Certificates
  /// nor TLSConfig.GetCertificate are populated. If the certificate is
  /// signed by a certificate authority, the certFile should be the
  /// concatenation of the server's certificate, any intermediates, and
  /// the CA's certificate.
  /// 
  /// If s.Addr is blank, ":https" is used.
  /// 
  /// ListenAndServeTLS always returns a non-nil error. After [Server.Shutdown] or
  /// [Server.Close], the returned error is [ErrServerClosed].
  fn ListenAndServeTLS(self: Ref<Server>, certFile: string, keyFile: string) -> Result<(), error>

  /// RegisterOnShutdown registers a function to call on [Server.Shutdown].
  /// This can be used to gracefully shutdown connections that have
  /// undergone ALPN protocol upgrade or that have been hijacked.
  /// This function should start protocol-specific graceful shutdown,
  /// but should not wait for shutdown to complete.
  fn RegisterOnShutdown(self: Ref<Server>, f: fn() -> ())

  /// Serve accepts incoming connections on the Listener l, creating a
  /// new service goroutine for each. The service goroutines read requests and
  /// then call s.Handler to reply to them.
  /// 
  /// HTTP/2 support is only enabled if the Listener returns [*tls.Conn]
  /// connections and they were configured with "h2" in the TLS
  /// Config.NextProtos.
  /// 
  /// Serve always returns a non-nil error and closes l.
  /// After [Server.Shutdown] or [Server.Close], the returned error is [ErrServerClosed].
  fn Serve(self: Ref<Server>, l: net.Listener) -> Result<(), error>

  /// ServeTLS accepts incoming connections on the Listener l, creating a
  /// new service goroutine for each. The service goroutines perform TLS
  /// setup and then read requests, calling s.Handler to reply to them.
  /// 
  /// Files containing a certificate and matching private key for the
  /// server must be provided if neither the [Server]'s
  /// TLSConfig.Certificates, TLSConfig.GetCertificate nor
  /// config.GetConfigForClient are populated.
  /// If the certificate is signed by a certificate authority, the
  /// certFile should be the concatenation of the server's certificate,
  /// any intermediates, and the CA's certificate.
  /// 
  /// ServeTLS always returns a non-nil error. After [Server.Shutdown] or [Server.Close], the
  /// returned error is [ErrServerClosed].
  fn ServeTLS(
    self: Ref<Server>,
    l: net.Listener,
    certFile: string,
    keyFile: string,
  ) -> Result<(), error>

  /// SetKeepAlivesEnabled controls whether HTTP keep-alives are enabled.
  /// By default, keep-alives are always enabled. Only very
  /// resource-constrained environments or servers in the process of
  /// shutting down should disable them.
  fn SetKeepAlivesEnabled(self: Ref<Server>, v: bool)

  /// Shutdown gracefully shuts down the server without interrupting any
  /// active connections. Shutdown works by first closing all open
  /// listeners, then closing all idle connections, and then waiting
  /// indefinitely for connections to return to idle and then shut down.
  /// If the provided context expires before the shutdown is complete,
  /// Shutdown returns the context's error, otherwise it returns any
  /// error returned from closing the [Server]'s underlying Listener(s).
  /// 
  /// When Shutdown is called, [Serve], [ServeTLS], [ListenAndServe], and
  /// [ListenAndServeTLS] immediately return [ErrServerClosed]. Make sure the
  /// program doesn't exit and waits instead for Shutdown to return.
  /// 
  /// Shutdown does not attempt to close nor wait for hijacked
  /// connections such as WebSockets. The caller of Shutdown should
  /// separately notify such long-lived connections of shutdown and wait
  /// for them to close, if desired. See [Server.RegisterOnShutdown] for a way to
  /// register shutdown notification functions.
  /// 
  /// Once Shutdown has been called on a server, it may not be reused;
  /// future calls to methods such as Serve will return ErrServerClosed.
  fn Shutdown(self: Ref<Server>, ctx: context.Context) -> Result<(), error>
}

impl Transport {
  /// CancelRequest cancels an in-flight request by closing its connection.
  /// CancelRequest should only be called after [Transport.RoundTrip] has returned.
  /// 
  /// Deprecated: Use [Request.WithContext] to create a request with a
  /// cancelable context instead. CancelRequest cannot cancel HTTP/2
  /// requests. This may become a no-op in a future release of Go.
  fn CancelRequest(self: Ref<Transport>, req: Ref<Request>)

  /// Clone returns a deep copy of t's exported fields.
  fn Clone(self: Ref<Transport>) -> Ref<Transport>

  /// CloseIdleConnections closes any connections which were previously
  /// connected from previous requests but are now sitting idle in
  /// a "keep-alive" state. It does not interrupt any connections currently
  /// in use.
  fn CloseIdleConnections(self: Ref<Transport>)

  /// RegisterProtocol registers a new protocol with scheme.
  /// The [Transport] will pass requests using the given scheme to rt.
  /// It is rt's responsibility to simulate HTTP request semantics.
  /// 
  /// RegisterProtocol can be used by other packages to provide
  /// implementations of protocol schemes like "ftp" or "file".
  /// 
  /// If rt.RoundTrip returns [ErrSkipAltProtocol], the Transport will
  /// handle the [Transport.RoundTrip] itself for that one request, as if the
  /// protocol were not registered.
  fn RegisterProtocol(self: Ref<Transport>, scheme: string, rt: RoundTripper)

  /// RoundTrip implements the [RoundTripper] interface.
  /// 
  /// For higher-level HTTP client support (such as handling of cookies
  /// and redirects), see [Get], [Post], and the [Client] type.
  /// 
  /// Like the RoundTripper interface, the error types returned
  /// by RoundTrip are unspecified.
  fn RoundTrip(self: Ref<Transport>, req: Ref<Request>) -> Result<Ref<Response>, error>
}
