@dcc-bs/communication.bs.js 0.0.5 → 0.1.0

package/dist/communication.bs.d.ts

@@ -2,6 +2,25 @@ import { default as default_2 } from 'zod';
 import { z } from 'zod';
 import { ZodType } from 'zod';
 
+/**
+ * Hook that runs after a response is received.
+ * Can be used to transform the response, log, or handle specific status codes.
+ *
+ * @param response - The Response object received from fetch
+ * @returns The original or a modified Response object
+ *
+ * @example
+ * const afterResponse: AfterResponseHook = async (response) => {
+ *   console.log(`Response status: ${response.status}`);
+ *   if (response.status === 401) {
+ *     // Handle unauthorized
+ *     await refreshToken();
+ *   }
+ *   return response;
+ * };
+ */
+export declare type AfterResponseHook = (response: Response) => Promise<Response> | Response;
+
 export declare class ApiError extends Error {
     $type: "ApiError";
     errorId: ErrorId;
@@ -37,8 +56,516 @@ declare type ApiResponse<T> = T | ApiError;
 
 export declare function apiStreamFetch(url: string, options?: ApiFetchOptions): Promise<ApiResponse<ReadableStream<Uint8Array>>>;
 
+/**
+ * Authentication configuration for the fetcher.
+ * Supports Bearer token and Basic authentication methods.
+ *
+ * @example Bearer Authentication
+ * const authConfig: AuthConfig = {
+ *   type: "bearer",
+ *   token: "your-api-token-here"
+ * };
+ *
+ * @example Basic Authentication
+ * const authConfig: AuthConfig = {
+ *   type: "basic",
+ *   username: "user",
+ *   password: "pass"
+ * };
+ */
+export declare type AuthConfig = BearerAuthConfig | BasicAuthConfig;
+
+declare type BasicAuthConfig = {
+    type: "basic";
+    username: string;
+    password: string;
+};
+
+declare type BearerAuthConfig = {
+    type: "bearer";
+    token: string;
+};
+
+/**
+ * Hook that runs before each request is sent.
+ * Can be used to modify the request, log, or perform authentication checks.
+ *
+ * @param url - The full URL that will be fetched
+ * @param options - The RequestInit options that will be passed to fetch
+ *
+ * @example
+ * const beforeRequest: BeforeRequestHook = async (url, options) => {
+ *   console.log(`Requesting: ${url}`);
+ *   // Add dynamic token
+ *   options.headers = { ...options.headers, 'X-Token': await getToken() };
+ * };
+ */
+export declare type BeforeRequestHook = (url: string, options: RequestInit) => Promise<void> | void;
+
+/**
+ * Creates a builder for configuring and creating a customized fetcher.
+ * The builder allows you to chain configuration methods and then build a fetcher
+ * with all the specified options applied.
+ *
+ * @param options - Initial configuration options for the fetcher
+ * @returns A builder object with methods to configure the fetcher
+ *
+ * @example
+ * const fetcher = createFetcherBuilder()
+ *   .setBaseURL("https://api.example.com")
+ *   .addHeader("Authorization", "Bearer token")
+ *   .setRequestTimeout(5000)
+ *   .enableDebug()
+ *   .build();
+ *
+ * // Use the fetcher
+ * const response = await fetcher("/users", { method: "GET" });
+ */
+export declare function createFetcherBuilder(options?: FetcherBuilderOptions): {
+    addHeader: (key: string, value: string) => {
+        addHeader: /*elided*/ any;
+        addHeaders: (headers: Record<string, string>) => /*elided*/ any;
+        setBaseURL: (baseURL: string) => /*elided*/ any;
+        setRequestTimeout: (timeout: number) => /*elided*/ any;
+        setRetries: (retries: number, retryDelay?: number, retryOn?: number[]) => /*elided*/ any;
+        setAuth: (config: AuthConfig) => /*elided*/ any;
+        setBeforeRequest: (beforeRequest: BeforeRequestHook) => /*elided*/ any;
+        setAfterResponse: (afterResponse: AfterResponseHook) => /*elided*/ any;
+        setOnError: (onError: OnErrorHook) => /*elided*/ any;
+        setQueryParams: (queryParams: Record<string, string | number | boolean>) => /*elided*/ any;
+        setCredentials: (credentials: "include" | "omit" | "same-origin") => /*elided*/ any;
+        setMode: (mode: "cors" | "no-cors" | "same-origin" | "navigate") => /*elided*/ any;
+        setCache: (cache: "default" | "no-store" | "reload" | "no-cache" | "force-cache" | "only-if-cached") => /*elided*/ any;
+        enableDebug: (isEnabled?: boolean) => /*elided*/ any;
+        enableDeduplication: () => /*elided*/ any;
+        build: () => Fetcher;
+    };
+    addHeaders: (headers: Record<string, string>) => {
+        addHeader: (key: string, value: string) => /*elided*/ any;
+        addHeaders: /*elided*/ any;
+        setBaseURL: (baseURL: string) => /*elided*/ any;
+        setRequestTimeout: (timeout: number) => /*elided*/ any;
+        setRetries: (retries: number, retryDelay?: number, retryOn?: number[]) => /*elided*/ any;
+        setAuth: (config: AuthConfig) => /*elided*/ any;
+        setBeforeRequest: (beforeRequest: BeforeRequestHook) => /*elided*/ any;
+        setAfterResponse: (afterResponse: AfterResponseHook) => /*elided*/ any;
+        setOnError: (onError: OnErrorHook) => /*elided*/ any;
+        setQueryParams: (queryParams: Record<string, string | number | boolean>) => /*elided*/ any;
+        setCredentials: (credentials: "include" | "omit" | "same-origin") => /*elided*/ any;
+        setMode: (mode: "cors" | "no-cors" | "same-origin" | "navigate") => /*elided*/ any;
+        setCache: (cache: "default" | "no-store" | "reload" | "no-cache" | "force-cache" | "only-if-cached") => /*elided*/ any;
+        enableDebug: (isEnabled?: boolean) => /*elided*/ any;
+        enableDeduplication: () => /*elided*/ any;
+        build: () => Fetcher;
+    };
+    setBaseURL: (baseURL: string) => {
+        addHeader: (key: string, value: string) => /*elided*/ any;
+        addHeaders: (headers: Record<string, string>) => /*elided*/ any;
+        setBaseURL: /*elided*/ any;
+        setRequestTimeout: (timeout: number) => /*elided*/ any;
+        setRetries: (retries: number, retryDelay?: number, retryOn?: number[]) => /*elided*/ any;
+        setAuth: (config: AuthConfig) => /*elided*/ any;
+        setBeforeRequest: (beforeRequest: BeforeRequestHook) => /*elided*/ any;
+        setAfterResponse: (afterResponse: AfterResponseHook) => /*elided*/ any;
+        setOnError: (onError: OnErrorHook) => /*elided*/ any;
+        setQueryParams: (queryParams: Record<string, string | number | boolean>) => /*elided*/ any;
+        setCredentials: (credentials: "include" | "omit" | "same-origin") => /*elided*/ any;
+        setMode: (mode: "cors" | "no-cors" | "same-origin" | "navigate") => /*elided*/ any;
+        setCache: (cache: "default" | "no-store" | "reload" | "no-cache" | "force-cache" | "only-if-cached") => /*elided*/ any;
+        enableDebug: (isEnabled?: boolean) => /*elided*/ any;
+        enableDeduplication: () => /*elided*/ any;
+        build: () => Fetcher;
+    };
+    setRequestTimeout: (timeout: number) => {
+        addHeader: (key: string, value: string) => /*elided*/ any;
+        addHeaders: (headers: Record<string, string>) => /*elided*/ any;
+        setBaseURL: (baseURL: string) => /*elided*/ any;
+        setRequestTimeout: /*elided*/ any;
+        setRetries: (retries: number, retryDelay?: number, retryOn?: number[]) => /*elided*/ any;
+        setAuth: (config: AuthConfig) => /*elided*/ any;
+        setBeforeRequest: (beforeRequest: BeforeRequestHook) => /*elided*/ any;
+        setAfterResponse: (afterResponse: AfterResponseHook) => /*elided*/ any;
+        setOnError: (onError: OnErrorHook) => /*elided*/ any;
+        setQueryParams: (queryParams: Record<string, string | number | boolean>) => /*elided*/ any;
+        setCredentials: (credentials: "include" | "omit" | "same-origin") => /*elided*/ any;
+        setMode: (mode: "cors" | "no-cors" | "same-origin" | "navigate") => /*elided*/ any;
+        setCache: (cache: "default" | "no-store" | "reload" | "no-cache" | "force-cache" | "only-if-cached") => /*elided*/ any;
+        enableDebug: (isEnabled?: boolean) => /*elided*/ any;
+        enableDeduplication: () => /*elided*/ any;
+        build: () => Fetcher;
+    };
+    setRetries: (retries: number, retryDelay?: number, retryOn?: number[]) => {
+        addHeader: (key: string, value: string) => /*elided*/ any;
+        addHeaders: (headers: Record<string, string>) => /*elided*/ any;
+        setBaseURL: (baseURL: string) => /*elided*/ any;
+        setRequestTimeout: (timeout: number) => /*elided*/ any;
+        setRetries: /*elided*/ any;
+        setAuth: (config: AuthConfig) => /*elided*/ any;
+        setBeforeRequest: (beforeRequest: BeforeRequestHook) => /*elided*/ any;
+        setAfterResponse: (afterResponse: AfterResponseHook) => /*elided*/ any;
+        setOnError: (onError: OnErrorHook) => /*elided*/ any;
+        setQueryParams: (queryParams: Record<string, string | number | boolean>) => /*elided*/ any;
+        setCredentials: (credentials: "include" | "omit" | "same-origin") => /*elided*/ any;
+        setMode: (mode: "cors" | "no-cors" | "same-origin" | "navigate") => /*elided*/ any;
+        setCache: (cache: "default" | "no-store" | "reload" | "no-cache" | "force-cache" | "only-if-cached") => /*elided*/ any;
+        enableDebug: (isEnabled?: boolean) => /*elided*/ any;
+        enableDeduplication: () => /*elided*/ any;
+        build: () => Fetcher;
+    };
+    setAuth: (config: AuthConfig) => {
+        addHeader: (key: string, value: string) => /*elided*/ any;
+        addHeaders: (headers: Record<string, string>) => /*elided*/ any;
+        setBaseURL: (baseURL: string) => /*elided*/ any;
+        setRequestTimeout: (timeout: number) => /*elided*/ any;
+        setRetries: (retries: number, retryDelay?: number, retryOn?: number[]) => /*elided*/ any;
+        setAuth: /*elided*/ any;
+        setBeforeRequest: (beforeRequest: BeforeRequestHook) => /*elided*/ any;
+        setAfterResponse: (afterResponse: AfterResponseHook) => /*elided*/ any;
+        setOnError: (onError: OnErrorHook) => /*elided*/ any;
+        setQueryParams: (queryParams: Record<string, string | number | boolean>) => /*elided*/ any;
+        setCredentials: (credentials: "include" | "omit" | "same-origin") => /*elided*/ any;
+        setMode: (mode: "cors" | "no-cors" | "same-origin" | "navigate") => /*elided*/ any;
+        setCache: (cache: "default" | "no-store" | "reload" | "no-cache" | "force-cache" | "only-if-cached") => /*elided*/ any;
+        enableDebug: (isEnabled?: boolean) => /*elided*/ any;
+        enableDeduplication: () => /*elided*/ any;
+        build: () => Fetcher;
+    };
+    setBeforeRequest: (beforeRequest: BeforeRequestHook) => {
+        addHeader: (key: string, value: string) => /*elided*/ any;
+        addHeaders: (headers: Record<string, string>) => /*elided*/ any;
+        setBaseURL: (baseURL: string) => /*elided*/ any;
+        setRequestTimeout: (timeout: number) => /*elided*/ any;
+        setRetries: (retries: number, retryDelay?: number, retryOn?: number[]) => /*elided*/ any;
+        setAuth: (config: AuthConfig) => /*elided*/ any;
+        setBeforeRequest: /*elided*/ any;
+        setAfterResponse: (afterResponse: AfterResponseHook) => /*elided*/ any;
+        setOnError: (onError: OnErrorHook) => /*elided*/ any;
+        setQueryParams: (queryParams: Record<string, string | number | boolean>) => /*elided*/ any;
+        setCredentials: (credentials: "include" | "omit" | "same-origin") => /*elided*/ any;
+        setMode: (mode: "cors" | "no-cors" | "same-origin" | "navigate") => /*elided*/ any;
+        setCache: (cache: "default" | "no-store" | "reload" | "no-cache" | "force-cache" | "only-if-cached") => /*elided*/ any;
+        enableDebug: (isEnabled?: boolean) => /*elided*/ any;
+        enableDeduplication: () => /*elided*/ any;
+        build: () => Fetcher;
+    };
+    setAfterResponse: (afterResponse: AfterResponseHook) => {
+        addHeader: (key: string, value: string) => /*elided*/ any;
+        addHeaders: (headers: Record<string, string>) => /*elided*/ any;
+        setBaseURL: (baseURL: string) => /*elided*/ any;
+        setRequestTimeout: (timeout: number) => /*elided*/ any;
+        setRetries: (retries: number, retryDelay?: number, retryOn?: number[]) => /*elided*/ any;
+        setAuth: (config: AuthConfig) => /*elided*/ any;
+        setBeforeRequest: (beforeRequest: BeforeRequestHook) => /*elided*/ any;
+        setAfterResponse: /*elided*/ any;
+        setOnError: (onError: OnErrorHook) => /*elided*/ any;
+        setQueryParams: (queryParams: Record<string, string | number | boolean>) => /*elided*/ any;
+        setCredentials: (credentials: "include" | "omit" | "same-origin") => /*elided*/ any;
+        setMode: (mode: "cors" | "no-cors" | "same-origin" | "navigate") => /*elided*/ any;
+        setCache: (cache: "default" | "no-store" | "reload" | "no-cache" | "force-cache" | "only-if-cached") => /*elided*/ any;
+        enableDebug: (isEnabled?: boolean) => /*elided*/ any;
+        enableDeduplication: () => /*elided*/ any;
+        build: () => Fetcher;
+    };
+    setOnError: (onError: OnErrorHook) => {
+        addHeader: (key: string, value: string) => /*elided*/ any;
+        addHeaders: (headers: Record<string, string>) => /*elided*/ any;
+        setBaseURL: (baseURL: string) => /*elided*/ any;
+        setRequestTimeout: (timeout: number) => /*elided*/ any;
+        setRetries: (retries: number, retryDelay?: number, retryOn?: number[]) => /*elided*/ any;
+        setAuth: (config: AuthConfig) => /*elided*/ any;
+        setBeforeRequest: (beforeRequest: BeforeRequestHook) => /*elided*/ any;
+        setAfterResponse: (afterResponse: AfterResponseHook) => /*elided*/ any;
+        setOnError: /*elided*/ any;
+        setQueryParams: (queryParams: Record<string, string | number | boolean>) => /*elided*/ any;
+        setCredentials: (credentials: "include" | "omit" | "same-origin") => /*elided*/ any;
+        setMode: (mode: "cors" | "no-cors" | "same-origin" | "navigate") => /*elided*/ any;
+        setCache: (cache: "default" | "no-store" | "reload" | "no-cache" | "force-cache" | "only-if-cached") => /*elided*/ any;
+        enableDebug: (isEnabled?: boolean) => /*elided*/ any;
+        enableDeduplication: () => /*elided*/ any;
+        build: () => Fetcher;
+    };
+    setQueryParams: (queryParams: Record<string, string | number | boolean>) => {
+        addHeader: (key: string, value: string) => /*elided*/ any;
+        addHeaders: (headers: Record<string, string>) => /*elided*/ any;
+        setBaseURL: (baseURL: string) => /*elided*/ any;
+        setRequestTimeout: (timeout: number) => /*elided*/ any;
+        setRetries: (retries: number, retryDelay?: number, retryOn?: number[]) => /*elided*/ any;
+        setAuth: (config: AuthConfig) => /*elided*/ any;
+        setBeforeRequest: (beforeRequest: BeforeRequestHook) => /*elided*/ any;
+        setAfterResponse: (afterResponse: AfterResponseHook) => /*elided*/ any;
+        setOnError: (onError: OnErrorHook) => /*elided*/ any;
+        setQueryParams: /*elided*/ any;
+        setCredentials: (credentials: "include" | "omit" | "same-origin") => /*elided*/ any;
+        setMode: (mode: "cors" | "no-cors" | "same-origin" | "navigate") => /*elided*/ any;
+        setCache: (cache: "default" | "no-store" | "reload" | "no-cache" | "force-cache" | "only-if-cached") => /*elided*/ any;
+        enableDebug: (isEnabled?: boolean) => /*elided*/ any;
+        enableDeduplication: () => /*elided*/ any;
+        build: () => Fetcher;
+    };
+    setCredentials: (credentials: "include" | "omit" | "same-origin") => {
+        addHeader: (key: string, value: string) => /*elided*/ any;
+        addHeaders: (headers: Record<string, string>) => /*elided*/ any;
+        setBaseURL: (baseURL: string) => /*elided*/ any;
+        setRequestTimeout: (timeout: number) => /*elided*/ any;
+        setRetries: (retries: number, retryDelay?: number, retryOn?: number[]) => /*elided*/ any;
+        setAuth: (config: AuthConfig) => /*elided*/ any;
+        setBeforeRequest: (beforeRequest: BeforeRequestHook) => /*elided*/ any;
+        setAfterResponse: (afterResponse: AfterResponseHook) => /*elided*/ any;
+        setOnError: (onError: OnErrorHook) => /*elided*/ any;
+        setQueryParams: (queryParams: Record<string, string | number | boolean>) => /*elided*/ any;
+        setCredentials: /*elided*/ any;
+        setMode: (mode: "cors" | "no-cors" | "same-origin" | "navigate") => /*elided*/ any;
+        setCache: (cache: "default" | "no-store" | "reload" | "no-cache" | "force-cache" | "only-if-cached") => /*elided*/ any;
+        enableDebug: (isEnabled?: boolean) => /*elided*/ any;
+        enableDeduplication: () => /*elided*/ any;
+        build: () => Fetcher;
+    };
+    setMode: (mode: "cors" | "no-cors" | "same-origin" | "navigate") => {
+        addHeader: (key: string, value: string) => /*elided*/ any;
+        addHeaders: (headers: Record<string, string>) => /*elided*/ any;
+        setBaseURL: (baseURL: string) => /*elided*/ any;
+        setRequestTimeout: (timeout: number) => /*elided*/ any;
+        setRetries: (retries: number, retryDelay?: number, retryOn?: number[]) => /*elided*/ any;
+        setAuth: (config: AuthConfig) => /*elided*/ any;
+        setBeforeRequest: (beforeRequest: BeforeRequestHook) => /*elided*/ any;
+        setAfterResponse: (afterResponse: AfterResponseHook) => /*elided*/ any;
+        setOnError: (onError: OnErrorHook) => /*elided*/ any;
+        setQueryParams: (queryParams: Record<string, string | number | boolean>) => /*elided*/ any;
+        setCredentials: (credentials: "include" | "omit" | "same-origin") => /*elided*/ any;
+        setMode: /*elided*/ any;
+        setCache: (cache: "default" | "no-store" | "reload" | "no-cache" | "force-cache" | "only-if-cached") => /*elided*/ any;
+        enableDebug: (isEnabled?: boolean) => /*elided*/ any;
+        enableDeduplication: () => /*elided*/ any;
+        build: () => Fetcher;
+    };
+    setCache: (cache: "default" | "no-store" | "reload" | "no-cache" | "force-cache" | "only-if-cached") => {
+        addHeader: (key: string, value: string) => /*elided*/ any;
+        addHeaders: (headers: Record<string, string>) => /*elided*/ any;
+        setBaseURL: (baseURL: string) => /*elided*/ any;
+        setRequestTimeout: (timeout: number) => /*elided*/ any;
+        setRetries: (retries: number, retryDelay?: number, retryOn?: number[]) => /*elided*/ any;
+        setAuth: (config: AuthConfig) => /*elided*/ any;
+        setBeforeRequest: (beforeRequest: BeforeRequestHook) => /*elided*/ any;
+        setAfterResponse: (afterResponse: AfterResponseHook) => /*elided*/ any;
+        setOnError: (onError: OnErrorHook) => /*elided*/ any;
+        setQueryParams: (queryParams: Record<string, string | number | boolean>) => /*elided*/ any;
+        setCredentials: (credentials: "include" | "omit" | "same-origin") => /*elided*/ any;
+        setMode: (mode: "cors" | "no-cors" | "same-origin" | "navigate") => /*elided*/ any;
+        setCache: /*elided*/ any;
+        enableDebug: (isEnabled?: boolean) => /*elided*/ any;
+        enableDeduplication: () => /*elided*/ any;
+        build: () => Fetcher;
+    };
+    enableDebug: (isEnabled?: boolean) => {
+        addHeader: (key: string, value: string) => /*elided*/ any;
+        addHeaders: (headers: Record<string, string>) => /*elided*/ any;
+        setBaseURL: (baseURL: string) => /*elided*/ any;
+        setRequestTimeout: (timeout: number) => /*elided*/ any;
+        setRetries: (retries: number, retryDelay?: number, retryOn?: number[]) => /*elided*/ any;
+        setAuth: (config: AuthConfig) => /*elided*/ any;
+        setBeforeRequest: (beforeRequest: BeforeRequestHook) => /*elided*/ any;
+        setAfterResponse: (afterResponse: AfterResponseHook) => /*elided*/ any;
+        setOnError: (onError: OnErrorHook) => /*elided*/ any;
+        setQueryParams: (queryParams: Record<string, string | number | boolean>) => /*elided*/ any;
+        setCredentials: (credentials: "include" | "omit" | "same-origin") => /*elided*/ any;
+        setMode: (mode: "cors" | "no-cors" | "same-origin" | "navigate") => /*elided*/ any;
+        setCache: (cache: "default" | "no-store" | "reload" | "no-cache" | "force-cache" | "only-if-cached") => /*elided*/ any;
+        enableDebug: /*elided*/ any;
+        enableDeduplication: () => /*elided*/ any;
+        build: () => Fetcher;
+    };
+    enableDeduplication: () => {
+        addHeader: (key: string, value: string) => /*elided*/ any;
+        addHeaders: (headers: Record<string, string>) => /*elided*/ any;
+        setBaseURL: (baseURL: string) => /*elided*/ any;
+        setRequestTimeout: (timeout: number) => /*elided*/ any;
+        setRetries: (retries: number, retryDelay?: number, retryOn?: number[]) => /*elided*/ any;
+        setAuth: (config: AuthConfig) => /*elided*/ any;
+        setBeforeRequest: (beforeRequest: BeforeRequestHook) => /*elided*/ any;
+        setAfterResponse: (afterResponse: AfterResponseHook) => /*elided*/ any;
+        setOnError: (onError: OnErrorHook) => /*elided*/ any;
+        setQueryParams: (queryParams: Record<string, string | number | boolean>) => /*elided*/ any;
+        setCredentials: (credentials: "include" | "omit" | "same-origin") => /*elided*/ any;
+        setMode: (mode: "cors" | "no-cors" | "same-origin" | "navigate") => /*elided*/ any;
+        setCache: (cache: "default" | "no-store" | "reload" | "no-cache" | "force-cache" | "only-if-cached") => /*elided*/ any;
+        enableDebug: (isEnabled?: boolean) => /*elided*/ any;
+        enableDeduplication: /*elided*/ any;
+        build: () => Fetcher;
+    };
+    build: () => Fetcher;
+};
+
 declare type ErrorId = "unexpected_error" | "fetch_failed" | string;
 
+export declare type Fetcher = (url: string, options: ApiFetchOptions) => Promise<Response>;
+
+/**
+ * Configuration options for the fetcher builder.
+ * These options are applied to every request made by the fetcher.
+ *
+ * @example
+ * const options: FetcherBuilderOptions = {
+ *   headers: { "X-API-Key": "secret" },
+ *   baseURL: "https://api.example.com",
+ *   timeout: 5000,
+ *   retries: 3,
+ *   debug: true
+ * };
+ */
+export declare type FetcherBuilderOptions = {
+    /**
+     * Custom headers to include in every request.
+     * These headers can be overridden on a per-request basis.
+     *
+     * @example
+     * { "X-Custom-Header": "value", "Accept-Language": "en-US" }
+     */
+    headers: Record<string, string>;
+    /**
+     * Base URL to prepend to all request URLs.
+     * Useful for API endpoints that share the same domain.
+     *
+     * @example
+     * "https://api.example.com/v1"
+     */
+    baseURL?: string;
+    /**
+     * Request timeout in milliseconds.
+     * Requests exceeding this duration will be automatically aborted.
+     *
+     * @example
+     * 5000 // 5 seconds
+     */
+    timeout?: number;
+    /**
+     * Number of retry attempts for failed requests.
+     * Only retries on network errors or status codes specified in `retryOn`.
+     *
+     * @default 0
+     * @example
+     * 3 // Retry up to 3 times
+     */
+    retries?: number;
+    /**
+     * Delay in milliseconds between retry attempts.
+     *
+     * @default 1000
+     * @example
+     * 2000 // Wait 2 seconds between retries
+     */
+    retryDelay?: number;
+    /**
+     * HTTP status codes that should trigger a retry.
+     * Only applies when `retries` is set.
+     *
+     * @example
+     * [408, 429, 500, 502, 503, 504] // Retry on timeout and server errors
+     */
+    retryOn?: number[];
+    /**
+     * Hook function that runs before each request.
+     * Can be async and can modify the request parameters.
+     *
+     * @example
+     * async (url, options) => {
+     *   console.log(`Requesting: ${url}`);
+     *   // Add dynamic token
+     *   options.headers = { ...options.headers, 'X-Token': await getToken() };
+     * }
+     */
+    beforeRequest?: BeforeRequestHook;
+    /**
+     * Hook function that runs after receiving a response.
+     * Can transform the response or perform logging.
+     *
+     * @example
+     * async (response) => {
+     *   console.log(`Response status: ${response.status}`);
+     *   return response;
+     * }
+     */
+    afterResponse?: AfterResponseHook;
+    /**
+     * Hook function that runs when an error occurs.
+     * Useful for error logging and monitoring.
+     *
+     * @example
+     * (error) => {
+     *   console.error('Fetch error:', error.message);
+     *   sendToErrorTracking(error);
+     * }
+     */
+    onError?: OnErrorHook;
+    /**
+     * Default query parameters to append to every request URL.
+     * Can be overridden on a per-request basis.
+     *
+     * @example
+     * { api_key: "abc123", format: "json" }
+     */
+    queryParams?: Record<string, string | number | boolean>;
+    /**
+     * Controls whether credentials (cookies, authorization headers) are sent with requests.
+     *
+     * @default "same-origin"
+     * @see https://developer.mozilla.org/en-US/docs/Web/API/Request/credentials
+     */
+    credentials?: "include" | "omit" | "same-origin";
+    /**
+     * Controls the CORS mode for requests.
+     *
+     * @default "cors"
+     * @see https://developer.mozilla.org/en-US/docs/Web/API/Request/mode
+     */
+    mode?: "cors" | "no-cors" | "same-origin" | "navigate";
+    /**
+     * Controls how the request interacts with the browser's HTTP cache.
+     *
+     * @default "default"
+     * @see https://developer.mozilla.org/en-US/docs/Web/API/Request/cache
+     */
+    cache?: "default" | "no-store" | "reload" | "no-cache" | "force-cache" | "only-if-cached";
+    /**
+     * Enable debug logging for all requests and responses.
+     * Logs request details, response status, and errors to the console.
+     *
+     * @default false
+     */
+    debug?: boolean;
+    /**
+     * Enable request deduplication to prevent duplicate in-flight requests.
+     * If the same request is made while a previous one is pending,
+     * the pending request's promise will be reused.
+     *
+     * @default false
+     */
+    dedupeRequests?: boolean;
+    /**
+     * Authentication configuration for the fetcher.
+     * Automatically adds Authorization headers to requests.
+     *
+     * @example
+     * { type: "bearer", token: "your-api-token" }
+     * @example
+     * { type: "basic", username: "user", password: "pass" }
+     */
+    auth?: AuthConfig;
+};
+
 export declare function isApiError(response: unknown): response is ApiError;
 
+/**
+ * Hook that runs when an error occurs during the fetch operation.
+ * Can be used for error logging, monitoring, or custom error handling.
+ *
+ * @param error - The error that occurred during fetch
+ *
+ * @example
+ * const onError: OnErrorHook = (error) => {
+ *   console.error('Fetch error:', error.message);
+ *   sendToErrorTracking(error);
+ * };
+ */
+export declare type OnErrorHook = (error: Error) => void;
+
 export { }