kinetex 0.0.2 → 1.0.0-rc.2

package/dist/types/interceptors.d.ts

@@ -0,0 +1,681 @@
+/**
+ * interceptors.ts
+ *
+ * Cross-runtime HTTP interceptor pipeline.
+ *
+ * Runtimes: Deno · Bun · Node.js · Cloudflare Workers · Vercel Edge ·
+ *           AWS Lambda · Browser · any WinterCG-compatible runtime.
+ *
+ * Features:
+ *  - Request interceptors  (mutate, replace, abort before sending)
+ *  - Response interceptors (mutate, retry, transform body)
+ *  - Error interceptors    (recover, rethrow, classify)
+ *  - Named interceptors    (register, eject by ID)
+ *  - Priority ordering     (lower number = runs first)
+ *  - Async-first pipeline  (every hook is async-capable)
+ *  - Scoped interceptors   (per-instance, not global)
+ *  - One-shot interceptors (auto-eject after first run)
+ *  - Conditional interceptors (predicate-gated execution)
+ *  - Retry interceptor     (exponential back-off, jitter, per-status config)
+ *  - Auth interceptor      (Bearer injection + token refresh + queue)
+ *  - Logging interceptor   (structured, redaction-aware)
+ *  - Timeout interceptor   (per-request deadline with AbortSignal)
+ *  - Cache interceptor     (in-memory LRU, stale-while-revalidate)
+ *  - Dedupe interceptor    (coalesce identical in-flight requests)
+ *  - Rate-limit interceptor (token bucket, respect Retry-After)
+ *  - HAR interceptor       (record HTTP Archive entries)
+ *  - Metrics interceptor   (timing, status buckets, error rates)
+ *  - No dependencies, no runtime globals beyond Promise/Map/Set
+ */
+/** Normalized request passed through the pipeline. */
+export interface InterceptorRequest {
+    /** Target URL */
+    url: string;
+    /** HTTP method (GET, POST, etc.) */
+    method: string;
+    /** Request headers as a flat object */
+    headers: Record<string, string>;
+    /** Request body */
+    body: BodyInit | null;
+    /** AbortSignal for cancellation (may be null) */
+    signal: AbortSignal | null;
+    /**
+     * Arbitrary per-request metadata bag — interceptors may read/write freely.
+     * Simple string-keyed values for request-scoped data.
+     *
+     * Use `meta` for:
+     * - Request-specific data (e.g., user ID, request ID)
+     * - Simple configuration passed between interceptors
+     *
+     * Use `ctx.store` (Map<symbol,>) for:
+     * - Complex objects requiring Symbol keys
+     * - Pipeline-scoped data shared across request/response/error phases
+     * - Avoiding key collisions with other interceptors
+     *
+     * @example
+     * ```ts
+     * // In request interceptor:
+     * ctx.request.meta.userId = "123";
+     *
+     * // In response interceptor:
+     * const userId = ctx.request.meta.userId;
+     * ```
+     */
+    meta: Record<string, unknown>;
+}
+/** Normalized response passed through the pipeline. */
+export interface InterceptorResponse {
+    /** HTTP status code */
+    status: number;
+    /** HTTP status text (e.g. "OK") */
+    statusText: string;
+    /** Response headers as a flat object */
+    headers: Record<string, string>;
+    /** Response body as string or binary */
+    body: string | Uint8Array | null;
+    /** Original runtime response (fetch Response, node http.IncomingMessage, etc.) */
+    raw: unknown;
+    /** Reference back to the request that produced this response */
+    request: InterceptorRequest;
+}
+/** Context object threaded through the entire pipeline for one request. */
+export interface InterceptorContext {
+    /** Mutable request — interceptors modify this in place */
+    request: InterceptorRequest;
+    /** Set by the dispatcher when the response arrives */
+    response: InterceptorResponse | null;
+    /** Set when an error occurs at any stage */
+    error: unknown | null;
+    /** Monotonic start time (performance.now() or Date.now()) */
+    startedAt: number;
+    /** Attempt counter, incremented by retry interceptor */
+    attempt: number;
+    /** Whether the pipeline has been aborted */
+    aborted: boolean;
+    /**
+     * Shared pipeline-scoped storage for cross-interceptor communication.
+     * Use Symbols as keys to avoid conflicts.
+     *
+     * @example
+     * ```ts
+     * const MY_KEY = Symbol("myKey");
+     * ctx.store.set(MY_KEY, { computed: true });
+     * // Later interceptor:
+     * const data = ctx.store.get(MY_KEY);
+     * ```
+     *
+     * @see meta For per-request metadata (simpler key-value store)
+     */
+    store: Map<symbol, unknown>;
+}
+/**
+ * A request interceptor may:
+ *  - return void / undefined  → pass the (possibly mutated) request through
+ *  - return InterceptorRequest → replace the request entirely
+ *  - return InterceptorResponse → short-circuit; skip the actual fetch
+ *  - throw                    → abort the pipeline with that error
+ */
+export type RequestInterceptorResult = void | undefined | InterceptorRequest | InterceptorResponse;
+/**
+ * A response interceptor may:
+ *  - return void / undefined     → pass through
+ *  - return InterceptorResponse  → replace the response
+ *  - return InterceptorRequest   → retry (pipeline re-runs from dispatch)
+ *  - throw                       → convert to error pipeline
+ */
+export type ResponseInterceptorResult = void | undefined | InterceptorResponse | InterceptorRequest;
+/**
+ * An error interceptor may:
+ *  - return void / undefined     → rethrow the error
+ *  - return InterceptorResponse  → recover with synthetic response
+ *  - throw                       → replace with a different error
+ */
+export type ErrorInterceptorResult = void | undefined | InterceptorResponse;
+/** Generic interceptor function type (internal use). */
+export type InterceptorFn<T = unknown> = (ctx: InterceptorContext) => Promise<T> | T;
+/** A request-phase interceptor function. */
+export type RequestInterceptorFn = (ctx: InterceptorContext) => Promise<RequestInterceptorResult> | RequestInterceptorResult;
+/** A response-phase interceptor function. */
+export type ResponseInterceptorFn = (ctx: InterceptorContext) => Promise<ResponseInterceptorResult> | ResponseInterceptorResult;
+/** An error-phase interceptor function. */
+export type ErrorInterceptorFn = (ctx: InterceptorContext) => Promise<ErrorInterceptorResult> | ErrorInterceptorResult;
+/** A registered request interceptor. */
+export interface RequestInterceptor {
+    /** Unique identifier used for ejection. */
+    id: string;
+    /** Execution priority (lower = runs first). */
+    priority: number;
+    /** Auto-eject after first execution. */
+    once: boolean;
+    /** Optional predicate gate — interceptor is skipped if false. */
+    condition: ((ctx: InterceptorContext) => boolean) | null;
+    /** The interceptor function. */
+    fn: RequestInterceptorFn;
+}
+/** A registered response interceptor. */
+export interface ResponseInterceptor {
+    /** Unique identifier used for ejection. */
+    id: string;
+    /** Execution priority (lower = runs first). */
+    priority: number;
+    /** Auto-eject after first execution. */
+    once: boolean;
+    /** Optional predicate gate — interceptor is skipped if false. */
+    condition: ((ctx: InterceptorContext) => boolean) | null;
+    /** The interceptor function. */
+    fn: ResponseInterceptorFn;
+}
+/** A registered error interceptor. */
+export interface ErrorInterceptor {
+    /** Unique identifier used for ejection. */
+    id: string;
+    /** Execution priority (lower = runs first). */
+    priority: number;
+    /** Auto-eject after first execution. */
+    once: boolean;
+    /** Optional predicate gate — interceptor is skipped if false. */
+    condition: ((ctx: InterceptorContext) => boolean) | null;
+    /** The interceptor function. */
+    fn: ErrorInterceptorFn;
+}
+export interface InterceptorOptions {
+    /** Unique ID. Auto-generated if omitted. */
+    id?: string;
+    /**
+     * Execution order. Lower = earlier.
+     * Request interceptors: lower priority runs first (outbound).
+     * Response interceptors: lower priority runs first (inbound).
+     * Default: 0
+     */
+    priority?: number;
+    /** If true, auto-eject after first successful execution. */
+    once?: boolean;
+    /** Only run if this predicate returns true. */
+    condition?: (ctx: InterceptorContext) => boolean;
+}
+/**
+ * The function that actually sends the HTTP request.
+ * The pipeline calls this once (unless a retry interceptor resets the context).
+ */
+export type Dispatcher = (req: InterceptorRequest) => Promise<InterceptorResponse>;
+/**
+ * Manages registration, ejection, and pipeline execution of interceptors.
+ *
+ * Interceptors are executed in priority order (lowest first) through three
+ * phases: request (outbound), response (inbound), and error (recovery).
+ */
+export declare class InterceptorManager {
+    private requestInterceptors;
+    private responseInterceptors;
+    private errorInterceptors;
+    /**
+     * Register a request interceptor.
+     *
+     * @param fn   - Interceptor function
+     * @param opts - Registration options (id, priority, once, condition)
+     * @returns The interceptor ID (auto-generated or from opts.id)
+     */
+    useRequest(fn: RequestInterceptorFn, opts?: InterceptorOptions): string;
+    /**
+     * Register a response interceptor.
+     *
+     * @param fn   - Interceptor function
+     * @param opts - Registration options (id, priority, once, condition)
+     * @returns The interceptor ID (auto-generated or from opts.id)
+     */
+    useResponse(fn: ResponseInterceptorFn, opts?: InterceptorOptions): string;
+    /**
+     * Register an error interceptor.
+     *
+     * @param fn   - Interceptor function
+     * @param opts - Registration options (id, priority, once, condition)
+     * @returns The interceptor ID (auto-generated or from opts.id)
+     */
+    useError(fn: ErrorInterceptorFn, opts?: InterceptorOptions): string;
+    /** Register both request and response interceptors together. */
+    use(requestFn: RequestInterceptorFn | null, responseFn: ResponseInterceptorFn | null, opts?: InterceptorOptions): {
+        /** ID of the registered request interceptor, or null */
+        requestId: string | null;
+        /** ID of the registered response interceptor, or null */
+        responseId: string | null;
+    };
+    /**
+     * Eject (remove) an interceptor by ID.
+     *
+     * @param id - The interceptor ID returned from registration
+     * @returns `true` if an interceptor was found and removed
+     */
+    eject(id: string): boolean;
+    /** Remove all registered interceptors. */
+    ejectAll(): void;
+    /** Check if an interceptor with the given ID is registered. */
+    has(id: string): boolean;
+    /** Number of registered request interceptors. */
+    get requestCount(): number;
+    /** Number of registered response interceptors. */
+    get responseCount(): number;
+    /** Number of registered error interceptors. */
+    get errorCount(): number;
+    /**
+     * Execute the full interceptor pipeline for a single request.
+     *
+     * @param request    - Initial request to send
+     * @param dispatcher - The function that performs the actual HTTP fetch
+     * @returns The final response after all interceptors have run
+     */
+    execute(request: InterceptorRequest, dispatcher: Dispatcher): Promise<InterceptorResponse>;
+    /** Internal: run (or re-run on retry) the full pipeline. */
+    _run(ctx: InterceptorContext, dispatcher: Dispatcher): Promise<InterceptorResponse>;
+    private _runResponsePhase;
+    private _runErrorPhase;
+}
+export interface RetryConfig {
+    /** Maximum number of retry attempts (default: 3) */
+    maxRetries: number;
+    /** Base delay in ms for exponential back-off (default: 300) */
+    baseDelayMs: number;
+    /** Maximum delay cap in ms (default: 30_000) */
+    maxDelayMs: number;
+    /** Jitter factor 0–1 (default: 0.3) */
+    jitter: number;
+    /** HTTP status codes that trigger a retry (default: [408,429,500,502,503,504]) */
+    retryStatuses: number[];
+    /** Retry on network errors / aborts (default: true) */
+    retryOnError: boolean;
+    /** Only retry these methods (default: GET, HEAD, PUT, DELETE, OPTIONS, TRACE) */
+    retryMethods: string[];
+    /**
+     * Custom predicate — if provided, overrides retryStatuses + retryOnError.
+     * Return true to retry, false to not retry.
+     */
+    shouldRetry: ((ctx: InterceptorContext) => boolean) | null;
+    /**
+     * Called before each retry with the upcoming delay in ms.
+     * Useful for logging.
+     */
+    onRetry: ((ctx: InterceptorContext, delayMs: number) => void) | null;
+}
+/**
+ * Create a retry interceptor pair (response + error) with exponential back-off,
+ * jitter, and per-status-code configuration.
+ *
+ * @param config - Retry configuration (defaults used for omitted fields)
+ */
+export declare function createRetryInterceptor(config?: Partial<RetryConfig>): {
+    /** Triggers retries for responses with retryable status codes */
+    responseInterceptor: ResponseInterceptorFn;
+    /** Triggers retries when a request fails with a retryable error */
+    errorInterceptor: ErrorInterceptorFn;
+};
+export interface AuthInterceptorConfig {
+    /** Return the current access token. */
+    getToken: () => string | null | Promise<string | null>;
+    /**
+     * Called when a 401 is received. Should refresh and return the new token,
+     * or null/throw to propagate the 401.
+     */
+    refreshToken: (() => Promise<string | null>) | null;
+    /** Header to inject the token into (default: "authorization") */
+    headerName: string;
+    /** Scheme prefix (default: "Bearer ") */
+    scheme: string;
+    /** Status codes that trigger a refresh attempt (default: [401]) */
+    refreshOnStatuses: number[];
+    /** Max concurrent refresh queue size (default: 50) */
+    maxQueue: number;
+    /**
+     * Circuit breaker: minimum delay between failed refresh attempts (default: 30000ms).
+     * If refresh fails, subsequent requests will throw until this delay has passed.
+     */
+    refreshRetryDelay: number;
+}
+/**
+ * Create an auth interceptor pair (request + response) that injects Bearer
+ * tokens and handles 401-driven token refresh with request queueing and
+ * circuit-breaker.
+ *
+ * @param config - Auth configuration (must include `getToken`; `refreshToken`
+ *   and other fields are optional)
+ */
+export declare function createAuthInterceptor(config: Partial<AuthInterceptorConfig> & {
+    getToken: () => string | null | Promise<string | null>;
+}): {
+    /** Injects the current token into outgoing request headers */
+    requestInterceptor: RequestInterceptorFn;
+    /** Handles 401 responses by triggering token refresh and retry */
+    responseInterceptor: ResponseInterceptorFn;
+};
+export interface TimeoutConfig {
+    /** Default timeout in ms. 0 = disabled. */
+    timeoutMs: number;
+    /** Per-method overrides, e.g. { POST: 60_000 } */
+    methodTimeouts: Record<string, number>;
+    /** Error message on timeout */
+    message: string;
+}
+/**
+ * Create a timeout interceptor that aborts requests exceeding the configured
+ * deadline. Cleans up timers in both the response and error phases.
+ *
+ * @param config - Timeout configuration (defaults used for omitted fields)
+ */
+export declare function createTimeoutInterceptor(config?: Partial<TimeoutConfig>): {
+    /** Identifier for this timeout interceptor instance */
+    id: string;
+    /** Attaches an AbortSignal to the request with the configured timeout */
+    requestInterceptor: RequestInterceptorFn;
+    /** Cleans up the timeout timer after a successful response */
+    responseInterceptor: ResponseInterceptorFn;
+    /** Cleans up the timeout timer when an error occurs */
+    errorInterceptor: ErrorInterceptorFn;
+};
+/** Error thrown when a request exceeds the configured timeout. */
+export declare class TimeoutError extends Error {
+    readonly timeoutMs: number;
+    readonly code = "ETIMEDOUT";
+    constructor(message: string, timeoutMs: number);
+}
+/** A single structured log entry emitted by the logging interceptor. */
+export interface LogEntry {
+    /** Phase that triggered the entry */
+    type: "request" | "response" | "error";
+    /** Unix timestamp when the entry was created */
+    timestamp: number;
+    /** Unique request identifier */
+    requestId: string;
+    /** HTTP method */
+    method: string;
+    /** Request URL */
+    url: string;
+    /** HTTP status (null for request/error entries) */
+    status: number | null;
+    /** Elapsed time in ms (null for request entries) */
+    durationMs: number | null;
+    /** Attempt number (1-based) */
+    attempt: number;
+    /** Error message (null for request/response entries) */
+    error: string | null;
+}
+export interface LoggingConfig {
+    /** Called for every log entry. Defaults to console output. */
+    logger: (entry: LogEntry) => void;
+    /** Header names whose values should be redacted in logs. */
+    redactHeaders: string[];
+    /** Log request phase (default: true) */
+    logRequests: boolean;
+    /** Log response phase (default: true) */
+    logResponses: boolean;
+    /** Log error phase (default: true) */
+    logErrors: boolean;
+}
+/**
+ * Create a logging interceptor that emits structured log entries for each
+ * request, response, and error phase. Sensitive headers can be redacted.
+ *
+ * @param config - Logging configuration (defaults used for omitted fields)
+ */
+export declare function createLoggingInterceptor(config?: Partial<LoggingConfig>): {
+    /** Emits a structured log entry when a request is sent */
+    requestInterceptor: RequestInterceptorFn;
+    /** Emits a structured log entry when a response is received */
+    responseInterceptor: ResponseInterceptorFn;
+    /** Emits a structured log entry when an error occurs */
+    errorInterceptor: ErrorInterceptorFn;
+};
+/** A single entry in the cache store. */
+export interface CacheEntry {
+    /** The cached response */
+    response: InterceptorResponse;
+    /** Timestamp when the entry was created */
+    createdAt: number;
+    /** Timestamp when the entry expires (fresh until this point) */
+    expiresAt: number;
+    /** End of the stale-while-revalidate window */
+    staleUntil: number;
+    /** ETag for conditional revalidation */
+    etag: string | null;
+    /** Last-Modified date string for conditional revalidation */
+    lastModified: string | null;
+}
+export interface CacheConfig {
+    /** Maximum number of cached entries (LRU eviction) */
+    maxEntries: number;
+    /** Default TTL in ms when no Cache-Control is present (default: 60_000) */
+    defaultTtlMs: number;
+    /** Only cache these methods (default: ["GET", "HEAD"]) */
+    cacheMethods: string[];
+    /** Custom cache key function */
+    cacheKey: ((req: InterceptorRequest) => string) | null;
+    /** If false, ignore Cache-Control: no-store / no-cache on response */
+    honorCacheControl: boolean;
+}
+/**
+ * Create a cache interceptor with LRU eviction and stale-while-revalidate
+ * support. Only caches GET and HEAD by default.
+ *
+ * @param config - Cache configuration (defaults used for omitted fields)
+ */
+export declare function createCacheInterceptor(config?: Partial<CacheConfig>): {
+    /** Serves cached responses and attaches conditional headers for revalidation */
+    requestInterceptor: RequestInterceptorFn;
+    /** Caches successful responses and handles 304 revalidation */
+    responseInterceptor: ResponseInterceptorFn;
+    /** Direct access to the underlying cache store */
+    store: Map<string, CacheEntry>;
+};
+/**
+ * Create a deduplication interceptor that coalesces concurrent GET/HEAD
+ * requests to the same URL into a single fetch.
+ */
+export declare function createDedupeInterceptor(): {
+    /** Coalesces duplicate in-flight GET/HEAD requests into one */
+    requestInterceptor: RequestInterceptorFn;
+    /** Resolves queued waiters with the shared response */
+    responseInterceptor: ResponseInterceptorFn;
+    /** Rejects queued waiters when the shared request fails */
+    errorInterceptor: ErrorInterceptorFn;
+};
+export interface RateLimitConfig {
+    /** Maximum requests per window */
+    limit: number;
+    /** Window size in ms (default: 1000 = 1 req/s * limit) */
+    windowMs: number;
+    /** If true, queue excess requests instead of rejecting (default: true) */
+    queue: boolean;
+    /** Max queue depth before rejecting (default: 100) */
+    maxQueue: number;
+}
+/**
+ * Create a rate-limit interceptor using a token bucket algorithm.
+ * Excess requests are queued (default) or rejected when the queue is full.
+ *
+ * @param config - Rate-limit configuration (defaults used for omitted fields)
+ */
+export declare function createRateLimitInterceptor(config?: Partial<RateLimitConfig>): RequestInterceptorFn;
+/** Error thrown when the rate limit is exceeded. */
+export declare class RateLimitError extends Error {
+    /** Machine-readable error code identifying this as a rate-limit error */
+    readonly code = "ERATELIMIT";
+    constructor(message: string);
+}
+/** A single HAR (HTTP Archive) entry representing one request/response pair. */
+export interface HAREntry {
+    /** ISO 8601 timestamp of the request start */
+    startedDateTime: string;
+    /** Total round-trip time in ms */
+    time: number;
+    /** Request details */
+    request: {
+        /** HTTP method */
+        method: string;
+        /** Full request URL */
+        url: string;
+        /** HTTP version string (e.g. "HTTP/1.1") */
+        httpVersion: string;
+        /** Request headers as name/value pairs */
+        headers: Array<{
+            name: string;
+            value: string;
+        }>;
+        /** Query string parameters */
+        queryString: Array<{
+            name: string;
+            value: string;
+        }>;
+        /** Request body size in bytes */
+        bodySize: number;
+    };
+    /** Response details */
+    response: {
+        /** HTTP status code */
+        status: number;
+        /** HTTP status text */
+        statusText: string;
+        /** HTTP version string */
+        httpVersion: string;
+        /** Response headers as name/value pairs */
+        headers: Array<{
+            name: string;
+            value: string;
+        }>;
+        /** Response content metadata */
+        content: {
+            /** Content size in bytes */
+            size: number;
+            /** MIME type of the response */
+            mimeType: string;
+            /** Response body text (only for string bodies) */
+            text?: string;
+        };
+        /** Response body size in bytes */
+        bodySize: number;
+        /** Redirect target URL if applicable */
+        redirectURL: string;
+    };
+    /** Request timing breakdown */
+    timings: {
+        /** Time spent sending the request in ms */
+        send: number;
+        /** Time waiting for the response in ms */
+        wait: number;
+        /** Time receiving the response in ms */
+        receive: number;
+    };
+}
+/** A top-level HAR log container (HAR 1.2 format). */
+export interface HARLog {
+    /** HAR format version */
+    version: string;
+    /** Tool that created the log */
+    creator: {
+        name: string;
+        version: string;
+    };
+    /** Array of request/response entries */
+    entries: HAREntry[];
+}
+/**
+ * Create a HAR (HTTP Archive) recording interceptor.
+ * Captures request/response pairs for export as a HAR log.
+ */
+export declare function createHARInterceptor(): {
+    /** Records the start time for HAR entry timing */
+    requestInterceptor: RequestInterceptorFn;
+    /** Captures request/response details into the HAR log */
+    responseInterceptor: ResponseInterceptorFn;
+    /** Returns the recorded HAR log in HAR 1.2 format */
+    getHAR: () => HARLog;
+    /** Clears all recorded HAR entries */
+    clearHAR: () => void;
+};
+/** Snapshot of metrics collected by the metrics interceptor. */
+export interface MetricsSnapshot {
+    /** Total requests processed */
+    totalRequests: number;
+    /** Total errors encountered */
+    totalErrors: number;
+    /** Total retry attempts */
+    totalRetries: number;
+    /** Status code buckets ("2xx", "3xx", "4xx", "5xx") */
+    statusBuckets: Record<string, number>;
+    /** Average request duration in ms */
+    avgDurationMs: number;
+    /** Median request duration in ms */
+    p50DurationMs: number;
+    /** 95th percentile duration in ms */
+    p95DurationMs: number;
+    /** 99th percentile duration in ms */
+    p99DurationMs: number;
+}
+/**
+ * Create a metrics interceptor that tracks request count, error rate, status
+ * code buckets, and duration percentiles.
+ */
+export declare function createMetricsInterceptor(): {
+    /** Records request start time and increments request counter */
+    requestInterceptor: RequestInterceptorFn;
+    /** Records response duration and updates status code buckets */
+    responseInterceptor: ResponseInterceptorFn;
+    /** Increments the error counter on pipeline errors */
+    errorInterceptor: ErrorInterceptorFn;
+    /** Returns a snapshot of accumulated metrics */
+    snapshot: () => MetricsSnapshot;
+    /** Resets all metrics counters to zero */
+    reset: () => void;
+};
+/** @internal Compute byte size of a request/response body. Exported for testing. */
+export declare function computeBodySize(body: BodyInit | string | Uint8Array | null): number;
+/** All interceptor instances returned by {@link createInterceptorSuite}. */
+export interface FullInterceptorSuite {
+    /** The interceptor manager with all built-ins registered. */
+    manager: InterceptorManager;
+    /** Retry interceptor pair. */
+    retry: ReturnType<typeof createRetryInterceptor>;
+    /** Auth interceptor pair (null if not configured). */
+    auth: ReturnType<typeof createAuthInterceptor> | null;
+    /** Timeout interceptor metadata. */
+    timeout: {
+        id: string;
+    };
+    /** Logging interceptor triplet. */
+    logging: ReturnType<typeof createLoggingInterceptor>;
+    /** Cache interceptor with store. */
+    cache: ReturnType<typeof createCacheInterceptor>;
+    /** Deduplication interceptor triplet. */
+    dedupe: ReturnType<typeof createDedupeInterceptor>;
+    /** HAR recording interceptor. */
+    har: ReturnType<typeof createHARInterceptor>;
+    /** Metrics interceptor. */
+    metrics: ReturnType<typeof createMetricsInterceptor>;
+}
+/** Configuration options for {@link createInterceptorSuite}. */
+export interface SuiteConfig {
+    retry?: Partial<RetryConfig>;
+    auth?: Partial<AuthInterceptorConfig> & {
+        getToken: () => string | null | Promise<string | null>;
+    };
+    timeout?: Partial<TimeoutConfig>;
+    logging?: Partial<LoggingConfig>;
+    cache?: Partial<CacheConfig>;
+    rateLimit?: Partial<RateLimitConfig>;
+}
+/**
+ * Create a full interceptor suite with all built-in interceptors registered
+ * at sensible priority levels:
+ *
+ * | Priority | Interceptor      |
+ * |----------|------------------|
+ * | -100     | Timeout          |
+ * | -90      | Rate limit       |
+ * | -80      | Deduplication    |
+ * | -70      | Cache            |
+ * | -50      | Auth             |
+ * |  50      | Retry            |
+ * |  90      | Logging          |
+ * |  95      | HAR              |
+ * | 100      | Metrics          |
+ *
+ * @param config - Configuration for each built-in interceptor
+ */
+export declare function createInterceptorSuite(config?: SuiteConfig): FullInterceptorSuite;
+//# sourceMappingURL=interceptors.d.ts.map