@zudojs/http 0.0.6 → 1.0.0

package/dist/httpHeaders/security/httpHeaders.security.js

@@ -0,0 +1,135 @@
+/**
+ * Header security utilities for preventing header injection.
+ *
+ * This module is the single hardened definition of "safe" for HTTP field
+ * names, field values and quoted-string parameter values in this package.
+ * Every module that emits a header name, a header value, or a
+ * `quoted-string` parameter must route through the helpers defined here so
+ * that CR, LF, NUL and the remaining C0/DEL controls cannot reach the wire.
+ *
+ * @module httpHeaders/security
+ */
+/**
+ * Characters forbidden in an RFC 9110 §5.5 `field-value`.
+ *
+ * `field-value = *( field-vchar / SP / HTAB )` with
+ * `field-vchar = VCHAR / obs-text`, so every C0 control other than HTAB
+ * (`\x09`) is forbidden, as is DEL (`\x7f`).
+ */
+const FORBIDDEN_FIELD_CHARS = /[\u0000-\u0008\u000a-\u001f\u007f]/;
+const FORBIDDEN_FIELD_CHARS_GLOBAL = /[\u0000-\u0008\u000a-\u001f\u007f]/g;
+/**
+ * RFC 9110 §5.6.2 `token`.
+ */
+const TOKEN_PATTERN = /^[!#$%&'*+\-.^_`|~0-9A-Za-z]+$/;
+/**
+ * Checks if a string contains CR or LF characters.
+ *
+ * @param value - The string to check.
+ * @returns `true` if the string contains `\r` or `\n`.
+ */
+export function containsCRLF(value) {
+    return /[\r\n]/.test(value);
+}
+/**
+ * Checks if a string contains any character forbidden in an HTTP field value.
+ *
+ * This covers CR, LF, NUL, every other C0 control except HTAB, and DEL.
+ *
+ * @param value - The string to check.
+ * @returns `true` if the string contains a forbidden control character.
+ */
+export function containsForbiddenHeaderChars(value) {
+    return FORBIDDEN_FIELD_CHARS.test(value);
+}
+/**
+ * Checks whether a string is a valid RFC 9110 §5.5 `field-value`.
+ *
+ * A valid field value contains no forbidden control characters and has no
+ * leading or trailing SP/HTAB (which a recipient is required to strip, and
+ * whose presence therefore makes the value ambiguous on the wire).
+ *
+ * @param value - The candidate field value.
+ * @returns `true` if the value may be emitted verbatim.
+ */
+export function isValidHeaderFieldValue(value) {
+    if (typeof value !== "string") {
+        return false;
+    }
+    if (containsForbiddenHeaderChars(value)) {
+        return false;
+    }
+    return value.trim().length === value.length;
+}
+/**
+ * Checks whether a string is a valid RFC 9110 §5.6.2 `token`, which is the
+ * grammar for an HTTP field name.
+ *
+ * @param name - The candidate field name.
+ * @returns `true` if the name is a valid token.
+ */
+export function isValidHeaderFieldName(name) {
+    if (typeof name !== "string" || name.length === 0) {
+        return false;
+    }
+    return TOKEN_PATTERN.test(name);
+}
+/**
+ * Throws if a header value contains any character forbidden in a field value.
+ *
+ * @param value - The header value to validate.
+ * @throws {TypeError} If the value contains CR, LF, NUL or another C0/DEL
+ *   control character, or has leading/trailing whitespace.
+ */
+export function assertSafeHeaderValue(value) {
+    if (typeof value !== "string" || containsForbiddenHeaderChars(value)) {
+        throw new TypeError("HTTP header values must not contain CR, LF, NUL or other control characters.");
+    }
+    if (value.trim().length !== value.length) {
+        throw new TypeError("HTTP header values must not have leading or trailing whitespace.");
+    }
+}
+/**
+ * Throws if a header name is not a valid RFC 9110 `token`.
+ *
+ * @param name - The header name to validate.
+ * @throws {TypeError} If the name is empty or contains a non-token character.
+ */
+export function assertSafeHeaderName(name) {
+    if (!isValidHeaderFieldName(name)) {
+        throw new TypeError(`Invalid HTTP header name: ${JSON.stringify(name)}`);
+    }
+}
+/**
+ * Removes every character forbidden in an HTTP field value.
+ *
+ * CR, LF, NUL and the remaining C0/DEL controls are stripped; HTAB and
+ * printable characters are preserved. Leading and trailing whitespace is
+ * trimmed.
+ *
+ * @param value - The header value to sanitize.
+ * @returns The sanitized value.
+ */
+export function sanitizeHeaderValue(value) {
+    return value.replace(FORBIDDEN_FIELD_CHARS_GLOBAL, "").trim();
+}
+/**
+ * Escapes a string for emission inside an RFC 9110 `quoted-string`.
+ *
+ * Control characters cannot be represented inside a `quoted-string` — a
+ * `quoted-pair` may only escape a printable character — so any forbidden
+ * control character is rejected rather than escaped. This prevents the
+ * response-splitting class of defect in every module that emits a quoted
+ * parameter value.
+ *
+ * @param value - The raw parameter value.
+ * @returns The escaped value, without the surrounding quotes.
+ * @throws {TypeError} If the value contains a forbidden control character.
+ */
+export function escapeHeaderQuotedString(value) {
+    if (containsForbiddenHeaderChars(value)) {
+        throw new TypeError("HTTP quoted-string values must not contain CR, LF, NUL or other control characters.");
+    }
+    return value.replaceAll("\\", "\\\\").replaceAll('"', '\\"');
+}
+//# sourceMappingURL=httpHeaders.security.js.map

package/dist/httpHeaders/security/index.d.ts

@@ -4,5 +4,4 @@
  * HTTP headers security utilities.
  */
 export * from "./httpHeaders.security.js";
-export * from "./index.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/httpHeaders/security/index.js

@@ -4,5 +4,4 @@
  * HTTP headers security utilities.
  */
 export * from "./httpHeaders.security.js";
-export * from "./index.js";
 //# sourceMappingURL=index.js.map

package/dist/httpHeaders/types/httpHeaders.type.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Types and interfaces for HTTP header utilities.
+ *
+ * @module httpHeaders/type
+ */
+import type { IncomingHttpHeaders, OutgoingHttpHeaders } from "node:http";
+import type { HTTPHeaders, HTTPHeadersInit } from "../http.headers.js";
+/**
+ * A union of all supported header input formats.
+ */
+export type HTTPHeadersLike = HTTPHeaders | HTTPHeadersInit | IncomingHttpHeaders | OutgoingHttpHeaders | Headers;
+/**
+ * Options for header matching operations.
+ */
+export interface HeaderMatchOptions {
+    readonly caseSensitive?: boolean;
+    readonly trim?: boolean;
+}
+//# sourceMappingURL=httpHeaders.type.d.ts.map

package/dist/httpHeaders/types/httpHeaders.type.js

@@ -0,0 +1,7 @@
+/**
+ * Types and interfaces for HTTP header utilities.
+ *
+ * @module httpHeaders/type
+ */
+export {};
+//# sourceMappingURL=httpHeaders.type.js.map

package/dist/httpHsts/http.hsts.d.ts

@@ -0,0 +1,45 @@
+/**
+ * HTTP Strict Transport Security (HSTS) utilities.
+ *
+ * Provides parsing, formatting, validation, and response-header helpers
+ * for the Strict-Transport-Security header.
+ */
+export interface HSTSOptions {
+    readonly maxAge: number;
+    readonly includeSubDomains?: boolean;
+    readonly preload?: boolean;
+}
+export interface HSTSPolicy {
+    readonly maxAge: number;
+    readonly includeSubDomains: boolean;
+    readonly preload: boolean;
+}
+export interface HSTSResult {
+    readonly header: string;
+    readonly policy: HSTSPolicy;
+}
+export declare const STRICT_TRANSPORT_SECURITY_HEADER = "Strict-Transport-Security";
+export declare const HSTS_DEFAULT_MAX_AGE = 31536000;
+export declare const HSTS_PRELOAD_MIN_MAX_AGE = 31536000;
+export declare function parseHSTS(value: string | undefined | null): HSTSPolicy | undefined;
+export declare function formatHSTS(options: HSTSOptions | HSTSPolicy): string;
+export declare function createHSTS(options?: Partial<HSTSOptions>): HSTSResult;
+export declare function createHSTSHeader(options?: Partial<HSTSOptions>): string;
+export declare function strictHSTS(options?: Partial<HSTSOptions>): string;
+export declare function preloadHSTS(options?: Partial<HSTSOptions>): string;
+export declare function validateHSTS(value: string): boolean;
+export declare function validateHSTSPolicy(policy: HSTSPolicy): boolean;
+export declare function validateHSTSOptions(options: HSTSOptions | HSTSPolicy): void;
+export declare function isHSTS(value: string | undefined | null): boolean;
+export declare function isHSTSPreloadable(value: string | HSTSPolicy): boolean;
+export declare function hasIncludeSubDomains(value: string | HSTSPolicy): boolean;
+export declare function hasPreload(value: string | HSTSPolicy): boolean;
+export declare function getHSTSMaxAge(value: string | HSTSPolicy): number | undefined;
+export declare function createHSTSRemovalHeader(): string;
+export declare function isHSTSDisabled(value: string | HSTSPolicy): boolean;
+export declare function createHSTSOptions(maxAge: number, options?: Omit<Partial<HSTSOptions>, "maxAge">): HSTSOptions;
+export declare function createHSTSHeaders(options?: Partial<HSTSOptions>): Readonly<Record<string, string>>;
+export declare function hstsDays(days: number): number;
+export declare function hstsHours(hours: number): number;
+export declare function hstsMinutes(minutes: number): number;
+//# sourceMappingURL=http.hsts.d.ts.map

package/dist/httpHsts/http.hsts.js

@@ -0,0 +1,224 @@
+/**
+ * HTTP Strict Transport Security (HSTS) utilities.
+ *
+ * Provides parsing, formatting, validation, and response-header helpers
+ * for the Strict-Transport-Security header.
+ */
+/* -------------------------------------------------------------------------- */
+/* Constants                                                                  */
+/* -------------------------------------------------------------------------- */
+export const STRICT_TRANSPORT_SECURITY_HEADER = "Strict-Transport-Security";
+export const HSTS_DEFAULT_MAX_AGE = 31536000;
+export const HSTS_PRELOAD_MIN_MAX_AGE = 31536000;
+/* -------------------------------------------------------------------------- */
+/* Parsing                                                                    */
+/* -------------------------------------------------------------------------- */
+export function parseHSTS(value) {
+    if (value === undefined || value === null || value.trim().length === 0) {
+        return undefined;
+    }
+    const directives = value
+        .split(";")
+        .map((item) => item.trim())
+        .filter(Boolean);
+    let maxAge;
+    let includeSubDomains = false;
+    let preload = false;
+    for (const directive of directives) {
+        const separator = directive.indexOf("=");
+        const name = (separator === -1 ? directive : directive.slice(0, separator))
+            .trim()
+            .toLowerCase();
+        const rawValue = separator === -1 ? undefined : directive.slice(separator + 1).trim();
+        if (name === "max-age") {
+            if (rawValue === undefined || !/^\d+$/.test(rawValue)) {
+                return undefined;
+            }
+            const parsed = Number(rawValue);
+            if (!Number.isSafeInteger(parsed)) {
+                return undefined;
+            }
+            maxAge = parsed;
+            continue;
+        }
+        if (name === "includeSubDomains".toLowerCase()) {
+            includeSubDomains = true;
+            continue;
+        }
+        if (name === "preload") {
+            preload = true;
+        }
+    }
+    if (maxAge === undefined) {
+        return undefined;
+    }
+    return {
+        maxAge,
+        includeSubDomains,
+        preload,
+    };
+}
+/* -------------------------------------------------------------------------- */
+/* Formatting                                                                 */
+/* -------------------------------------------------------------------------- */
+export function formatHSTS(options) {
+    validateHSTSOptions(options);
+    const parts = [`max-age=${options.maxAge}`];
+    if (options.includeSubDomains) {
+        parts.push("includeSubDomains");
+    }
+    if (options.preload) {
+        parts.push("preload");
+    }
+    return parts.join("; ");
+}
+export function createHSTS(options = {}) {
+    const policy = {
+        maxAge: options.maxAge ?? HSTS_DEFAULT_MAX_AGE,
+        includeSubDomains: options.includeSubDomains ?? false,
+        preload: options.preload ?? false,
+    };
+    validateHSTSOptions(policy);
+    return {
+        header: formatHSTS(policy),
+        policy,
+    };
+}
+export function createHSTSHeader(options = {}) {
+    return createHSTS(options).header;
+}
+/* -------------------------------------------------------------------------- */
+/* Common Policies                                                            */
+/* -------------------------------------------------------------------------- */
+export function strictHSTS(options = {}) {
+    return createHSTSHeader({
+        maxAge: options.maxAge ?? HSTS_DEFAULT_MAX_AGE,
+        includeSubDomains: options.includeSubDomains ?? true,
+        preload: options.preload ?? false,
+    });
+}
+export function preloadHSTS(options = {}) {
+    return createHSTSHeader({
+        maxAge: options.maxAge ?? HSTS_PRELOAD_MIN_MAX_AGE,
+        includeSubDomains: options.includeSubDomains ?? true,
+        preload: options.preload ?? true,
+    });
+}
+/* -------------------------------------------------------------------------- */
+/* Validation                                                                 */
+/* -------------------------------------------------------------------------- */
+export function validateHSTS(value) {
+    const policy = parseHSTS(value);
+    if (!policy) {
+        return false;
+    }
+    return validateHSTSPolicy(policy);
+}
+export function validateHSTSPolicy(policy) {
+    try {
+        validateHSTSOptions(policy);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export function validateHSTSOptions(options) {
+    if (!Number.isSafeInteger(options.maxAge) || options.maxAge < 0) {
+        throw new RangeError("HSTS maxAge must be a non-negative safe integer.");
+    }
+    if (typeof options.includeSubDomains !== "boolean") {
+        throw new TypeError("HSTS includeSubDomains must be a boolean.");
+    }
+    if (typeof options.preload !== "boolean") {
+        throw new TypeError("HSTS preload must be a boolean.");
+    }
+    if (options.preload && options.maxAge < HSTS_PRELOAD_MIN_MAX_AGE) {
+        throw new RangeError(`HSTS preload requires maxAge to be at least ${HSTS_PRELOAD_MIN_MAX_AGE} seconds.`);
+    }
+    if (options.preload && !options.includeSubDomains) {
+        throw new RangeError("HSTS preload requires includeSubDomains to be enabled.");
+    }
+}
+/* -------------------------------------------------------------------------- */
+/* Policy Helpers                                                             */
+/* -------------------------------------------------------------------------- */
+export function isHSTS(value) {
+    return parseHSTS(value) !== undefined;
+}
+export function isHSTSPreloadable(value) {
+    const policy = typeof value === "string" ? parseHSTS(value) : value;
+    if (!policy) {
+        return false;
+    }
+    return policy.maxAge >= HSTS_PRELOAD_MIN_MAX_AGE && policy.includeSubDomains;
+}
+export function hasIncludeSubDomains(value) {
+    const policy = typeof value === "string" ? parseHSTS(value) : value;
+    return policy?.includeSubDomains ?? false;
+}
+export function hasPreload(value) {
+    const policy = typeof value === "string" ? parseHSTS(value) : value;
+    return policy?.preload ?? false;
+}
+export function getHSTSMaxAge(value) {
+    const policy = typeof value === "string" ? parseHSTS(value) : value;
+    return policy?.maxAge;
+}
+/* -------------------------------------------------------------------------- */
+/* Expiration                                                                  */
+/* -------------------------------------------------------------------------- */
+export function createHSTSRemovalHeader() {
+    return "max-age=0";
+}
+export function isHSTSDisabled(value) {
+    return getHSTSMaxAge(value) === 0;
+}
+export function createHSTSOptions(maxAge, options = {}) {
+    return {
+        maxAge,
+        includeSubDomains: options.includeSubDomains ?? false,
+        preload: options.preload ?? false,
+    };
+}
+/* -------------------------------------------------------------------------- */
+/* HTTP Header Helpers                                                        */
+/* -------------------------------------------------------------------------- */
+export function createHSTSHeaders(options = {}) {
+    return {
+        [STRICT_TRANSPORT_SECURITY_HEADER]: createHSTSHeader(options),
+    };
+}
+/* -------------------------------------------------------------------------- */
+/* Time Helpers                                                               */
+/* -------------------------------------------------------------------------- */
+export function hstsDays(days) {
+    validateFiniteNumber(days, "days");
+    if (days < 0) {
+        throw new RangeError("days cannot be negative.");
+    }
+    return Math.floor(days * 24 * 60 * 60);
+}
+export function hstsHours(hours) {
+    validateFiniteNumber(hours, "hours");
+    if (hours < 0) {
+        throw new RangeError("hours cannot be negative.");
+    }
+    return Math.floor(hours * 60 * 60);
+}
+export function hstsMinutes(minutes) {
+    validateFiniteNumber(minutes, "minutes");
+    if (minutes < 0) {
+        throw new RangeError("minutes cannot be negative.");
+    }
+    return Math.floor(minutes * 60);
+}
+/* -------------------------------------------------------------------------- */
+/* Internal Helpers                                                           */
+/* -------------------------------------------------------------------------- */
+function validateFiniteNumber(value, name) {
+    if (!Number.isFinite(value)) {
+        throw new TypeError(`${name} must be a finite number.`);
+    }
+}
+//# sourceMappingURL=http.hsts.js.map

package/dist/httpInterceptors/builtin/httpInterceptor.request.d.ts

@@ -0,0 +1,70 @@
+/**
+ * Request interceptors.
+ *
+ * @module httpInterceptors/builtin/request
+ */
+import type { HttpInterceptorOptions } from "../httpInterceptor.type.js";
+export interface RequestIdInterceptorOptions extends HttpInterceptorOptions {
+    readonly headerName?: string;
+    readonly generator?: () => string;
+}
+export declare function createRequestIdInterceptor(options?: RequestIdInterceptorOptions): {
+    phase: "request";
+    priority: import("../httpInterceptor.type.js").InterceptorPriority;
+    name: string;
+    handler: (request: {
+        readonly headers: Record<string, string | undefined>;
+    }) => {
+        headers: {
+            [x: string]: string | undefined;
+        };
+    };
+};
+export interface UserAgentInterceptorOptions extends HttpInterceptorOptions {
+    readonly userAgent?: string;
+    readonly headerName?: string;
+}
+export declare function createUserAgentInterceptor(options?: UserAgentInterceptorOptions): {
+    phase: "request";
+    priority: import("../httpInterceptor.type.js").InterceptorPriority;
+    name: string;
+    handler: (request: {
+        readonly headers: Record<string, string | undefined>;
+    }) => {
+        headers: {
+            [x: string]: string | undefined;
+        };
+    };
+};
+export interface BearerTokenInterceptorOptions extends HttpInterceptorOptions {
+    readonly token: string | (() => string);
+    readonly headerName?: string;
+}
+export declare function createBearerTokenInterceptor(options: BearerTokenInterceptorOptions): {
+    phase: "request";
+    priority: import("../httpInterceptor.type.js").InterceptorPriority;
+    name: string;
+    handler: (request: {
+        readonly headers: Record<string, string | undefined>;
+    }) => {
+        headers: {
+            [x: string]: string | undefined;
+        };
+    };
+};
+export interface JsonAcceptInterceptorOptions extends HttpInterceptorOptions {
+    readonly headerName?: string;
+}
+export declare function createJsonAcceptInterceptor(options?: JsonAcceptInterceptorOptions): {
+    phase: "request";
+    priority: import("../httpInterceptor.type.js").InterceptorPriority;
+    name: string;
+    handler: (request: {
+        readonly headers: Record<string, string | undefined>;
+    }) => {
+        headers: {
+            [x: string]: string | undefined;
+        };
+    };
+};
+//# sourceMappingURL=httpInterceptor.request.d.ts.map

package/dist/httpInterceptors/builtin/httpInterceptor.response.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Response interceptors.
+ *
+ * @module httpInterceptors/builtin/response
+ */
+import type { HttpInterceptorOptions } from "../httpInterceptor.type.js";
+export interface ResponseHeaderInterceptorOptions extends HttpInterceptorOptions {
+    readonly headers: Record<string, string>;
+    readonly override?: boolean;
+}
+export declare function createResponseHeaderInterceptor(options: ResponseHeaderInterceptorOptions): {
+    phase: "response";
+    priority: import("../httpInterceptor.type.js").InterceptorPriority;
+    name: string;
+    handler: (response: {
+        readonly headers: Record<string, string | undefined>;
+    }) => {
+        headers: {
+            [x: string]: string | undefined;
+        };
+    };
+};
+export declare function createStatusErrorInterceptor(options?: HttpInterceptorOptions): {
+    phase: "response";
+    priority: import("../httpInterceptor.type.js").InterceptorPriority;
+    name: string;
+    handler: (response: {
+        readonly status: number;
+    }) => {
+        readonly status: number;
+    };
+};
+//# sourceMappingURL=httpInterceptor.response.d.ts.map

package/dist/httpInterceptors/builtin/httpInterceptor.response.js

@@ -0,0 +1,43 @@
+/**
+ * Response interceptors.
+ *
+ * @module httpInterceptors/builtin/response
+ */
+export function createResponseHeaderInterceptor(options) {
+    return {
+        phase: "response",
+        priority: options.priority ?? "normal",
+        name: options.name ?? "response-headers",
+        handler: (response) => {
+            const headers = { ...response.headers };
+            if (options.override) {
+                Object.assign(headers, options.headers);
+            }
+            else {
+                for (const [key, value] of Object.entries(options.headers)) {
+                    if (!headers[key]) {
+                        headers[key] = value;
+                    }
+                }
+            }
+            return {
+                ...response,
+                headers,
+            };
+        },
+    };
+}
+export function createStatusErrorInterceptor(options = {}) {
+    return {
+        phase: "response",
+        priority: options.priority ?? "normal",
+        name: options.name ?? "status-error",
+        handler: (response) => {
+            if (response.status >= 400) {
+                throw new Error(`HTTP Error: ${response.status}`);
+            }
+            return response;
+        },
+    };
+}
+//# sourceMappingURL=httpInterceptor.response.js.map

package/dist/httpInterceptors/builtin/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Built-in HTTP interceptors.
+ *
+ * @module httpInterceptors/builtin
+ */
+export * from "./httpInterceptor.request.js";
+export * from "./httpInterceptor.response.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/httpInterceptors/builtin/index.js

@@ -0,0 +1,8 @@
+/**
+ * Built-in HTTP interceptors.
+ *
+ * @module httpInterceptors/builtin
+ */
+export * from "./httpInterceptor.request.js";
+export * from "./httpInterceptor.response.js";
+//# sourceMappingURL=index.js.map

package/dist/httpInterceptors/http.interceptors.d.ts

@@ -0,0 +1,11 @@
+/**
+ * HTTP interceptors for request/response processing.
+ *
+ * @module httpInterceptors
+ */
+export * from "./httpInterceptor.type.js";
+export * from "./httpInterceptor.helper.js";
+export * from "./manager/httpInterceptor.manager.js";
+export * from "./builtin/httpInterceptor.request.js";
+export * from "./builtin/httpInterceptor.response.js";
+//# sourceMappingURL=http.interceptors.d.ts.map

package/dist/httpInterceptors/http.interceptors.js

@@ -0,0 +1,11 @@
+/**
+ * HTTP interceptors for request/response processing.
+ *
+ * @module httpInterceptors
+ */
+export * from "./httpInterceptor.type.js";
+export * from "./httpInterceptor.helper.js";
+export * from "./manager/httpInterceptor.manager.js";
+export * from "./builtin/httpInterceptor.request.js";
+export * from "./builtin/httpInterceptor.response.js";
+//# sourceMappingURL=http.interceptors.js.map

package/dist/httpInterceptors/httpInterceptor.helper.d.ts

@@ -0,0 +1,27 @@
+/**
+ * HTTP interceptor helper functions.
+ *
+ * @module httpInterceptors/helpers
+ */
+import type { InterceptorPriority } from "./httpInterceptor.type.js";
+/**
+ * Normalizes a priority string.
+ */
+export declare function normalizePriority(priority: InterceptorPriority | string): InterceptorPriority;
+/**
+ * Sanitizes a name for use as an identifier.
+ */
+export declare function sanitizeName(name: string): string;
+/**
+ * Compares two IDs for ordering.
+ */
+export declare function compareIds(a: string, b: string): number;
+/**
+ * Extracts a sequence number from an ID.
+ */
+export declare function extractSequence(id: string): number;
+/**
+ * Generates a default request ID.
+ */
+export declare function defaultRequestId(): string;
+//# sourceMappingURL=httpInterceptor.helper.d.ts.map