@zudojs/http 0.1.0 → 1.0.0

package/dist/httpClient/httpClient.executor.js

@@ -0,0 +1,168 @@
+/**
+ * HTTP client execution with retry.
+ *
+ * @module httpClient/executor
+ */
+import { HttpClientError, HttpClientTimeoutError } from "./httpClient.error.js";
+import { normalizeClientError } from "./httpClient.errorNormalizer.js";
+import { normalizeRetryOptions, shouldRetryStatus, shouldRetryError, calculateRetryDelay, delay, } from "./httpClient.retry.js";
+import { combineAbortSignals } from "./httpClient.abort.js";
+import { parseResponse } from "./httpClient.response.js";
+export async function executeWithRetry(context, client) {
+    const retry = normalizeRetryOptions(context.config.retry ?? client.defaultRetry);
+    const retries = retry?.retries ?? 0;
+    let attempt = 0;
+    while (true) {
+        try {
+            const response = await executeOnce(context, client);
+            if (retry !== undefined &&
+                attempt < retries &&
+                shouldRetryStatus(response.status, (context.config.method ??
+                    "GET"), retry)) {
+                await delay(calculateRetryDelay(attempt, retry));
+                attempt += 1;
+                continue;
+            }
+            if (!response.ok) {
+                throw new HttpClientError(`HTTP request failed with status ${response.status}.`, {
+                    code: "HTTP_CLIENT_HTTP_ERROR",
+                    status: response.status,
+                    statusText: response.statusText,
+                    url: response.url,
+                    response,
+                    request: response.request,
+                });
+            }
+            return response;
+        }
+        catch (error) {
+            const normalized = normalizeClientError(error, context.request);
+            if (retry !== undefined &&
+                attempt < retries &&
+                shouldRetryError(normalized, (context.config.method ??
+                    "GET"), retry)) {
+                await delay(calculateRetryDelay(attempt, retry));
+                attempt += 1;
+                continue;
+            }
+            throw normalized;
+        }
+    }
+}
+async function executeOnce(context, client) {
+    const timeout = context.config.timeout ?? client.defaultTimeout;
+    let controller;
+    let timeoutId;
+    if (timeout !== undefined) {
+        controller = new AbortController();
+        timeoutId = setTimeout(() => {
+            controller?.abort(new HttpClientTimeoutError(timeout, context.request));
+        }, timeout);
+    }
+    const signal = combineAbortSignals(context.config.signal, controller?.signal);
+    const request = signal === context.request.signal
+        ? context.request
+        : new Request(context.request, { signal });
+    try {
+        const raw = await fetchFollowingRedirects(request, client);
+        const response = await parseResponse(raw, context.config.responseType ?? "auto");
+        return response;
+    }
+    catch (error) {
+        if (error instanceof HttpClientError) {
+            throw error;
+        }
+        throw normalizeClientError(error, request);
+    }
+    finally {
+        if (timeoutId !== undefined) {
+            clearTimeout(timeoutId);
+        }
+    }
+}
+/* -------------------------------------------------------------------------- */
+/* Redirects                                                                  */
+/* -------------------------------------------------------------------------- */
+const REDIRECT_STATUSES = new Set([301, 302, 303, 307, 308]);
+const MAX_REDIRECTS = 20;
+/**
+ * Headers that authenticate the caller and must never be replayed to an
+ * origin the caller did not choose.
+ */
+const CREDENTIAL_HEADERS = [
+    "authorization",
+    "cookie",
+    "proxy-authorization",
+];
+/**
+ * Follows redirects manually so credentials can be dropped on a cross-origin
+ * hop.
+ *
+ * `fetch`'s own `redirect: "follow"` replays every request header — including
+ * `Authorization` — to whatever origin the `Location` header names, so an
+ * open redirect on the target host leaks the caller's bearer token to an
+ * attacker-chosen server. Following the chain here lets those headers be
+ * stripped the moment the origin changes.
+ */
+async function fetchFollowingRedirects(request, client) {
+    if (request.redirect !== "follow") {
+        return client.fetchImpl(request);
+    }
+    const hasBody = request.method !== "GET" && request.method !== "HEAD";
+    /*
+     * Buffer the body once. A Request's body stream is consumed by the first
+     * dispatch, so each hop (and each retry) needs its own copy.
+     */
+    const body = hasBody ? await request.clone().arrayBuffer() : undefined;
+    let current = new Request(request, { redirect: "manual" });
+    for (let hop = 0; hop <= MAX_REDIRECTS; hop += 1) {
+        const response = await client.fetchImpl(current);
+        if (!REDIRECT_STATUSES.has(response.status)) {
+            return response;
+        }
+        const location = response.headers.get("location");
+        if (!location) {
+            return response;
+        }
+        let target;
+        try {
+            target = new URL(location, current.url);
+        }
+        catch {
+            return response;
+        }
+        if (target.protocol !== "http:" && target.protocol !== "https:") {
+            throw new HttpClientError(`Refusing to follow a redirect to a non-HTTP scheme: ${target.protocol}`, { code: "HTTP_CLIENT_UNSAFE_REDIRECT", url: target.toString() });
+        }
+        const headers = new Headers(current.headers);
+        if (target.origin !== new URL(current.url).origin) {
+            for (const name of CREDENTIAL_HEADERS) {
+                headers.delete(name);
+            }
+        }
+        let method = current.method;
+        let nextBody = body;
+        const dropsBody = response.status === 303 ||
+            ((response.status === 301 || response.status === 302) &&
+                method !== "GET" &&
+                method !== "HEAD");
+        if (dropsBody) {
+            method = method === "HEAD" ? "HEAD" : "GET";
+            nextBody = undefined;
+            headers.delete("content-length");
+            headers.delete("content-type");
+        }
+        current = new Request(target.toString(), {
+            method,
+            headers,
+            body: nextBody,
+            signal: current.signal,
+            redirect: "manual",
+            credentials: current.credentials,
+            integrity: current.integrity,
+            referrerPolicy: current.referrerPolicy,
+        });
+    }
+    throw new HttpClientError(`HTTP request exceeded the maximum of ${MAX_REDIRECTS} redirects.`, { code: "HTTP_CLIENT_TOO_MANY_REDIRECTS", url: current.url });
+}
+//# sourceMappingURL=httpClient.executor.js.map

package/dist/httpClient/httpClient.factory.d.ts

@@ -0,0 +1,10 @@
+/**
+ * HTTP client factory functions.
+ *
+ * @module httpClient/factory
+ */
+import type { HttpClientOptions } from "./httpClient.type.js";
+import { HttpClient } from "./httpClient.client.js";
+export declare function createHttpClient(options?: HttpClientOptions): HttpClient;
+export declare function createHttpClientWithBaseUrl(baseUrl: string, options?: Omit<HttpClientOptions, "baseUrl">): HttpClient;
+//# sourceMappingURL=httpClient.factory.d.ts.map

package/dist/httpClient/httpClient.factory.js

@@ -0,0 +1,13 @@
+/**
+ * HTTP client factory functions.
+ *
+ * @module httpClient/factory
+ */
+import { HttpClient } from "./httpClient.client.js";
+export function createHttpClient(options = {}) {
+    return new HttpClient(options);
+}
+export function createHttpClientWithBaseUrl(baseUrl, options = {}) {
+    return new HttpClient({ ...options, baseUrl });
+}
+//# sourceMappingURL=httpClient.factory.js.map

package/dist/httpClient/httpClient.headers.d.ts

@@ -0,0 +1,7 @@
+/**
+ * HTTP client header merging.
+ *
+ * @module httpClient/headers
+ */
+export declare function mergeHeaders(defaults: HeadersInit, overrides?: HeadersInit): Headers;
+//# sourceMappingURL=httpClient.headers.d.ts.map

package/dist/httpClient/httpClient.headers.js

@@ -0,0 +1,16 @@
+/**
+ * HTTP client header merging.
+ *
+ * @module httpClient/headers
+ */
+export function mergeHeaders(defaults, overrides) {
+    const result = new Headers(defaults);
+    if (overrides) {
+        const additional = new Headers(overrides);
+        for (const [key, value] of additional.entries()) {
+            result.set(key, value);
+        }
+    }
+    return result;
+}
+//# sourceMappingURL=httpClient.headers.js.map

package/dist/httpClient/httpClient.helpers.d.ts

@@ -0,0 +1,18 @@
+/**
+ * HTTP client helper utilities.
+ *
+ * @module httpClient/helpers
+ */
+import type { HttpClientResponse } from "./httpClient.type.js";
+export declare function normalizeMethod(method: string): string;
+export declare function normalizeBaseUrl(baseUrl?: string): string | undefined;
+export declare function validateTimeout(timeout?: number): number | undefined;
+export declare function getDefaultBaseUrl(): string;
+export declare function isAbsoluteUrl(value: string): boolean;
+export declare function removeInterceptor<T>(list: T[], interceptor: T): void;
+export declare function isHttpClientResponse(value: unknown): value is HttpClientResponse;
+export declare class HttpClientResponseMarker {
+    readonly value: HttpClientResponse;
+    constructor(value: HttpClientResponse);
+}
+//# sourceMappingURL=httpClient.helpers.d.ts.map

package/dist/httpClient/httpClient.helpers.js

@@ -0,0 +1,59 @@
+/**
+ * HTTP client helper utilities.
+ *
+ * @module httpClient/helpers
+ */
+export function normalizeMethod(method) {
+    return method.toUpperCase();
+}
+export function normalizeBaseUrl(baseUrl) {
+    if (!baseUrl) {
+        return undefined;
+    }
+    return baseUrl.endsWith("/") ? baseUrl : `${baseUrl}/`;
+}
+export function validateTimeout(timeout) {
+    if (timeout === undefined) {
+        return undefined;
+    }
+    if (!Number.isFinite(timeout) || timeout < 0) {
+        throw new RangeError("HTTP client timeout must be a non-negative finite number.");
+    }
+    return timeout;
+}
+export function getDefaultBaseUrl() {
+    if (typeof globalThis.location !== "undefined") {
+        return globalThis.location.href;
+    }
+    throw new Error("A base URL is required when using relative URLs outside a browser environment.");
+}
+export function isAbsoluteUrl(value) {
+    try {
+        new URL(value);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export function removeInterceptor(list, interceptor) {
+    const index = list.indexOf(interceptor);
+    if (index >= 0) {
+        list.splice(index, 1);
+    }
+}
+export function isHttpClientResponse(value) {
+    return (value !== null &&
+        typeof value === "object" &&
+        "status" in value &&
+        "data" in value &&
+        "raw" in value);
+}
+/* Error Interceptor Response Marker */
+export class HttpClientResponseMarker {
+    value;
+    constructor(value) {
+        this.value = value;
+    }
+}
+//# sourceMappingURL=httpClient.helpers.js.map

package/dist/httpClient/httpClient.interceptors.d.ts

@@ -0,0 +1,10 @@
+/**
+ * HTTP client interceptor management.
+ *
+ * @module httpClient/interceptors
+ */
+import type { HttpRequestInterceptor, HttpResponseInterceptor, HttpErrorInterceptor } from "./httpClient.type.js";
+export declare function addRequestInterceptor(list: HttpRequestInterceptor[], interceptor: HttpRequestInterceptor): () => void;
+export declare function addResponseInterceptor(list: HttpResponseInterceptor[], interceptor: HttpResponseInterceptor): () => void;
+export declare function addErrorInterceptor(list: HttpErrorInterceptor[], interceptor: HttpErrorInterceptor): () => void;
+//# sourceMappingURL=httpClient.interceptors.d.ts.map

package/dist/httpClient/httpClient.interceptors.js

@@ -0,0 +1,25 @@
+/**
+ * HTTP client interceptor management.
+ *
+ * @module httpClient/interceptors
+ */
+import { removeInterceptor } from "./httpClient.helpers.js";
+export function addRequestInterceptor(list, interceptor) {
+    list.push(interceptor);
+    return () => {
+        removeInterceptor(list, interceptor);
+    };
+}
+export function addResponseInterceptor(list, interceptor) {
+    list.push(interceptor);
+    return () => {
+        removeInterceptor(list, interceptor);
+    };
+}
+export function addErrorInterceptor(list, interceptor) {
+    list.push(interceptor);
+    return () => {
+        removeInterceptor(list, interceptor);
+    };
+}
+//# sourceMappingURL=httpClient.interceptors.js.map

package/dist/httpClient/httpClient.methods.d.ts

@@ -0,0 +1,15 @@
+/**
+ * HTTP client convenience methods (get, post, put, patch, delete, head, options).
+ *
+ * @module httpClient/methods
+ */
+import type { HttpClientBody, HttpClientRequestConfig, HttpClientResponse } from "./httpClient.type.js";
+import type { HttpClient } from "./httpClient.client.js";
+export declare function httpGet<T = unknown>(client: HttpClient, url: string | URL, config?: Omit<HttpClientRequestConfig, "method" | "body">): Promise<HttpClientResponse<T>>;
+export declare function httpPost<T = unknown>(client: HttpClient, url: string | URL, body?: HttpClientBody, config?: Omit<HttpClientRequestConfig, "method" | "body">): Promise<HttpClientResponse<T>>;
+export declare function httpPut<T = unknown>(client: HttpClient, url: string | URL, body?: HttpClientBody, config?: Omit<HttpClientRequestConfig, "method" | "body">): Promise<HttpClientResponse<T>>;
+export declare function httpPatch<T = unknown>(client: HttpClient, url: string | URL, body?: HttpClientBody, config?: Omit<HttpClientRequestConfig, "method" | "body">): Promise<HttpClientResponse<T>>;
+export declare function httpDelete<T = unknown>(client: HttpClient, url: string | URL, config?: Omit<HttpClientRequestConfig, "method">): Promise<HttpClientResponse<T>>;
+export declare function httpHead<T = unknown>(client: HttpClient, url: string | URL, config?: Omit<HttpClientRequestConfig, "method" | "body">): Promise<HttpClientResponse<T>>;
+export declare function httpOptions<T = unknown>(client: HttpClient, url: string | URL, config?: Omit<HttpClientRequestConfig, "method" | "body">): Promise<HttpClientResponse<T>>;
+//# sourceMappingURL=httpClient.methods.d.ts.map

package/dist/httpClient/httpClient.methods.js

@@ -0,0 +1,27 @@
+/**
+ * HTTP client convenience methods (get, post, put, patch, delete, head, options).
+ *
+ * @module httpClient/methods
+ */
+export function httpGet(client, url, config = {}) {
+    return client.request(url, { ...config, method: "GET" });
+}
+export function httpPost(client, url, body, config = {}) {
+    return client.request(url, { ...config, method: "POST", body });
+}
+export function httpPut(client, url, body, config = {}) {
+    return client.request(url, { ...config, method: "PUT", body });
+}
+export function httpPatch(client, url, body, config = {}) {
+    return client.request(url, { ...config, method: "PATCH", body });
+}
+export function httpDelete(client, url, config = {}) {
+    return client.request(url, { ...config, method: "DELETE" });
+}
+export function httpHead(client, url, config = {}) {
+    return client.request(url, { ...config, method: "HEAD" });
+}
+export function httpOptions(client, url, config = {}) {
+    return client.request(url, { ...config, method: "OPTIONS" });
+}
+//# sourceMappingURL=httpClient.methods.js.map

package/dist/httpClient/httpClient.response.d.ts

@@ -0,0 +1,8 @@
+/**
+ * HTTP client response parsing.
+ *
+ * @module httpClient/response
+ */
+import type { HttpResponseType, HttpClientResponse } from "./httpClient.type.js";
+export declare function parseResponse(response: Response, responseType?: HttpResponseType): Promise<HttpClientResponse>;
+//# sourceMappingURL=httpClient.response.d.ts.map

package/dist/httpClient/httpClient.response.js

@@ -0,0 +1,78 @@
+/**
+ * HTTP client response parsing.
+ *
+ * @module httpClient/response
+ */
+import { HttpClientError } from "./httpClient.error.js";
+import { getDefaultBaseUrl } from "./httpClient.helpers.js";
+export async function parseResponse(response, responseType = "auto") {
+    const type = resolveResponseType(response, responseType);
+    let data;
+    switch (type) {
+        case "json":
+            data = await parseJsonResponse(response);
+            break;
+        case "text":
+            data = await response.text();
+            break;
+        case "arrayBuffer":
+            data = await response.arrayBuffer();
+            break;
+        case "blob":
+            data = await response.blob();
+            break;
+        case "response":
+            data = response;
+            break;
+        default:
+            data = await response.text();
+    }
+    return {
+        data,
+        status: response.status,
+        statusText: response.statusText,
+        headers: response.headers,
+        url: response.url,
+        request: createRequestFromResponse(response),
+        raw: response,
+        ok: response.ok,
+    };
+}
+async function parseJsonResponse(response) {
+    const text = await response.text();
+    if (text.trim() === "") {
+        return undefined;
+    }
+    try {
+        return JSON.parse(text);
+    }
+    catch (error) {
+        throw new HttpClientError("Failed to parse HTTP response as JSON.", {
+            code: "HTTP_CLIENT_INVALID_JSON",
+            status: response.status,
+            statusText: response.statusText,
+            url: response.url,
+            cause: error,
+        });
+    }
+}
+function resolveResponseType(response, requested) {
+    if (requested !== "auto") {
+        return requested;
+    }
+    const contentType = response.headers.get("content-type") ?? "";
+    if (contentType.toLowerCase().includes("application/json") ||
+        contentType.toLowerCase().includes("+json")) {
+        return "json";
+    }
+    if (contentType.toLowerCase().startsWith("text/")) {
+        return "text";
+    }
+    return "response";
+}
+function createRequestFromResponse(response) {
+    return new Request(response.url || getDefaultBaseUrl(), {
+        method: "GET",
+    });
+}
+//# sourceMappingURL=httpClient.response.js.map

package/dist/httpClient/httpClient.retry.d.ts

@@ -26,7 +26,7 @@ export declare function shouldRetryStatus(status: number, method: string, retry?
 /**
  * Check if an error should trigger a retry.
  */
-export declare function shouldRetryError(error: unknown, _method: string, retry?: HttpRetryOptions): boolean;
+export declare function shouldRetryError(error: unknown, method: string, retry?: HttpRetryOptions): boolean;
 /**
  * Calculate retry delay with exponential backoff.
  */

package/dist/httpClient/httpClient.retry.js

@@ -33,13 +33,42 @@ export function shouldRetryStatus(status, method, retry) {
 /**
  * Check if an error should trigger a retry.
  */
-export function shouldRetryError(error, _method, retry) {
+export function shouldRetryError(error, method, retry) {
     if (!retry?.retries)
         return false;
     if (!retry.retryOnNetworkError)
         return false;
-    const name = error instanceof Error ? error.constructor.name : "";
-    return name === "TypeError" || name === "FetchError";
+    /*
+     * A connection that drops after the server processed the request is
+     * indistinguishable from one that never arrived, so replaying a
+     * non-idempotent method duplicates its side effects. `retryMethods` exists
+     * for exactly this and was honoured only on the status path.
+     */
+    if (!retry.retryMethods?.includes(method))
+        return false;
+    return isRetryableNetworkError(error);
+}
+/**
+ * Narrows "is this a transport failure?" to errors that really are one.
+ *
+ * A bare `instanceof TypeError` also catches a body that has already been
+ * consumed and parse failures, which are permanent and were being retried
+ * until the budget ran out.
+ */
+function isRetryableNetworkError(error) {
+    if (!(error instanceof Error)) {
+        return false;
+    }
+    if (error.constructor.name === "FetchError") {
+        return true;
+    }
+    if (error.name === "HttpClientNetworkError") {
+        return true;
+    }
+    if (!(error instanceof TypeError)) {
+        return false;
+    }
+    return !/body|disturbed|already (been )?(used|read)/i.test(error.message);
 }
 /**
  * Calculate retry delay with exponential backoff.
@@ -47,10 +76,10 @@ export function shouldRetryError(error, _method, retry) {
 export function calculateRetryDelay(attempt, retry) {
     const base = retry.retryDelay ?? 1000;
     const max = retry.maxRetryDelay ?? 30_000;
-    const ms = retry.backoff === "fixed"
-        ? base
-        : Math.min(base * Math.pow(2, attempt), max);
-    return ms + Math.random() * 1000;
+    const ms = retry.backoff === "fixed" ? base : base * Math.pow(2, attempt);
+    /* Clamp *after* jitter, and on the fixed branch too, or `maxRetryDelay`
+     * is not actually a maximum. */
+    return Math.min(ms + Math.random() * 1000, max);
 }
 /**
  * Delay for a given number of milliseconds.

package/dist/httpClient/httpClient.type.d.ts

@@ -0,0 +1,88 @@
+/**
+ * HTTP client core type definitions.
+ *
+ * @module httpClient/types
+ */
+export type HttpClientMethod = "GET" | "POST" | "PUT" | "PATCH" | "DELETE" | "HEAD" | "OPTIONS" | "TRACE";
+export type HttpClientBody = BodyInit | Record<string, unknown> | readonly unknown[] | null | undefined;
+export type HttpClientQueryValue = string | number | boolean | bigint | null | undefined | readonly (string | number | boolean | bigint)[];
+export type HttpClientQuery = Readonly<Record<string, HttpClientQueryValue>> | URLSearchParams;
+export type HttpResponseType = "auto" | "json" | "text" | "arrayBuffer" | "blob" | "response";
+export interface HttpRetryOptions {
+    readonly retries?: number;
+    readonly retryDelay?: number;
+    readonly maxRetryDelay?: number;
+    readonly retryStatusCodes?: readonly number[];
+    readonly retryMethods?: readonly HttpClientMethod[];
+    readonly retryOnNetworkError?: boolean;
+    readonly backoff?: "fixed" | "exponential";
+}
+export interface HttpClientResponse<T = unknown> {
+    readonly data: T;
+    readonly status: number;
+    readonly statusText: string;
+    readonly headers: Headers;
+    readonly url: string;
+    readonly request: Request;
+    readonly raw: Response;
+    readonly ok: boolean;
+}
+export interface HttpClientRequestConfig {
+    readonly method?: HttpClientMethod;
+    readonly headers?: HeadersInit;
+    readonly query?: HttpClientQuery;
+    readonly body?: HttpClientBody;
+    readonly responseType?: HttpResponseType;
+    readonly timeout?: number;
+    readonly signal?: AbortSignal;
+    readonly credentials?: RequestCredentials;
+    readonly mode?: RequestMode;
+    readonly cache?: RequestCache;
+    readonly redirect?: RequestRedirect;
+    readonly referrer?: string;
+    readonly referrerPolicy?: ReferrerPolicy;
+    readonly integrity?: string;
+    readonly keepalive?: boolean;
+    readonly retry?: HttpRetryOptions;
+    readonly metadata?: Readonly<Record<string, unknown>>;
+}
+export interface HttpClientOptions {
+    readonly baseUrl?: string;
+    readonly headers?: HeadersInit;
+    readonly timeout?: number;
+    readonly credentials?: RequestCredentials;
+    readonly mode?: RequestMode;
+    readonly cache?: RequestCache;
+    readonly redirect?: RequestRedirect;
+    readonly referrer?: string;
+    readonly referrerPolicy?: ReferrerPolicy;
+    readonly integrity?: string;
+    readonly keepalive?: boolean;
+    readonly retry?: HttpRetryOptions;
+    readonly interceptors?: HttpClientInterceptors;
+    readonly fetch?: typeof globalThis.fetch;
+}
+export interface HttpClientRequestContext {
+    readonly url: string;
+    readonly config: HttpClientRequestConfig;
+    readonly request: Request;
+}
+export interface HttpClientErrorDetails {
+    readonly status?: number;
+    readonly statusText?: string;
+    readonly url?: string;
+    readonly response?: HttpClientResponse;
+    readonly request?: Request;
+    readonly cause?: unknown;
+    readonly code?: string;
+}
+export interface HttpClientInterceptors {
+    readonly request?: HttpRequestInterceptor[];
+    readonly response?: HttpResponseInterceptor[];
+    readonly error?: HttpErrorInterceptor[];
+}
+export type HttpRequestInterceptor = (context: HttpClientRequestContext) => HttpClientRequestContext | Promise<HttpClientRequestContext>;
+export type HttpResponseInterceptor = <T>(response: HttpClientResponse<T>) => HttpClientResponse<T> | Promise<HttpClientResponse<T>>;
+import type { HttpClientError } from "./httpClient.error.js";
+export type HttpErrorInterceptor = (error: HttpClientError) => HttpClientError | Promise<HttpClientResponse | never>;
+//# sourceMappingURL=httpClient.type.d.ts.map

package/dist/httpClient/httpClient.type.js

@@ -0,0 +1,7 @@
+/**
+ * HTTP client core type definitions.
+ *
+ * @module httpClient/types
+ */
+export {};
+//# sourceMappingURL=httpClient.type.js.map

package/dist/httpClient/httpClient.typeGuards.d.ts

@@ -0,0 +1,14 @@
+/**
+ * HTTP client type guards.
+ *
+ * @module httpClient/typeGuards
+ */
+import { HttpClientError, HttpClientTimeoutError, HttpClientAbortError, HttpClientNetworkError } from "./httpClient.error.js";
+import type { HttpClientResponse } from "./httpClient.type.js";
+import { HttpClientResponseMarker } from "./httpClient.helpers.js";
+export declare function isHttpClientError(value: unknown): value is HttpClientError;
+export declare function isHttpClientTimeoutError(value: unknown): value is HttpClientTimeoutError;
+export declare function isHttpClientAbortError(value: unknown): value is HttpClientAbortError;
+export declare function isHttpClientNetworkError(value: unknown): value is HttpClientNetworkError;
+export declare function createResponseInterceptorResult(response: HttpClientResponse): HttpClientResponseMarker;
+//# sourceMappingURL=httpClient.typeGuards.d.ts.map