fn pub inline static accept -> Header {
  Header.Standard(ACCEPT)
}

fn pub inline static accept_charset -> Header {
  Header.Standard(ACCEPT_CHARSET)
}

fn pub inline static accept_encoding -> Header {
  Header.Standard(ACCEPT_ENCODING)
}

fn pub inline static accept_language -> Header {
  Header.Standard(ACCEPT_LANGUAGE)
}

fn pub inline static accept_ranges -> Header {
  Header.Standard(ACCEPT_RANGES)
}

fn pub inline static access_control_allow_credentials -> Header {
  Header.Standard(ACCESS_CONTROL_ALLOW_CREDENTIALS)
}

fn pub inline static access_control_allow_headers -> Header {
  Header.Standard(ACCESS_CONTROL_ALLOW_HEADERS)
}

fn pub inline static access_control_allow_methods -> Header {
  Header.Standard(ACCESS_CONTROL_ALLOW_METHODS)
}

fn pub inline static access_control_allow_origin -> Header {
  Header.Standard(ACCESS_CONTROL_ALLOW_ORIGIN)
}

fn pub inline static access_control_max_age -> Header {
  Header.Standard(ACCESS_CONTROL_MAX_AGE)
}

fn pub inline static access_control_method -> Header {
  Header.Standard(ACCESS_CONTROL_METHOD)
}

fn pub inline static access_control_request_headers -> Header {
  Header.Standard(ACCESS_CONTROL_REQUEST_HEADERS)
}

fn pub inline static access_control_request_method -> Header {
  Header.Standard(ACCESS_CONTROL_REQUEST_METHOD)
}

fn pub inline static access_control_request_methods -> Header {
  Header.Standard(ACCESS_CONTROL_REQUEST_METHODS)
}

fn pub inline static age -> Header {
  Header.Standard(AGE)
}

fn pub inline static allow -> Header {
  Header.Standard(ALLOW)
}

fn pub inline static alt_svc -> Header {
  Header.Standard(ALT_SVC)
}

fn pub inline static authorization -> Header {
  Header.Standard(AUTHORIZATION)
}

fn pub inline static cache_control -> Header {
  Header.Standard(CACHE_CONTROL)
}

fn pub inline static connection -> Header {
  Header.Standard(CONNECTION)
}

fn pub inline static content_disposition -> Header {
  Header.Standard(CONTENT_DISPOSITION)
}

fn pub inline static content_encoding -> Header {
  Header.Standard(CONTENT_ENCODING)
}

fn pub inline static content_language -> Header {
  Header.Standard(CONTENT_LANGUAGE)
}

fn pub inline static content_length -> Header {
  Header.Standard(CONTENT_LENGTH)
}

fn pub inline static content_location -> Header {
  Header.Standard(CONTENT_LOCATION)
}

fn pub inline static content_range -> Header {
  Header.Standard(CONTENT_RANGE)
}

fn pub inline static content_type -> Header {
  Header.Standard(CONTENT_TYPE)
}

fn pub inline static cookie -> Header {
  Header.Standard(COOKIE)
}

fn pub inline static date -> Header {
  Header.Standard(DATE)
}

fn pub inline static etag -> Header {
  Header.Standard(ETAG)
}

fn pub inline static expect -> Header {
  Header.Standard(EXPECT)
}

fn pub inline static expires -> Header {
  Header.Standard(EXPIRES)
}

fn pub inline static from -> Header {
  Header.Standard(FROM)
}

fn pub inline static host -> Header {
  Header.Standard(HOST)
}

fn pub inline static if_match -> Header {
  Header.Standard(IF_MATCH)
}

fn pub inline static if_modified_since -> Header {
  Header.Standard(IF_MODIFIED_SINCE)
}

fn pub inline static if_none_match -> Header {
  Header.Standard(IF_NONE_MATCH)
}

fn pub inline static if_range -> Header {
  Header.Standard(IF_RANGE)
}

fn pub inline static if_unmodified_since -> Header {
  Header.Standard(IF_UNMODIFIED_SINCE)
}

fn pub inline static keep_alive -> Header {
  Header.Standard(KEEP_ALIVE)
}

fn pub inline static last_modified -> Header {
  Header.Standard(LAST_MODIFIED)
}

fn pub inline static link -> Header {
  Header.Standard(LINK)
}

fn pub inline static location -> Header {
  Header.Standard(LOCATION)
}

fn pub inline static max_forwards -> Header {
  Header.Standard(MAX_FORWARDS)
}

fn pub static new[B: Bytes + ToString](input: ref B) -> Header {
  match header.index_of(input) {
    case -1 -> Header.Other(input.to_string)
    case n -> Header.Standard(n)
  }
}

fn pub inline static origin -> Header {
  Header.Standard(ORIGIN)
}

fn pub inline static pragma -> Header {
  Header.Standard(PRAGMA)
}

fn pub inline static proxy_authenticate -> Header {
  Header.Standard(PROXY_AUTHENTICATE)
}

fn pub inline static proxy_authorization -> Header {
  Header.Standard(PROXY_AUTHORIZATION)
}

fn pub inline static proxy_connection -> Header {
  Header.Standard(PROXY_CONNECTION)
}

fn pub inline static range -> Header {
  Header.Standard(RANGE)
}

fn pub inline static referer -> Header {
  Header.Standard(REFERER)
}

fn pub inline static retry_after -> Header {
  Header.Standard(RETRY_AFTER)
}

fn pub inline static sec_fetch_dest -> Header {
  Header.Standard(SEC_FETCH_DEST)
}

fn pub inline static sec_fetch_mode -> Header {
  Header.Standard(SEC_FETCH_MODE)
}

fn pub inline static sec_fetch_site -> Header {
  Header.Standard(SEC_FETCH_SITE)
}

fn pub inline static sec_fetch_user -> Header {
  Header.Standard(SEC_FETCH_USER)
}

fn pub inline static sec_websocket_accept -> Header {
  Header.Standard(SEC_WEBSOCKET_ACCEPT)
}

fn pub inline static sec_websocket_extensions -> Header {
  Header.Standard(SEC_WEBSOCKET_EXTENSIONS)
}

fn pub inline static sec_websocket_key -> Header {
  Header.Standard(SEC_WEBSOCKET_KEY)
}

fn pub inline static sec_websocket_protocol -> Header {
  Header.Standard(SEC_WEBSOCKET_PROTOCOL)
}

fn pub inline static sec_websocket_version -> Header {
  Header.Standard(SEC_WEBSOCKET_VERSION)
}

fn pub inline static server -> Header {
  Header.Standard(SERVER)
}

fn pub inline static set_cookie -> Header {
  Header.Standard(SET_COOKIE)
}

fn pub inline static strict_transport_security -> Header {
  Header.Standard(STRICT_TRANSPORT_SECURITY)
}

fn pub inline static trailer -> Header {
  Header.Standard(TRAILER)
}

fn pub inline static transfer_encoding -> Header {
  Header.Standard(TRANSFER_ENCODING)
}

fn pub inline static upgrade -> Header {
  Header.Standard(UPGRADE)
}

fn pub inline static upgrade_insecure_requests -> Header {
  Header.Standard(UPGRADE_INSECURE_REQUESTS)
}

fn pub inline static user_agent -> Header {
  Header.Standard(USER_AGENT)
}

fn pub inline static vary -> Header {
  Header.Standard(VARY)
}

fn pub inline static via -> Header {
  Header.Standard(VIA)
}

fn pub inline static www_authenticate -> Header {
  Header.Standard(WWW_AUTHENTICATE)
}

fn pub !=(other: ref Self) -> Bool {
  !(self == other)
}

fn pub ==(other: ref Header) -> Bool {
  match (self, other) {
    case (Standard(a), Standard(b)) -> a == b
    case (Other(a), Other(b)) -> a == b
    case _ -> false
  }
}

fn pub clone -> Self {
  match self {
    case Standard(v) -> Header.Standard(v)
    case Other(v) -> Header.Other(v)
  }
}

fn pub fmt(formatter: mut Formatter) {
  formatter.write(to_string)
}

fn pub hash[H: mut + Hasher](hasher: mut H) {
  match self {
    case Standard(v) -> v.hash(hasher)
    case Other(v) -> v.hash(hasher)
  }
}

fn pub to_string -> String {
  match self {
    case Standard(v) -> header.name(v)
    case Other(v) -> v
  }
}