@cto.af/http-headers/lib/index.d.ts

Parse HTTP headers from RFC 9110 (and a bunch of others) using the full ABNF.

export interface Header<Name extends string> {
  kind: Name; // Lowercase
  value: string;
  name?: string; // Original, if parsed as a full header
}

export interface UnknownHeader {
  kind: string; // Lowercase
  value: string;
  name: string; // Original, if parsed as a full header
  unknown: true;
}

export interface Parameters {
  [name: string]: string;
}
export interface MediaRange {
  type: string;
  subtype: string;
  parameters: Parameters;
  weight: number;
}
export interface Accept extends Header<'accept'> {
  ranges: MediaRange[];
}

export interface Accept_CH extends Header<'accept-ch'> {
  hints: string[];
}

export interface Charset {
  charset: string;
  weight: number;
}
export interface Accept_Charset extends Header<'accept-charset'> {
  charsets: Charset[];
}

export interface Encoding {
  coding: string;
  weight: number;
}
export interface Accept_Encoding extends Header<'accept-encoding'> {
  encodings: Encoding[];
}

export interface Language {
  range: string[];
  weight: number;
}
export interface Accept_Language extends Header<'accept-language'> {
  languages: Language[];
}

export interface Accept_Ranges extends Header<'accept-ranges'> {
  ranges: string[];
}

export interface Access_Control_Allow_Credentials extends Header<'access-control-allow-credentials'> {
  allow: boolean;
}
export interface Access_Control_Allow_Headers extends Header<'access-control-allow-headers'> {
  fields: string[];
}
export interface Access_Control_Allow_Methods extends Header<'access-control-allow-methods'> {
  methods: string[];
}
export interface Access_Control_Allow_Origin extends Header<'access-control_allow-origin'> {
  origin: string;
}
export interface Access_Control_Expose_Headers extends Header<'access-control-expose-headers'> {
  fields: string[];
}
export interface Access_Control_Max_Age extends Header<'access-control-max-age'> {
  age: number;
}
export interface Access_Control_Request_Headers extends Header<'access-control-request-headers'> {
  fields: string[];
}
export interface Access_Control_Request_Method extends Header<'access-control-request-method'> {
  method: string;
}

export interface Age extends Header<'age'> {
  secs: number;
}

export interface Allow extends Header<'allow'> {
  methods: string[];
}

export interface ALPN extends Header<'alpn'> {
  protocols: string[];
}

export interface Service {
  protocol: string;
  authority: string;
  parameters: Parameters;
}
export interface Alt_Svc extends Header<'alt-svc'> {
  services?: Service[];
  clear?: true;
}

export interface AuthParam {
  name: string;
  value: string;
}
export interface Authentication_Info extends Header<'authentication-info'> {
  params: AuthParam[];
}

export interface Authorization extends Header<'authorization'> {
  scheme: string;
  params?: AuthParam[];
  token68?: string;
}

export type CacheDirective = [
  name: string,
  value: string | string[] | number | null,
];
export interface Cache_Control extends Header<'cache-control'> {
  controls: CacheDirective[];
}

export interface Connection extends Header<'connection'> {
  opts: string[];
}

export interface LanguageTag {
  language: string | null;
  script: string | null;
  region: string | null;
  variant: string[];
  extension: string[];
  privateuse: string | null;
}
export interface Content_Language extends Header<'content-language'> {
  tags: LanguageTag[];
}

export interface Content_Length extends Header<'content-length'> {
  length: number;
}

export interface Content_Location extends Header<'content-location'> {
  uri: string;
  absolute: boolean;
}

export interface Content_Range extends Header<'content-range'> {
  units: string;
  complete: number; // NaN if unknown
  first?: number;
  last?: number;
  unsatisfied?: boolean; // True if no first/last
}

export interface CSPValue {
  kind: 'scheme' | 'keyword' | 'nonce' | 'hash' | 'host' | 'token' | 'unknown';
  value: string;
}
export interface CSPDirective {
  name: string;
  values: CSPValue[];
  unknown?: true;
}
export interface Content_Security_Policy extends Header<'content-security-policy'> {
  directives: CSPDirective[];
}

export interface Content_Security_Policy_Report_Only extends Header<'content-security-policy-report-only'> {
  directives: CSPDirective[];
}

export interface Content_Type extends Header<'content-type'> {
  type: string;
  subtype: string;
  parameters: Parameters;
}

export interface CoopPolicyItem {
  item: string;
  params?: {
    [name: string]: string;
  };
}
export interface Cross_Origin_Embedder_Policy extends Header<'cross-origin-embedder-policy'> {
  policy: CoopPolicyItem;
}
export interface Cross_Origin_Embedder_Policy_Report_Only extends Header<'cross-origin-embedder-policy-report-only'> {
  policy: CoopPolicyItem;
}
export interface Cross_Origin_Opener_Policy extends Header<'cross-origin-opener-policy'> {
  policy: CoopPolicyItem;
}
export interface Cross_Origin_Opener_Policy_Report_Only extends Header<'cross-origin-opener-policy-report-only'> {
  policy: CoopPolicyItem;
}

export interface Cross_Origin_Resource_Policy extends Header<'cross-origin-resource-policy'> {
  policy: string;
}

export interface Date extends Header<'date'> {
  date: Date;
}

export interface ETag extends Header<'etag'> {
  etag: string;
}

export interface Expectation {
  token: string; // Mostly 100-continue
  value?: string; // Not used yet to my knowledge
  parameters?: Parameters; // Not used yet to my knowledge
}
export interface Expect extends Header<'expect'> {
  expectations: Expectation[];
}

export interface Expires extends Header<'expires'> {
  date: Date;
}

export interface From extends Header<'from'> {
  address: string;
}

export interface Host extends Header<'host'> {
  host: string;
  port: number | null;
}

export interface If_Match extends Header<'if-match'> {
  etags: string[];
}

export interface If_Modified_Since extends Header<'if-modified-since'> {
  date: Date;
}

export interface If_None_Match extends Header<'if-none-match'> {
  etags: string[];
}

export interface If_Range extends Header<'if-range'> {
  etag?: string;
  date?: Date;
}

export interface If_Unmodified_Since extends Header<'if-unmodified-since'> {
  date: Date;
}

export interface Last_Modified extends Header<'last-modified'> {
  date: Date;
}

export interface LinkValue {
  uri: URL;
  params: {
    [name: string]: string;
  };
}
export interface Link extends Header<'link'> {
  links: LinkValue[];
}

export interface Location extends Header<'location'> {
  uri: string;
}

export interface Max_Forwards extends Header<'max-forwards'> {
  max: number;
}

export interface NEL extends Header<'nel'> {
  json: unknown[];
}

export interface PermissionsPolicyItem {
  item?: string;
  params?: {
    [name: string]: string;
  };
}
export interface PermissionsPolicyItems {
  items: PermissionsPolicyItem[];
  params?: {
    [name: string]: string;
  };
}
export interface Permissions_Policy extends Header<'permissions-policy'> {
  directives: [name: string, items: PermissionsPolicyItems][];
}

export interface Challenge {
  scheme: string;
  params?: AuthParam[];
  token68?: string;
}
export interface Proxy_Authenticate extends Header<'proxy-authenticate'> {
  challenges: Challenge[];
}

export interface Proxy_Authentication_Info extends Header<'proxy-authentication-info'> {
  params: AuthParam[];
}

export interface Proxy_Authorization extends Header<'proxy-authorization'> {
  scheme: string;
  params?: AuthParam[];
  token68?: string;
}

export interface RangeSpec {
  first?: number | null;
  last?: number | null;
  other?: string;
}

export interface Range extends Header<'range'> {
  units: string;
  ranges: RangeSpec[];
}

export interface Referer extends Header<'referer'> {
  uri: string;
  absolute: boolean;
}

export interface Referrer_Policy extends Header<'referer-policy'> {
  tokens: string[];
}

export interface Reporting_Endpoints extends Header<'reporting-endpoints'> {
  endpoints: [name: string, uri: string][];
}

export interface Retry_After extends Header<'retry-after'> {
  date?: Date;
  seconds?: number;
}

export interface Product {
  product: string;
  version: string;
}
export interface Comment {
  comment: string;
}
export interface Server extends Header<'server'> {
  products: (Product | Comment)[];
}

export interface TimingMetric {
  metric: string;
  params: {
    [name: string]: string;
  };
}
export interface Server_Timing extends Header<'server-timing'> {
  metrics: TimingMetric[];
}

export type CookieAttribute = [
  name: string,
  value: string | number | Date | null,
];
export interface Set_Cookie extends Header<'set-cookie'> {
  cookieName: string;
  cookieValue: string;
  attributes: CookieAttribute[];
}

export type STSDirective = [
  name: string,
  value: string | number | null,
];
export interface Strict_Transport_Security extends Header<'strict-transport-security'> {
  directives: STSDirective[];
}

export interface TransferEncoding {
  encoding: string;
  parameters: Parameters;
  weight: number;
}
export interface TE extends Header<'te'> {
  trailers: boolean;
  codings: TransferEncoding[];
}

export interface Trailer extends Header<'trailer'> {
  fields: string[];
}

export interface Protocol {
  name: string;
  version: string | null;
}
export interface Upgrade extends Header<'upgrade'> {
  protocols: Protocol[];
}

export interface User_Agent extends Header<'user-agent'> {
  products: (Product | Comment)[];
}

export interface Vary extends Header<'vary'> {
  fields: string[];
}

export interface Path {
  protocol: string | null;
  version: string;
  name: string;
  port: number | null;
}
export interface Via extends Header<'via'> {
  path: Path[];
}

export interface WWW_Authenticate extends Header<'www-authenticate'> {
  challenges: Challenge[];
}

export type AnyHeader
  = Accept
  | Accept_CH
  | Accept_Charset
  | Accept_Encoding
  | Accept_Language
  | Accept_Ranges
  | Access_Control_Allow_Credentials
  | Access_Control_Allow_Headers
  | Access_Control_Allow_Methods
  | Access_Control_Allow_Origin
  | Access_Control_Expose_Headers
  | Access_Control_Max_Age
  | Access_Control_Request_Headers
  | Access_Control_Request_Method
  | Age
  | Allow
  | ALPN
  | Alt_Svc
  | Authentication_Info
  | Authorization
  | Cache_Control
  | Connection
  | Content_Encoding
  | Content_Language
  | Content_Length
  | Content_Location
  | Content_Range
  | Content_Security_Policy
  | Content_Security_Policy_Report_Only
  | Content_Type
  | Cross_Origin_Embedder_Policy
  | Cross_Origin_Embedder_Policy_Report_Only
  | Cross_Origin_Opener_Policy
  | Cross_Origin_Opener_Policy_Report_Only
  | Cross_Origin_Resource_Policy
  | Date
  | ETag
  | Expect
  | Expires
  | From
  | Host
  | If_Match
  | If_Modified_Since
  | If_None_Match
  | If_Range
  | If_Unmodified_Since
  | Last_Modified
  | Link
  | Location
  | Max_Forwards
  | NEL
  | Permissions_Policy
  | Proxy_Authenticate
  | Proxy_Authentication_Info
  | Proxy_Authorization
  | Range
  | Referer
  | Referrer_Policy
  | Reporting_Endpoints
  | Retry_After
  | Server
  | Server_Timing
  | Set_Cookie
  | Strict_Transport_Security
  | TE
  | Trailer
  | Upgrade
  | User_Agent
  | Vary
  | Via
  | WWW_Authenticate
  | UnknownHeader;

export type Headers = AnyHeader[];
/** Provides information pointing to a location within a source. */
export interface Location {
  /** Line in the parsed source (1-based). */
  readonly line: number;
  /** Column in the parsed source (1-based). */
  readonly column: number;
  /** Offset in the parsed source (0-based). */
  readonly offset: number;
}

/**
 * Anything that can successfully be converted to a string with `String()`
 * so that it can be used in error messages.
 *
 * The GrammarLocation class in Peggy is a good example.
 */
export interface GrammarSourceObject {
  readonly toString: () => string;

  /**
   * If specified, allows the grammar source to be embedded in a larger file
   * at some offset.
   */
  readonly offset?: undefined | ((loc: Location) => Location);
}

/**
 * Most often, you just use a string with the file name.
 */
export type GrammarSource = string | GrammarSourceObject;

/** The `start` and `end` position's of an object within the source. */
export interface LocationRange {
  /**
   * A string or object that was supplied to the `parse()` call as the
   * `grammarSource` option.
   */
  readonly source: GrammarSource;
  /** Position at the beginning of the expression. */
  readonly start: Location;
  /** Position after the end of the expression. */
  readonly end: Location;
}

/**
 * Expected a literal string, like `"foo"i`.
 */
export interface LiteralExpectation {
  readonly type: "literal";
  readonly text: string;
  readonly ignoreCase: boolean;
}

/**
 * Range of characters, like `a-z`
 */
export type ClassRange = [
  start: string,
  end: string,
]

export interface ClassParts extends Array<string | ClassRange> {
}

/**
 * Expected a class, such as `[^acd-gz]i`
 */
export interface ClassExpectation {
  readonly type: "class";
  readonly parts: ClassParts;
  readonly inverted: boolean;
  readonly ignoreCase: boolean;
}

/**
 * Expected any character, with `.`
 */
export interface AnyExpectation {
  readonly type: "any";
}

/**
 * Expected the end of input.
 */
export interface EndExpectation {
  readonly type: "end";
}

/**
 * Expected some other input.  These are specified with a rule's
 * "human-readable name", or with the `expected(message, location)`
 * function.
 */
export interface OtherExpectation {
  readonly type: "other";
  readonly description: string;
}

export type Expectation =
  | AnyExpectation
  | ClassExpectation
  | EndExpectation
  | LiteralExpectation
  | OtherExpectation;

/**
 * Pass an array of these into `SyntaxError.prototype.format()`
 */
export interface SourceText {
  /**
   * Identifier of an input that was used as a grammarSource in parse().
   */
  readonly source: GrammarSource;
  /** Source text of the input. */
  readonly text: string;
}

export declare class SyntaxError extends globalThis.SyntaxError {
  /**
   * Constructs the human-readable message from the machine representation.
   *
   * @param expected Array of expected items, generated by the parser
   * @param found Any text that will appear as found in the input instead of
   *   expected
   */
  static buildMessage(expected: Expectation[], found?: string | null | undefined): string;
  readonly expected: Expectation[];
  readonly found: string | null | undefined;
  readonly location: LocationRange;
  readonly name: string;
  constructor(
    message: string,
    expected: Expectation[],
    found: string | null,
    location: LocationRange,
  );

  /**
   * With good sources, generates a feature-rich error message pointing to the
   * error in the input.
   * @param sources List of {source, text} objects that map to the input.
   */
  format(sources: SourceText[]): string;
}

/**
 * Trace execution of the parser.
 */
export interface ParserTracer {
  trace: (event: ParserTracerEvent) => void;
}

export type ParserTracerEvent
  = {
      readonly type: "rule.enter";
      readonly rule: string;
      readonly location: LocationRange
    }
  | {
      readonly type: "rule.fail";
      readonly rule: string;
      readonly location: LocationRange
    }
  | {
      readonly type: "rule.match";
      readonly rule: string;
      readonly location: LocationRange
      /** Return value from the rule. */
      readonly result: unknown;
    };

export type StartRuleNames = "Headers" | "Headers_Loose" | "Header" | "Accept" | "Accept_CH" | "Accept_Charset" | "Accept_Encoding" | "Accept_Language" | "Accept_Ranges" | "Access_Control_Allow_Credentials" | "Access_Control_Allow_Headers" | "Access_Control_Allow_Methods" | "Access_Control_Allow_Origin" | "Access_Control_Expose_Headers" | "Access_Control_Max_Age" | "Access_Control_Request_Headers" | "Access_Control_Request_Method" | "Age" | "Allow" | "ALPN" | "Alt_Svc" | "Authentication_Info" | "Authorization" | "Cache_Control" | "Connection" | "Content_Encoding" | "Content_Language" | "Content_Length" | "Content_Location" | "Content_Range" | "Content_Security_Policy" | "Content_Security_Policy_Report_Only" | "Content_Type" | "Cross_Origin_Embedder_Policy" | "Cross_Origin_Embedder_Policy_Report_Only" | "Cross_Origin_Opener_Policy" | "Cross_Origin_Opener_Policy_Report_Only" | "Cross_Origin_Resource_Policy" | "Date" | "ETag" | "Expect" | "Expires" | "From" | "Host" | "If_Match" | "If_Modified_Since" | "If_None_Match" | "If_Range" | "If_Unmodified_Since" | "Last_Modified" | "Location" | "Link" | "Max_Forwards" | "NEL" | "Permissions_Policy" | "Proxy_Authenticate" | "Proxy_Authentication_Info" | "Proxy_Authorization" | "Range" | "Referer" | "Referrer_Policy" | "Retry_After" | "Reporting_Endpoints" | "Server" | "Server_Timing" | "Set_Cookie" | "Strict_Transport_Security" | "TE" | "Trailer" | "Upgrade" | "User_Agent" | "Vary" | "Via" | "WWW_Authenticate" | "Unknown_Header";
export interface ParseOptions<T extends StartRuleNames = "Headers"> {
  /**
   * String or object that will be attached to the each `LocationRange` object
   * created by the parser. For example, this can be path to the parsed file
   * or even the File object.
   */
  readonly grammarSource?: GrammarSource;
  readonly startRule?: T;
  readonly tracer?: ParserTracer;

  // Internal use only:
  readonly peg$library?: boolean;
  // Internal use only:
  peg$currPos?: number;
  // Internal use only:
  peg$silentFails?: number;
  // Internal use only:
  peg$maxFailExpected?: Expectation[];
  // Extra application-specific properties
  [key: string]: unknown;
}

export declare const StartRules: StartRuleNames[];
export declare const parse: typeof ParseFunction;

// Overload of ParseFunction for each allowedStartRule

declare function ParseFunction<Options extends ParseOptions<"Headers">>(
  input: string,
  options?: Options,
): Headers;

declare function ParseFunction<Options extends ParseOptions<"Headers_Loose">>(
  input: string,
  options?: Options,
): Headers;

declare function ParseFunction<Options extends ParseOptions<"Header">>(
  input: string,
  options?: Options,
): AnyHeader;

declare function ParseFunction<Options extends ParseOptions<"Accept">>(
  input: string,
  options?: Options,
): Accept;

declare function ParseFunction<Options extends ParseOptions<"Accept_CH">>(
  input: string,
  options?: Options,
): Accept_CH;

declare function ParseFunction<Options extends ParseOptions<"Accept_Charset">>(
  input: string,
  options?: Options,
): Accept_Charset;

declare function ParseFunction<Options extends ParseOptions<"Accept_Encoding">>(
  input: string,
  options?: Options,
): Accept_Encoding;

declare function ParseFunction<Options extends ParseOptions<"Accept_Language">>(
  input: string,
  options?: Options,
): Accept_Language;

declare function ParseFunction<Options extends ParseOptions<"Accept_Ranges">>(
  input: string,
  options?: Options,
): Accept_Ranges;

declare function ParseFunction<Options extends ParseOptions<"Access_Control_Allow_Credentials">>(
  input: string,
  options?: Options,
): Access_Control_Allow_Credentials;

declare function ParseFunction<Options extends ParseOptions<"Access_Control_Allow_Headers">>(
  input: string,
  options?: Options,
): Access_Control_Allow_Headers;

declare function ParseFunction<Options extends ParseOptions<"Access_Control_Allow_Methods">>(
  input: string,
  options?: Options,
): Access_Control_Allow_Methods;

declare function ParseFunction<Options extends ParseOptions<"Access_Control_Allow_Origin">>(
  input: string,
  options?: Options,
): Access_Control_Allow_Origin;

declare function ParseFunction<Options extends ParseOptions<"Access_Control_Expose_Headers">>(
  input: string,
  options?: Options,
): Access_Control_Expose_Headers;

declare function ParseFunction<Options extends ParseOptions<"Access_Control_Max_Age">>(
  input: string,
  options?: Options,
): Access_Control_Max_Age;

declare function ParseFunction<Options extends ParseOptions<"Access_Control_Request_Headers">>(
  input: string,
  options?: Options,
): Access_Control_Request_Headers;

declare function ParseFunction<Options extends ParseOptions<"Access_Control_Request_Method">>(
  input: string,
  options?: Options,
): Access_Control_Request_Method;

declare function ParseFunction<Options extends ParseOptions<"Age">>(
  input: string,
  options?: Options,
): Age;

declare function ParseFunction<Options extends ParseOptions<"Allow">>(
  input: string,
  options?: Options,
): Allow;

declare function ParseFunction<Options extends ParseOptions<"ALPN">>(
  input: string,
  options?: Options,
): ALPN;

declare function ParseFunction<Options extends ParseOptions<"Alt_Svc">>(
  input: string,
  options?: Options,
): any;

declare function ParseFunction<Options extends ParseOptions<"Authentication_Info">>(
  input: string,
  options?: Options,
): Authentication_Info;

declare function ParseFunction<Options extends ParseOptions<"Authorization">>(
  input: string,
  options?: Options,
): Authorization;

declare function ParseFunction<Options extends ParseOptions<"Cache_Control">>(
  input: string,
  options?: Options,
): Cache_Control;

declare function ParseFunction<Options extends ParseOptions<"Connection">>(
  input: string,
  options?: Options,
): Connection;

declare function ParseFunction<Options extends ParseOptions<"Content_Encoding">>(
  input: string,
  options?: Options,
): Content_Encoding;

declare function ParseFunction<Options extends ParseOptions<"Content_Language">>(
  input: string,
  options?: Options,
): Content_Language;

declare function ParseFunction<Options extends ParseOptions<"Content_Length">>(
  input: string,
  options?: Options,
): Content_Length;

declare function ParseFunction<Options extends ParseOptions<"Content_Location">>(
  input: string,
  options?: Options,
): Content_Location;

declare function ParseFunction<Options extends ParseOptions<"Content_Range">>(
  input: string,
  options?: Options,
): Content_Range;

declare function ParseFunction<Options extends ParseOptions<"Content_Security_Policy">>(
  input: string,
  options?: Options,
): Content_Security_Policy;

declare function ParseFunction<Options extends ParseOptions<"Content_Security_Policy_Report_Only">>(
  input: string,
  options?: Options,
): Content_Security_Policy_Report_Only;

declare function ParseFunction<Options extends ParseOptions<"Content_Type">>(
  input: string,
  options?: Options,
): Content_Type;

declare function ParseFunction<Options extends ParseOptions<"Cross_Origin_Embedder_Policy">>(
  input: string,
  options?: Options,
): Cross_Origin_Embedder_Policy;

declare function ParseFunction<Options extends ParseOptions<"Cross_Origin_Embedder_Policy_Report_Only">>(
  input: string,
  options?: Options,
): Cross_Origin_Embedder_Policy_Report_Only;

declare function ParseFunction<Options extends ParseOptions<"Cross_Origin_Opener_Policy">>(
  input: string,
  options?: Options,
): Cross_Origin_Opener_Policy;

declare function ParseFunction<Options extends ParseOptions<"Cross_Origin_Opener_Policy_Report_Only">>(
  input: string,
  options?: Options,
): Cross_Origin_Opener_Policy_Report_Only;

declare function ParseFunction<Options extends ParseOptions<"Cross_Origin_Resource_Policy">>(
  input: string,
  options?: Options,
): Cross_Origin_Resource_Policy;

declare function ParseFunction<Options extends ParseOptions<"Date">>(
  input: string,
  options?: Options,
): Date;

declare function ParseFunction<Options extends ParseOptions<"ETag">>(
  input: string,
  options?: Options,
): ETag;

declare function ParseFunction<Options extends ParseOptions<"Expect">>(
  input: string,
  options?: Options,
): Expect;

declare function ParseFunction<Options extends ParseOptions<"Expires">>(
  input: string,
  options?: Options,
): Expires;

declare function ParseFunction<Options extends ParseOptions<"From">>(
  input: string,
  options?: Options,
): From;

declare function ParseFunction<Options extends ParseOptions<"Host">>(
  input: string,
  options?: Options,
): Host;

declare function ParseFunction<Options extends ParseOptions<"If_Match">>(
  input: string,
  options?: Options,
): If_Match;

declare function ParseFunction<Options extends ParseOptions<"If_Modified_Since">>(
  input: string,
  options?: Options,
): If_Modified_Since;

declare function ParseFunction<Options extends ParseOptions<"If_None_Match">>(
  input: string,
  options?: Options,
): If_None_Match;

declare function ParseFunction<Options extends ParseOptions<"If_Range">>(
  input: string,
  options?: Options,
): If_Range;

declare function ParseFunction<Options extends ParseOptions<"If_Unmodified_Since">>(
  input: string,
  options?: Options,
): If_Unmodified_Since;

declare function ParseFunction<Options extends ParseOptions<"Last_Modified">>(
  input: string,
  options?: Options,
): Last_Modified;

declare function ParseFunction<Options extends ParseOptions<"Location">>(
  input: string,
  options?: Options,
): Location;

declare function ParseFunction<Options extends ParseOptions<"Link">>(
  input: string,
  options?: Options,
): Link;

declare function ParseFunction<Options extends ParseOptions<"Max_Forwards">>(
  input: string,
  options?: Options,
): Max_Forwards;

declare function ParseFunction<Options extends ParseOptions<"NEL">>(
  input: string,
  options?: Options,
): NEL;

declare function ParseFunction<Options extends ParseOptions<"Permissions_Policy">>(
  input: string,
  options?: Options,
): Permissions_Policy;

declare function ParseFunction<Options extends ParseOptions<"Proxy_Authenticate">>(
  input: string,
  options?: Options,
): Proxy_Authenticate;

declare function ParseFunction<Options extends ParseOptions<"Proxy_Authentication_Info">>(
  input: string,
  options?: Options,
): Proxy_Authentication_Info;

declare function ParseFunction<Options extends ParseOptions<"Proxy_Authorization">>(
  input: string,
  options?: Options,
): Proxy_Authorization;

declare function ParseFunction<Options extends ParseOptions<"Range">>(
  input: string,
  options?: Options,
): Range;

declare function ParseFunction<Options extends ParseOptions<"Referer">>(
  input: string,
  options?: Options,
): Referer;

declare function ParseFunction<Options extends ParseOptions<"Referrer_Policy">>(
  input: string,
  options?: Options,
): Referrer_Policy;

declare function ParseFunction<Options extends ParseOptions<"Retry_After">>(
  input: string,
  options?: Options,
): Retry_After;

declare function ParseFunction<Options extends ParseOptions<"Reporting_Endpoints">>(
  input: string,
  options?: Options,
): Reporting_Endpoints;

declare function ParseFunction<Options extends ParseOptions<"Server">>(
  input: string,
  options?: Options,
): Server;

declare function ParseFunction<Options extends ParseOptions<"Server_Timing">>(
  input: string,
  options?: Options,
): Server_Timing;

declare function ParseFunction<Options extends ParseOptions<"Set_Cookie">>(
  input: string,
  options?: Options,
): Set_Cookie;

declare function ParseFunction<Options extends ParseOptions<"Strict_Transport_Security">>(
  input: string,
  options?: Options,
): Strict_Transport_Security;

declare function ParseFunction<Options extends ParseOptions<"TE">>(
  input: string,
  options?: Options,
): TE;

declare function ParseFunction<Options extends ParseOptions<"Trailer">>(
  input: string,
  options?: Options,
): Trailer;

declare function ParseFunction<Options extends ParseOptions<"Upgrade">>(
  input: string,
  options?: Options,
): Upgrade;

declare function ParseFunction<Options extends ParseOptions<"User_Agent">>(
  input: string,
  options?: Options,
): User_Agent;

declare function ParseFunction<Options extends ParseOptions<"Vary">>(
  input: string,
  options?: Options,
): Vary;

declare function ParseFunction<Options extends ParseOptions<"Via">>(
  input: string,
  options?: Options,
): Via;

declare function ParseFunction<Options extends ParseOptions<"WWW_Authenticate">>(
  input: string,
  options?: Options,
): WWW_Authenticate;

declare function ParseFunction<Options extends ParseOptions<"Unknown_Header">>(
  input: string,
  options?: Options,
): Unknown_Header;

declare function ParseFunction<Options extends ParseOptions<StartRuleNames>>(
  input: string,
  options?: Options,
): Headers | AnyHeader | Accept | Accept_CH | Accept_Charset | Accept_Encoding | Accept_Language | Accept_Ranges | Access_Control_Allow_Credentials | Access_Control_Allow_Headers | Access_Control_Allow_Methods | Access_Control_Allow_Origin | Access_Control_Expose_Headers | Access_Control_Max_Age | Access_Control_Request_Headers | Access_Control_Request_Method | Age | Allow | ALPN | any | Authentication_Info | Authorization | Cache_Control | Connection | Content_Encoding | Content_Language | Content_Length | Content_Location | Content_Range | Content_Security_Policy | Content_Security_Policy_Report_Only | Content_Type | Cross_Origin_Embedder_Policy | Cross_Origin_Embedder_Policy_Report_Only | Cross_Origin_Opener_Policy | Cross_Origin_Opener_Policy_Report_Only | Cross_Origin_Resource_Policy | Date | ETag | Expect | Expires | From | Host | If_Match | If_Modified_Since | If_None_Match | If_Range | If_Unmodified_Since | Last_Modified | Location | Link | Max_Forwards | NEL | Permissions_Policy | Proxy_Authenticate | Proxy_Authentication_Info | Proxy_Authorization | Range | Referer | Referrer_Policy | Retry_After | Reporting_Endpoints | Server | Server_Timing | Set_Cookie | Strict_Transport_Security | TE | Trailer | Upgrade | User_Agent | Vary | Via | WWW_Authenticate | Unknown_Header;