ContentEncodingFlags {.pure.} = enum
  Identity, Br, Compress, Deflate, Gzip

HttpAddressError = object of HttpTransportError

HttpAddressErrorType {.pure.} = enum
  InvalidUrlScheme = "Unsupported URL scheme",
  InvalidPortNumber = "Invalid port number",
  MissingHostname = "Hostname missing from URL",
  InvalidIpHostname = "Invalid IP", NameLookupFailed = "DNS lookup failed",
  NoAddressResolved = "Hostname has no addresses"

HttpConnectionError = object of HttpTransportError

HttpCriticalError {....deprecated.} = object of HttpProtocolError

HttpDisconnectError = object of HttpReadError

HttpError = object of AsyncError

HttpInterruptError = object of HttpError

HttpInvalidUsageError = object of HttpError

HttpMessage = object
  code*: HttpCode
  contentType*: MediaType
  message*: string

HttpProtocolError = object of HttpError
  code*: HttpCode

HttpReadError = object of HttpTransportError

HttpReadLimitError = object of HttpReadError

HttpRecoverableError {....deprecated.} = object of HttpProtocolError

HttpRedirectError = object of HttpTransportError

HttpRequestBodyError = object of HttpRequestError

HttpRequestBodyTooLargeError = object of HttpRequestBodyError

HttpRequestError = object of HttpProtocolError

HttpRequestHeadersError = object of HttpRequestError

HttpRequestHeadersTooLargeError = object of HttpRequestHeadersError

HttpResponseError = object of HttpProtocolError

HttpResult[T] = Result[T, string]

HttpResultCode[T] = Result[T, HttpCode]

HttpResultMessage[T] = Result[T, HttpMessage]

HttpState {.pure.} = enum
  Alive, Closing, Closed

HttpTransportError = object of HttpError

HttpUseClosedError = object of HttpInvalidUsageError

HttpWriteError = object of HttpTransportError

KeyValueTuple = tuple[key: string, value: string]

QueryParamsFlag {.pure.} = enum
  CommaSeparatedArray        ## Enable usage of comma symbol as separator of array
                             ## items

TransferEncodingFlags {.pure.} = enum
  Identity, Chunked, Compress, Deflate, Gzip

AcceptHeaderName = "accept"

AuthorizationHeader = "authorization"

ConnectionHeader = "connection"

ContentDispositionHeader = "content-disposition"

ContentEncodingHeader = "content-encoding"

ContentLengthHeader = "content-length"

ContentTypeHeader = "content-type"

CriticalHttpAddressError = {HttpAddressErrorType.InvalidUrlScheme,
                            HttpAddressErrorType.InvalidPortNumber,
                            HttpAddressErrorType.MissingHostname,
                            HttpAddressErrorType.InvalidIpHostname}

DateHeader = "date"

ExpectHeader = "expect"

HeadersMark = [0x0D'u8, 0x0A'u8, 0x0D'u8, 0x0A'u8]

HostHeader = "host"

HttpServerRequestTrackerName = "httpserver.request"

HttpServerResponseTrackerName = "httpserver.response"

HttpServerSecureConnectionTrackerName = "httpserver.secure.connection"

HttpServerUnsecureConnectionTrackerName = "httpserver.unsecure.connection"

LocationHeader = "location"

MaximumBodySizeError = "Maximum size of request\'s body reached"

MultipartContentType = (media: "multipart", subtype: "form-data")

PostMethods = {MethodPost, MethodPatch, MethodPut, MethodDelete}

ProxyAuthorizationHeader = "proxy-authorization"

RecoverableHttpAddressError = {HttpAddressErrorType.NameLookupFailed,
                               HttpAddressErrorType.NoAddressResolved}

ServerHeader = "server"

TransferEncodingHeader = "transfer-encoding"

UrlEncodedContentType = (media: "application", subtype: "x-www-form-urlencoded")

UserAgentHeader = "user-agent"

func bytesToString(src: openArray[byte]): string {....raises: [], tags: [].}

proc bytesToString(src: openArray[byte]; dst: var openArray[char]) {....raises: [],
    tags: [].}

func encodeBasicAuth(username, password: string): string {....raises: [], tags: [].}

func getContentEncoding(ch: openArray[string]): HttpResult[
    set[ContentEncodingFlags]] {....raises: [], tags: [].}

func getContentType(ch: openArray[string]): HttpResult[ContentTypeData] {.
    ...raises: [], tags: [].}

func getTransferEncoding(ch: openArray[string]): HttpResult[
    set[TransferEncodingFlags]] {....raises: [], tags: [].}

func init(t: typedesc[HttpMessage]; code: HttpCode): HttpMessage {....raises: [].}

func init(t: typedesc[HttpMessage]; code: HttpCode; message: string): HttpMessage {.
    ...raises: [].}

func init(t: typedesc[HttpMessage]; code: HttpCode; message: string;
          contentType: MediaType): HttpMessage {....raises: [].}

func init(t: typedesc[HttpMessage]; code: HttpCode; message: string;
          contentType: string): HttpMessage {....raises: [].}

func isCriticalError(error: HttpAddressErrorType): bool {....raises: [], tags: [].}

func isPersistent(version: HttpVersion; headers: HttpTable): bool {....raises: [],
    tags: [].}

func isRecoverableError(error: HttpAddressErrorType): bool {....raises: [],
    tags: [].}

proc newHttpInterruptError(): ref HttpInterruptError {.noinline, ...raises: [],
    tags: [].}

proc newHttpReadError(message: string): ref HttpReadError {.noinline,
    ...raises: [], tags: [].}

proc newHttpUseClosedError(): ref HttpUseClosedError {.noinline, ...raises: [],
    tags: [].}

proc newHttpWriteError(message: string): ref HttpWriteError {.noinline,
    ...raises: [], tags: [].}

proc raiseHttpAddressError(msg: string) {.noinline, noreturn,
    ...raises: [HttpAddressError], raises: [], tags: [].}

proc raiseHttpConnectionError(msg: string) {.noinline, noreturn,
    ...raises: [HttpConnectionError], raises: [], tags: [].}

proc raiseHttpCriticalError(msg: string; code = Http400) {.noinline, noreturn,
    ...raises: [HttpCriticalError], deprecated, raises: [], tags: [].}

proc raiseHttpDisconnectError() {.noinline, noreturn,
                                  ...raises: [HttpDisconnectError], raises: [],
                                  tags: [].}

proc raiseHttpInterruptError() {.noinline, noreturn,
                                 ...raises: [HttpInterruptError], raises: [],
                                 tags: [].}

proc raiseHttpProtocolError(code: HttpCode; msg: string) {.noinline, noreturn,
    ...raises: [HttpProtocolError], raises: [], tags: [].}

proc raiseHttpProtocolError(msg: HttpMessage) {.noinline, noreturn,
    ...raises: [HttpProtocolError], raises: [], tags: [].}

proc raiseHttpProtocolError(msg: string) {.noinline, noreturn,
    ...raises: [HttpProtocolError], raises: [], tags: [].}

proc raiseHttpReadError(msg: string) {.noinline, noreturn,
                                       ...raises: [HttpReadError], raises: [],
                                       tags: [].}

proc raiseHttpRedirectError(msg: string) {.noinline, noreturn,
    ...raises: [HttpRedirectError], raises: [], tags: [].}

proc raiseHttpRequestBodyTooLargeError() {.noinline, noreturn,
    ...raises: [HttpRequestBodyTooLargeError], raises: [], tags: [].}

proc raiseHttpWriteError(msg: string) {.noinline, noreturn,
                                        ...raises: [HttpWriteError], raises: [],
                                        tags: [].}

func stringToBytes(src: openArray[char]): seq[byte] {....raises: [], tags: [].}

proc stringToBytes(src: openArray[char]; dst: var openArray[byte]) {....raises: [],
    tags: [].}

func toString(error: HttpAddressErrorType): string {....raises: [], tags: [].}

iterator queryParams(query: string; flags: set[QueryParamsFlag] = {}): KeyValueTuple {.
    ...raises: [], tags: [].}