@superutils/fetch 1.4.2 → 1.5.0

package/dist/index.d.cts

@@ -0,0 +1,915 @@
+import * as _superutils_promise from '@superutils/promise';
+import { RetryOptions, RetryIfFunc, TimeoutOptions, IPromisE_Timeout, DeferredAsyncOptions } from '@superutils/promise';
+export { DeferredAsyncOptions, ResolveError, ResolveIgnored, TIMEOUT_FALLBACK, TIMEOUT_MAX, TimeoutPromise } from '@superutils/promise';
+import { ValueOrPromise, DropFirst } from '@superutils/core';
+
+/** Commonly used content types for easier access */
+declare const ContentType: {
+    readonly APPLICATION_JAVASCRIPT: "application/javascript";
+    readonly APPLICATION_JSON: "application/json";
+    readonly APPLICATION_OCTET_STREAM: "application/octet-stream";
+    readonly APPLICATION_PDF: "application/pdf";
+    readonly APPLICATION_X_WWW_FORM_URLENCODED: "application/x-www-form-urlencoded";
+    readonly APPLICATION_XML: "application/xml";
+    readonly APPLICATION_ZIP: "application/zip";
+    readonly AUDIO_MPEG: "audio/mpeg";
+    readonly MULTIPART_FORM_DATA: "multipart/form-data";
+    readonly TEXT_CSS: "text/css";
+    readonly TEXT_HTML: "text/html";
+    readonly TEXT_PLAIN: "text/plain";
+    readonly VIDEO_MP4: "video/mp4";
+};
+declare enum FetchAs {
+    arrayBuffer = "arrayBuffer",
+    blob = "blob",
+    bytes = "bytes",
+    formData = "formData",
+    json = "json",
+    response = "response",
+    text = "text"
+}
+
+/**
+ * Generic definition for interceptor and transformer callbacks used throughout the fetch lifecycle.
+ */
+type Interceptor<T, TArgs extends unknown[]> = (...args: [value: T, ...TArgs]) => ValueOrPromise<void> | ValueOrPromise<T>;
+/**
+ * Fetch error interceptor to be invoked whenever an exception occurs.
+ * This interceptor can also be used as the error transformer by returning {@link FetchError}.
+ *
+ * Note: The error interceptor is only triggered if the request ultimately fails. If retries are enabled (`retry > 0`)
+ * and a subsequent attempt succeeds, this interceptor will not be invoked for the intermediate failures.
+ *
+ * @param	{FetchError}	fetchError custom error that also contain URL, options & response
+ *
+ * @returns returning undefined or not returning anything will not override the error
+ *
+ * @example	intercept fetch errors to log errors
+ * ```typescript
+ * import PromisE from '@superutils/promise'
+ *
+ * // not returning anything or returning undefined will avoid transforming the error.
+ * const logError = fetchErr => console.log(fetchErr)
+ * const result = await PromisE.fetch('https://my.domain.com/api/that/fails', {
+ *     interceptors: {
+ *         error: [logError]
+ *     }
+ * })
+ * ```
+ *
+ * @example	intercept & transform fetch errors
+ * ```typescript
+ * import PromisE from '@superutils/promise'
+ *
+ * // Interceptors can be async functions or just return a promise that resolves to the error.
+ * // If the execution of the interceptor fails or promise rejects, it will be ignored.
+ * // To transform the error it must directly return an error or a Promise that `resolves` with an error.
+ * const transformError = async (fetchErr, url, options) => {
+ *     fetchErr.message = 'Custom errormessage'
+ * 	   return Promise.resolve(fetchErr)
+ * }
+ * const result = await PromisE.fetch('https://my.domain.com/api/that/fails', {
+ *     interceptors: {
+ *         error: [transformError]
+ *     }
+ * })
+ * ```
+ */
+type FetchInterceptorError = Interceptor<FetchError, FetchArgsInterceptor>;
+/**
+ * Fetch request interceptor to be invoked before making a fetch request.
+ * This interceptor can also be used as a transformer:
+ * 1. by returning an API URL (string/URL)
+ * 2. by modifying the properties of the options parameter to be used before making the fetch request
+ *
+ * @example intercept and transform fetch request
+ * ```typescript
+ * import PromisE from '@superutils/promise'
+ *
+ * // update API version number
+ * const apiV1ToV2 = url => `${url}`.replace('api/v1', 'api/v2')
+ * const includeAuthToken = (url, options) => {
+ *     options.headers.set('x-auth-token', 'my-auth-token')
+ * }
+ * const data = await PromisE.fetch('https://my.domain.com/api', {
+ *     interceptors: {
+ *         result: [apiV1ToV2, includeAuthToken]
+ *     }
+ * })
+ * ```
+ */
+type FetchInterceptorRequest = Interceptor<FetchArgs[0], [
+    FetchArgsInterceptor[1]
+]>;
+/**
+ * Fetch response interceptor to be invoked before making a fetch request.
+ *
+ * This interceptor can also be used as a transformer by return a different/modified {@link Response}.
+ *
+ * @example intercept and transform response:
+ * ```typescript
+ * import PromisE from '@superutils/promise'
+ *
+ * // After successful login, retrieve user balance.
+ * // This is probably better suited as a result transformer but play along as this is
+ * // just a hypothetical scenario ;)
+ * const includeBalance = async response => {
+ *     const balance = await PromisE.fetch('https://my.domain.com/api/user/12325345/balance')
+ * 	   const user = await response.json()
+ *     user.balance = balance
+ *     return new Response(JSON.stringify(user))
+ * }
+ * const user = await PromisE.fetch('https://my.domain.com/api/login', {
+ *     interceptors: {
+ *         response: [includeBalance]
+ *     }
+ * })
+ * ```
+ */
+type FetchInterceptorResponse = Interceptor<Response, FetchArgsInterceptor>;
+/**
+ *
+ * Fetch result interceptor to be invoked before returning parsed fetch result.
+ *
+ * Result interceptors are executed ONLY when a result is successfully parsed (as ArrayBuffer, Blob, JSON, Text...).
+ * Result interceptors WILL NOT be executed if:
+ * - return type is set to `Response` by using {@link FetchAs.response} in the {@link FetchOptions.as}
+ * - exceptions is thrown even before attempting to parse
+ * - parse fails
+ *
+ * This interceptor can also be used as a transformer by returns a different/modified result.
+ *
+ *
+ * @example intercept and transform fetch result
+ * ```typescript
+ * import PromisE from '@superutils/promise'
+ *
+ * // first transform result by extracting result.data
+ * const extractData = result => result?.data ?? result
+ * // then check convert hexadecimal number to BigInt
+ * const hexToBigInt = data => {
+ *     if (data.hasOwnProperty('balance') && `${data.balance}`.startsWith('0x')) {
+ *          data.balance = BigInt(data.balance)
+ *     }
+ *     return data
+ * }
+ * // then log balance (no transformation)
+ * const logBalance = data => {
+ *     data?.hasOwnProperty('balance') && console.log(data.balance)
+ * }
+ * const data = await PromisE.fetch('https://my.domain.com/api', {
+ *     interceptors: {
+ *         result: [
+ * 	           extractData,
+ * 	           hexToBigInt,
+ * 	           logBalance
+ * 	       ]
+ *     }
+ * })
+ * ```
+ */
+type FetchInterceptorResult<Args extends unknown[] = FetchArgsInterceptor> = Interceptor<unknown, Args>;
+/**
+ * All valid interceptors for fetch requests are:
+ * ---
+ * 1. error
+ * 2. request
+ * 3. response
+ * 4. result
+ *
+ * An interceptor can be any of the following:
+ * ---
+ * 1. synchronous function
+ * 2. synchronous function that returns a promise (or sometimes returns a promise)
+ * 3. asynchronous functions
+ *
+ * An interceptor can return:
+ * ---
+ * 1. undefined (void/no return): plain interceptor that does other stuff but does not transform
+ * 2. value: act as a transformer. Returned value depends on the type of interceptor.
+ * 3. promise resolves with (1) value or (2) undefined
+ *
+ * PS:
+ * ---
+ * 1. Any exception thrown by interceptors will gracefully ignored.
+ * 2. Interceptors will be executed in the sequence they're given.
+ * 3. Execution priority: global interceptors will always be executed before local interceptors.
+ * 4. The following options cannot be modified using interceptors: abortCtrl, as, signal, timeout
+ *
+ * More info about specific interceptor types & examples:
+ * ---
+ * See the following for more details and examples:
+ *
+ * - `error`: {@link FetchInterceptorError}
+ * - `request`: {@link FetchInterceptorRequest}
+ * - `response`: {@link FetchInterceptorResponse}
+ * - `result`: {@link FetchInterceptorResult}
+ */
+type FetchInterceptors = {
+    /** Request error interceptors/transformers. See {@link FetchInterceptorError} for more details. */
+    error?: FetchInterceptorError | FetchInterceptorError[];
+    /** Request request interceptors/transformers. See {@link FetchInterceptorRequest} for more details. */
+    request?: FetchInterceptorRequest | FetchInterceptorRequest[];
+    /** Request response interceptors/transformers. See {@link FetchInterceptorResponse} for more details. */
+    response?: FetchInterceptorResponse | FetchInterceptorResponse[];
+    /** Request result interceptors/transformers. See {@link FetchInterceptorResult} for more details. */
+    result?: FetchInterceptorResult | FetchInterceptorResult[];
+};
+/** Interceptors after merging should only be array of functions  */
+type FetchInterceptorsMerged = {
+    error: FetchInterceptorError[];
+    request: FetchInterceptorRequest[];
+    response: FetchInterceptorResponse[];
+    result: FetchInterceptorResult[];
+};
+
+/** Exclude properties of `Target` from `Options`. `headers` will always be included */
+type ExcludeOptions<Target, Options extends FetchOptions = FetchOptions> = Target extends FetchOptions ? {
+    headers?: Options['headers'];
+} & Omit<Options, 'headers' | keyof Target> & Partial<Record<Exclude<keyof Target, 'headers'>, never>> : Options;
+/** Exclude properties of `Target` from {@link PostOptions} */
+type ExcludePostOptions<Target> = ExcludeOptions<Target, PostOptions>;
+/** Extract the first macthing `FetchAs` from `T` array. If none matches, use `Fallback` */
+type ExtractAs<T extends unknown[], //FetchOptions/FetchAs/...
+Fallback = FetchAs.json> = T['length'] extends 0 ? Fallback : T[0] extends FetchAs ? T[0] : T[0] extends {
+    as: infer OptAs;
+} ? OptAs extends FetchAs ? OptAs : ExtractAs<DropFirst<T>, Fallback> : ExtractAs<DropFirst<T>, Fallback>;
+type ExtractFetchAs<T, TFallback = FetchAs.json> = T extends FetchAs ? T : T extends {
+    as: infer As;
+} ? As extends FetchAs ? As : TFallback : TFallback;
+type FetchArgs = [url: string | URL, options?: FetchOptions];
+type FetchArgsInterceptor = [
+    url: string | URL,
+    options: FetchOptionsInterceptor
+];
+/** Custom fetch options (not used by built-in `fetch()`*/
+type FetchCustomOptions = {
+    /**
+     * Specify how the parse the result. To get raw response use {@link FetchAs.response}.
+     * Default: 'json'
+     */
+    as?: FetchAs;
+    /**
+     * An `AbortController` instance to control the request.
+     *
+     * If not provided, a new instance is automatically created internally.
+     *
+     * It is supported in addition to the standard `signal`. If both are provided, `abortCtrl` will be aborted
+     * when the `signal` aborts or when the request times out.
+     *
+     * Recommendation:
+     * - For request timeout purposes, setting a timeout duration will be sufficient.
+     * Abort controller/signal is not needed.
+     * - Use `abortCtrl` instead of `signal` to prevent creating internal `AbortController` instance.
+     */
+    abortCtrl?: AbortController;
+    body?: PostBody | (() => PostBody);
+    /**
+     * Custom fetch function to use instead of the global `fetch`.
+     * Useful for testing or using a different fetch implementation (e.g. `node-fetch` in older Node versions).
+     *
+     * Default: `globalThis.fetch`
+     */
+    fetchFunc?: FetchFunc;
+    errMsgs?: FetchErrMsgs;
+    /**
+     * Interceptor/transformer callback executed at different stages of the request.
+     * See {@link FetchInterceptors} for more details.
+     */
+    interceptors?: FetchInterceptors;
+    /** Whether to validate URL before making the request. Default: `true` */
+    validateUrl?: boolean;
+} & FetchRetryOptions & TimeoutOptions<[]>;
+/** Default args */
+type FetchDeferredArgs = [
+    url?: string | URL,
+    options?: Omit<FetchOptions, 'abortCtrl'>
+];
+type FetchErrMsgs = {
+    /** Error message to be used when request is aborted without specifying a message */
+    aborted?: string;
+    /** Error message to be use when URL validation fails */
+    invalidUrl?: string;
+    /** Error message to be used when request parse failes */
+    parseFailed?: string;
+    /** Error message to be used when request times out */
+    timedout?: string;
+    /** Error message to be used when request fails */
+    requestFailed?: string;
+};
+type FetchFunc = (...args: FetchArgs) => Promise<Response>;
+/**
+ * Fetch request options
+ */
+type FetchOptions = Omit<RequestInit, 'body'> & FetchCustomOptions;
+/** Default fetch options */
+type FetchOptionsDefault = Omit<FetchOptionsInterceptor, 'abortCtrl' | 'as' | 'method' | 'signal' | 'timeout'> & {
+    /** Request timeout duration in milliseconds. Default: `30_000` (30 seconds) */
+    timeout: number;
+};
+/**
+ * Fetch options available to interceptors.
+ *
+ */
+type FetchOptionsInterceptor = Omit<FetchOptions, 'as' | 'errMsgs' | 'interceptors' | 'headers' | 'timeout' | keyof FetchRetryOptions> & {
+    as: FetchAs;
+    /** Error messages */
+    errMsgs: Required<FetchErrMsgs>;
+    headers: Headers;
+    /** Interceptors/transformers for fetch requests. See {@link FetchInterceptors} for more details. */
+    interceptors: FetchInterceptorsMerged;
+    timeout: number;
+} & FetchRetryOptions;
+/**
+ * Result types for specific parsers ("as": FetchAs)
+ */
+type FetchResult<T = unknown> = {
+    arrayBuffer: ArrayBuffer;
+    blob: Blob;
+    bytes: Uint8Array<ArrayBuffer>;
+    formData: FormData;
+    json: T;
+    text: string;
+    response: Response;
+};
+type GetFetchResult<As = unknown, T = never> = [T] extends [never] ? FetchResult[As extends unknown[] ? ExtractAs<As> : As extends FetchAs ? As : FetchAs.json] : T;
+/**
+ * Fetch retry options
+ */
+type FetchRetryOptions = Omit<Partial<RetryOptions>, 'retry' | 'retryIf'> & {
+    /**
+     * Maximum number of retries.
+     *
+     * The total number of attempts will be `retry + 1`.
+     *
+     * Default: `0`
+     */
+    retry?: number;
+    retryIf?: RetryIfFunc<Response>;
+};
+type PostBody = Record<string, unknown> | BodyInit | null;
+type PostArgs = [
+    url: string | URL,
+    data?: PostBody | (() => PostBody),
+    options?: PostOptions
+];
+/**
+ * Dynamic arguments for deferred post-like methods.
+ *
+ * @example
+ * ```typescript
+ * import fetch, { type PostDeferredCbArgs } from '@superutils/fetch'
+ *
+ * // test with types
+ * type T1 = PostDeferredCbArgs<string | URL, undefined> // expected: [data, options]
+ * type T2 = PostDeferredCbArgs<undefined, string> // expected: [url, options]
+ * type T3 = PostDeferredCbArgs // expected: [url, data, options]
+ * type T4 = PostDeferredCbArgs<string, string> // expected: [options]
+ *
+ * const data = { name: 'test' }
+ * const url = 'https://domain.com'
+ * // test with fetch.post.deferred()
+ * const f1 = fetch.post.deferred({}, 'https://domain.com')
+ * // expected: [data, options]
+ * f1({data: 1}).then(console.log, console.warn)
+ *
+ * const f2 = fetch.post.deferred({}, undefined, 'dome data')
+ * // expected: [url, options]
+ * f2('https').then(console.log, console.warn)
+ *
+ * const f3 = fetch.post.deferred({})
+ * // expected: [url, data, options]
+ * f3('https://domain.com').then(console.log, console.warn)
+ *
+ * const f4 = fetch.post.deferred({}, 'url', 'data')
+ * // expected: [options]
+ * f4().then(console.log, console.warn)
+ * ```
+ */
+type PostDeferredCbArgs<DefaultUrl = undefined, DefaultData = undefined, Options = PostArgs[2], PostArgsReq extends unknown[] = Required<PostArgs>, _url = undefined extends DefaultUrl ? undefined : DefaultUrl, _data = undefined extends DefaultData ? undefined : DefaultData> = [_url, _data] extends [PostArgsReq[0], undefined] ? [
+    data?: PostArgs[1],
+    options?: PostArgs[2]
+] : [
+    _url,
+    _data
+] extends [undefined, PostArgsReq[1]] ? [url: PostArgs[0], options?: PostArgs[2]] : [
+    _url,
+    _data
+] extends [PostArgsReq[0], PostArgsReq[1]] ? [options?: PostArgs[2]] : [url: PostArgs[0], data?: PostArgs[1], options?: Options];
+/** Request options for POST-like methods that allow "options.body" */
+type PostOptions = {
+    /** Default: `'post'` */
+    method?: 'post' | 'put' | 'patch' | 'delete' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
+} & Omit<FetchOptions, 'method'>;
+
+/** Custom error message for fetch requests with more detailed info about the request URL, fetch options and response */
+declare class FetchError extends Error {
+    /** Create a new `FetchError` with a new `message` while preserving all metadata */
+    clone: (newMessage: string) => FetchError;
+    options: FetchOptions;
+    response: Response | undefined;
+    url: string | URL;
+    constructor(message: string, options: {
+        cause?: unknown;
+        options: FetchOptions;
+        response?: Response;
+        url: string | URL;
+    });
+}
+
+type IPromise_Fetch<T = unknown> = Omit<IPromisE_Timeout<T>, 'abortCtrl'> & {
+    /** An `AbortController` instance to control the request.  */
+    abortCtrl: AbortController;
+};
+
+/**
+ * Defines client generic parameter T based on fixed options.
+ *
+ * If `fixedOptions.as` is defined and not `FetcAs.json`, then `T` will be `never`.
+ */
+type ClientData<FixedOptions> = ExtractAs<[FixedOptions]> extends FetchAs.json ? unknown : never;
+/**
+ * Create a reusable fetch client with shared options. The returned function comes attached with a
+ * `.deferred()` function for debounce and throttle behavior.
+ *
+ * The `createClient` utility streamlines the creation of dedicated API clients by generating pre-configured fetch
+ * functions. These functions can be equipped with default options like headers, timeouts, or a specific HTTP method,
+ * which minimizes code repetition across your application. If a method is not specified during creation, the client
+ * will default to `GET`.
+ *
+ * The returned client also includes a `.deferred()` method, providing the same debounce, throttle, and sequential
+ * execution capabilities found in functions like `fetch.get.deferred()`.
+ *
+ * @example create reusable clients
+ * ```javascript
+ * import { createClient } from '@superutils/fetch'
+ *
+ * // Create a "GET" client with default headers and a 5-second timeout
+ * const apiClient = createClient(
+ * 	{
+ * 		// fixed options cannot be overridden
+ * 		method: 'get',
+ * 	},
+ * 	{
+ * 		// default options can be overridden
+ * 		headers: {
+ * 			Authorization: 'Bearer my-secret-token',
+ * 			'Content-Type': 'application/json',
+ * 		},
+ * 		timeout: 5000,
+ * 	},
+ * 	{
+ * 		// default defer options (can be overridden)
+ * 		delay: 300,
+ * 		retry: 2, // If request fails, retry up to two more times
+ * 	},
+ * )
+ *
+ * // Use it just like the standard fetch
+ * apiClient('https://dummyjson.com/products/1', {
+ * 	// The 'method' property cannot be overridden as it is used in the fixed options when creating the client.
+ * 	// In TypeScript, the compiler will not allow this property.
+ * 	// In Javascript, it will simply be ignored.
+ * 	// method: 'post',
+ * 	timeout: 3000, // The 'timeout' property can be overridden
+ * }).then(console.log, console.warn)
+ *
+ * // create a deferred client using "apiClient"
+ * const deferredClient = apiClient.deferred(
+ * 	{ retry: 0 }, // disable retrying by overriding the `retry` defer option
+ * 	'https://dummyjson.com/products/1',
+ * 	{ timeout: 3000 },
+ * )
+ * deferredClient({ timeout: 10000 }) // timeout is overridden by individual request
+ * 	.then(console.log, console.warn)
+ * ```
+ */
+declare const createClient: <FixedOptions extends FetchOptions | undefined, CommonOptions extends ExcludeOptions<FixedOptions> | undefined, CommonDelay extends number>(
+/** Mandatory fetch options that cannot be overriden by individual request */
+fixedOptions?: FixedOptions, 
+/** Common fetch options that can be overriden by individual request */
+commonOptions?: FetchOptions & CommonOptions, commonDeferOptions?: DeferredAsyncOptions<unknown, CommonDelay>) => {
+    <T extends ClientData<FixedOptions> = never, TOptions extends ExcludeOptions<FixedOptions> | undefined = ExcludeOptions<FixedOptions> | undefined, Result = GetFetchResult<[FixedOptions, TOptions, CommonOptions], T>>(url: FetchArgs[0], options?: TOptions): IPromise_Fetch<Result>;
+    deferred<ThisArg, Delay extends CommonDelay | number, DefaultUrl extends FetchArgs[0] | undefined = string | URL | undefined, DefaultOptions extends ExcludeOptions<FixedOptions> | undefined = ExcludeOptions<FixedOptions> | undefined>(deferOptions?: DeferredAsyncOptions<ThisArg, Delay>, defaultUrl?: DefaultUrl, defaultOptions?: DefaultOptions): <T extends ClientData<FixedOptions> = never, TOptions_1 extends ExcludeOptions<FixedOptions> | undefined = ExcludeOptions<FixedOptions> | undefined, Result_1 = GetFetchResult<[FixedOptions, TOptions_1, DefaultOptions, CommonOptions], T>>(...args: DefaultUrl extends undefined ? [url: FetchArgs[0], options?: TOptions_1] : [options?: TOptions_1]) => IPromise_Fetch<Result_1>;
+};
+
+/**
+ * Create a reusable fetch client with shared options. The returned function comes attached with a
+ * `.deferred()` function for debounced and throttled request.
+ * While `createClient()` is versatile enough for any HTTP method, `createPostClient()` is specifically designed for
+ * methods that require a request body, such as `DELETE`, `PATCH`, `POST`, and `PUT`. If a method is not provided, it
+ * defaults to `POST`. The generated client accepts an additional second parameter (`data`) for the request payload.
+ *
+ * Similar to `createClient`, the returned function comes equipped with a `.deferred()` method, enabling debounced,
+ * throttled, or sequential execution.
+ *
+ * @example create reusable clients
+ * ```javascript
+ * import { createPostClient, FetchAs } from '@superutils/fetch'
+ *
+ * // Create a POST client with 10-second as the default timeout
+ * const postClient = createPostClient(
+ * 	{
+ * 		method: 'post',
+ * 		headers: { 'content-type': 'application/json' },
+ * 	},
+ * 	{ timeout: 10000 },
+ * )
+ *
+ * // Invoking `postClient()` automatically applies the pre-configured options
+ * postClient(
+ * 	'https://dummyjson.com/products/add',
+ * 	{ title: 'New Product' }, // data/body
+ * 	{}, // other options
+ * ).then(console.log)
+ *
+ * // create a deferred client using "postClient"
+ * const updateProduct = postClient.deferred(
+ * 	{
+ * 		delay: 300, // debounce duration
+ * 		onResult: console.log, // prints only successful results
+ * 	},
+ * 	'https://dummyjson.com/products/add',
+ * 	{
+ * 		method: 'patch',
+ * 		timeout: 3000,
+ * 	},
+ * )
+ * updateProduct({ title: 'New title 1' }) // ignored by debounce
+ * updateProduct({ title: 'New title 2' }) // executed
+ * ```
+ */
+declare const createPostClient: <FixedOptions extends PostOptions | undefined, CommonOptions extends ExcludePostOptions<FixedOptions> | undefined, CommonDelay extends number = number>(
+/** Mandatory fetch options that cannot be overriden by individual request */
+fixedOptions?: FixedOptions, 
+/** Common fetch options that can be overriden by individual request */
+commonOptions?: PostOptions & CommonOptions, commonDeferOptions?: DeferredAsyncOptions<unknown, CommonDelay>) => {
+    <T extends ClientData<FixedOptions> = never, Options extends ExcludePostOptions<FixedOptions> | undefined = ExcludePostOptions<FixedOptions> | undefined, Result = GetFetchResult<[FixedOptions, Options, CommonOptions], T>>(url: PostArgs[0], data?: PostArgs[1], options?: Options): IPromise_Fetch<Result>;
+    deferred<ThisArg, DefaultUrl extends PostArgs[0] | undefined, DefaultData extends PostArgs[1] | undefined, DefaultOptions extends ExcludePostOptions<FixedOptions> | undefined = ExcludePostOptions<FixedOptions> | undefined, Delay extends CommonDelay | number = number>(deferOptions?: DeferredAsyncOptions<ThisArg, Delay>, defaultUrl?: DefaultUrl, defaultData?: DefaultData, defaultOptions?: DefaultOptions): <T extends ClientData<FixedOptions> = never, Options_1 extends ExcludePostOptions<FixedOptions> | undefined = ExcludePostOptions<FixedOptions> | undefined, TReturn = GetFetchResult<[FixedOptions, Options_1, DefaultOptions, CommonOptions], T>>(...args: PostDeferredCbArgs<DefaultUrl, DefaultData, Options_1>) => IPromise_Fetch<TReturn>;
+};
+
+/**
+ * Gracefully executes interceptors and returns the processed value.
+ * If the value is not transformed (by returning a new value) by the interceptors,
+ * the original value is returned.
+ *
+ * @param	value value to be passed to the interceptors
+ * @param	signal The AbortController used to monitor the request status. If the signal is aborted (e.g. due to
+ * timeout or manual cancellation), the interceptor chain halts immediately. Note: This does not interrupt the
+ * currently executing interceptor, but prevents subsequent ones from running.
+ * @param	interceptors interceptor/transformer callbacks
+ * @param	args (optional) common arguments to be supplied to all the interceptors in addition to
+ * the `value' which will always be the first argument.
+ *
+ * Interceptor arguments: `[value, ...args]`
+ */
+declare const executeInterceptors: <T, TArgs extends unknown[]>(value: T, signal?: AbortSignal, interceptors?: Interceptor<T, TArgs>[], ...args: TArgs) => Promise<T>;
+
+/**
+ * Extended `fetch` with timeout, retry, and other options. Automatically parses as JSON by default on success.
+ *
+ * @param url request URL
+ * @param options (optional) Standard `fetch` options extended with {@link FetchCustomOptions}.
+ * Default "content-type" header is 'application/json'.
+ * @param options.as (optional) determines how to parse the result. Default: {@link FetchAs.json}
+ * @param options.method (optional) fetch method. Default: `'get'`
+ *
+ * @example Make a simple HTTP requests
+ * ```typescript
+ * import { fetch } from '@superutils/fetch'
+ *
+ * // no need for `response.json()` or `result.data.data` drilling
+ * fetch('https://dummyjson.com/products/1')
+ * 	   .then(product => console.log(product))
+ * ```
+ */
+declare const fetch$1: {
+    <T = unknown, TOptions extends FetchOptions = FetchOptions, TAs extends FetchAs = TOptions["as"] extends FetchAs ? TOptions["as"] : FetchAs.response, TReturn = FetchResult<T>[TAs]>(url: string | URL, options?: FetchOptions & TOptions): IPromise_Fetch<TReturn>;
+    /** Default fetch options */
+    defaults: FetchOptionsDefault;
+};
+
+/**
+ * Merge one or more {@link FetchOptions}
+ *
+ * Notes:
+ * - item properties will be prioritized in the order of sequence they were passed in
+ * - the following properties will be merged
+ *     * `errMsgs`
+ *     * `headers`
+ *     * `interceptors`
+ * - all other properties will simply override previous values
+ *
+ * @returns combined
+ */
+declare const mergeOptions: (...allOptions: (FetchOptions | undefined)[]) => FetchOptionsInterceptor;
+
+declare const methods: {
+    /** Make HTTP requests with method GET */
+    get: {
+        <T extends unknown = never, TOptions extends ({
+            headers?: HeadersInit | undefined;
+        } & Omit<FetchOptions, "headers" | "method"> & Partial<Record<"method", never>>) | undefined = ({
+            headers?: HeadersInit | undefined;
+        } & Omit<FetchOptions, "headers" | "method"> & Partial<Record<"method", never>>) | undefined, Result = GetFetchResult<[{
+            method: string;
+        }, TOptions, ({
+            headers?: HeadersInit | undefined;
+        } & Omit<FetchOptions, "headers" | "method"> & Partial<Record<"method", never>>) | undefined], T>>(url: FetchArgs[0], options?: TOptions | undefined): IPromise_Fetch<Result>;
+        deferred<ThisArg, Delay extends number, DefaultUrl extends FetchArgs[0] | undefined = string | URL | undefined, DefaultOptions extends ({
+            headers?: HeadersInit | undefined;
+        } & Omit<FetchOptions, "headers" | "method"> & Partial<Record<"method", never>>) | undefined = ({
+            headers?: HeadersInit | undefined;
+        } & Omit<FetchOptions, "headers" | "method"> & Partial<Record<"method", never>>) | undefined>(deferOptions?: _superutils_promise.DeferredAsyncOptions<ThisArg, Delay> | undefined, defaultUrl?: DefaultUrl | undefined, defaultOptions?: DefaultOptions | undefined): <T extends unknown = never, TOptions extends ({
+            headers?: HeadersInit | undefined;
+        } & Omit<FetchOptions, "headers" | "method"> & Partial<Record<"method", never>>) | undefined = ({
+            headers?: HeadersInit | undefined;
+        } & Omit<FetchOptions, "headers" | "method"> & Partial<Record<"method", never>>) | undefined, Result = GetFetchResult<[{
+            method: string;
+        }, TOptions, DefaultOptions, ({
+            headers?: HeadersInit | undefined;
+        } & Omit<FetchOptions, "headers" | "method"> & Partial<Record<"method", never>>) | undefined], T>>(...args: DefaultUrl extends undefined ? [url: string | URL, options?: TOptions | undefined] : [options?: TOptions | undefined]) => IPromise_Fetch<Result>;
+    };
+    /** Make HTTP requests with method HEAD */
+    head: {
+        <T extends unknown = never, TOptions extends ({
+            headers?: HeadersInit | undefined;
+        } & Omit<FetchOptions, "headers" | "method"> & Partial<Record<"method", never>>) | undefined = ({
+            headers?: HeadersInit | undefined;
+        } & Omit<FetchOptions, "headers" | "method"> & Partial<Record<"method", never>>) | undefined, Result = GetFetchResult<[{
+            method: string;
+        }, TOptions, ({
+            headers?: HeadersInit | undefined;
+        } & Omit<FetchOptions, "headers" | "method"> & Partial<Record<"method", never>>) | undefined], T>>(url: FetchArgs[0], options?: TOptions | undefined): IPromise_Fetch<Result>;
+        deferred<ThisArg, Delay extends number, DefaultUrl extends FetchArgs[0] | undefined = string | URL | undefined, DefaultOptions extends ({
+            headers?: HeadersInit | undefined;
+        } & Omit<FetchOptions, "headers" | "method"> & Partial<Record<"method", never>>) | undefined = ({
+            headers?: HeadersInit | undefined;
+        } & Omit<FetchOptions, "headers" | "method"> & Partial<Record<"method", never>>) | undefined>(deferOptions?: _superutils_promise.DeferredAsyncOptions<ThisArg, Delay> | undefined, defaultUrl?: DefaultUrl | undefined, defaultOptions?: DefaultOptions | undefined): <T extends unknown = never, TOptions extends ({
+            headers?: HeadersInit | undefined;
+        } & Omit<FetchOptions, "headers" | "method"> & Partial<Record<"method", never>>) | undefined = ({
+            headers?: HeadersInit | undefined;
+        } & Omit<FetchOptions, "headers" | "method"> & Partial<Record<"method", never>>) | undefined, Result = GetFetchResult<[{
+            method: string;
+        }, TOptions, DefaultOptions, ({
+            headers?: HeadersInit | undefined;
+        } & Omit<FetchOptions, "headers" | "method"> & Partial<Record<"method", never>>) | undefined], T>>(...args: DefaultUrl extends undefined ? [url: string | URL, options?: TOptions | undefined] : [options?: TOptions | undefined]) => IPromise_Fetch<Result>;
+    };
+    /** Make HTTP requests with method OPTIONS */
+    options: {
+        <T extends unknown = never, TOptions extends ({
+            headers?: HeadersInit | undefined;
+        } & Omit<FetchOptions, "headers" | "method"> & Partial<Record<"method", never>>) | undefined = ({
+            headers?: HeadersInit | undefined;
+        } & Omit<FetchOptions, "headers" | "method"> & Partial<Record<"method", never>>) | undefined, Result = GetFetchResult<[{
+            method: string;
+        }, TOptions, ({
+            headers?: HeadersInit | undefined;
+        } & Omit<FetchOptions, "headers" | "method"> & Partial<Record<"method", never>>) | undefined], T>>(url: FetchArgs[0], options?: TOptions | undefined): IPromise_Fetch<Result>;
+        deferred<ThisArg, Delay extends number, DefaultUrl extends FetchArgs[0] | undefined = string | URL | undefined, DefaultOptions extends ({
+            headers?: HeadersInit | undefined;
+        } & Omit<FetchOptions, "headers" | "method"> & Partial<Record<"method", never>>) | undefined = ({
+            headers?: HeadersInit | undefined;
+        } & Omit<FetchOptions, "headers" | "method"> & Partial<Record<"method", never>>) | undefined>(deferOptions?: _superutils_promise.DeferredAsyncOptions<ThisArg, Delay> | undefined, defaultUrl?: DefaultUrl | undefined, defaultOptions?: DefaultOptions | undefined): <T extends unknown = never, TOptions extends ({
+            headers?: HeadersInit | undefined;
+        } & Omit<FetchOptions, "headers" | "method"> & Partial<Record<"method", never>>) | undefined = ({
+            headers?: HeadersInit | undefined;
+        } & Omit<FetchOptions, "headers" | "method"> & Partial<Record<"method", never>>) | undefined, Result = GetFetchResult<[{
+            method: string;
+        }, TOptions, DefaultOptions, ({
+            headers?: HeadersInit | undefined;
+        } & Omit<FetchOptions, "headers" | "method"> & Partial<Record<"method", never>>) | undefined], T>>(...args: DefaultUrl extends undefined ? [url: string | URL, options?: TOptions | undefined] : [options?: TOptions | undefined]) => IPromise_Fetch<Result>;
+    };
+    /** Make HTTP requests with method DELETE */
+    delete: {
+        <T extends unknown = never, Options extends ({
+            headers?: HeadersInit | undefined;
+        } & Omit<PostOptions, "headers" | "method"> & Partial<Record<"method", never>>) | undefined = ({
+            headers?: HeadersInit | undefined;
+        } & Omit<PostOptions, "headers" | "method"> & Partial<Record<"method", never>>) | undefined, Result = GetFetchResult<[{
+            method: "delete";
+        }, Options, ({
+            headers?: HeadersInit | undefined;
+        } & Omit<PostOptions, "headers" | "method"> & Partial<Record<"method", never>>) | undefined], T>>(url: PostArgs[0], data?: PostArgs[1], options?: Options | undefined): IPromise_Fetch<Result>;
+        deferred<ThisArg, DefaultUrl extends PostArgs[0] | undefined, DefaultData extends PostArgs[1] | undefined, DefaultOptions extends ({
+            headers?: HeadersInit | undefined;
+        } & Omit<PostOptions, "headers" | "method"> & Partial<Record<"method", never>>) | undefined = ({
+            headers?: HeadersInit | undefined;
+        } & Omit<PostOptions, "headers" | "method"> & Partial<Record<"method", never>>) | undefined, Delay extends number = number>(deferOptions?: _superutils_promise.DeferredAsyncOptions<ThisArg, Delay> | undefined, defaultUrl?: DefaultUrl | undefined, defaultData?: DefaultData | undefined, defaultOptions?: DefaultOptions | undefined): <T extends unknown = never, Options extends ({
+            headers?: HeadersInit | undefined;
+        } & Omit<PostOptions, "headers" | "method"> & Partial<Record<"method", never>>) | undefined = ({
+            headers?: HeadersInit | undefined;
+        } & Omit<PostOptions, "headers" | "method"> & Partial<Record<"method", never>>) | undefined, TReturn = GetFetchResult<[{
+            method: "delete";
+        }, Options, DefaultOptions, ({
+            headers?: HeadersInit | undefined;
+        } & Omit<PostOptions, "headers" | "method"> & Partial<Record<"method", never>>) | undefined], T>>(...args: PostDeferredCbArgs<DefaultUrl, DefaultData, Options, [url: string | URL, data: PostBody | (() => PostBody), options: PostOptions], undefined extends DefaultUrl ? DefaultUrl & undefined : DefaultUrl, undefined extends DefaultData ? DefaultData & undefined : DefaultData>) => IPromise_Fetch<TReturn>;
+    };
+    /** Make HTTP requests with method PATCH */
+    patch: {
+        <T extends unknown = never, Options extends ({
+            headers?: HeadersInit | undefined;
+        } & Omit<PostOptions, "headers" | "method"> & Partial<Record<"method", never>>) | undefined = ({
+            headers?: HeadersInit | undefined;
+        } & Omit<PostOptions, "headers" | "method"> & Partial<Record<"method", never>>) | undefined, Result = GetFetchResult<[{
+            method: "patch";
+        }, Options, ({
+            headers?: HeadersInit | undefined;
+        } & Omit<PostOptions, "headers" | "method"> & Partial<Record<"method", never>>) | undefined], T>>(url: PostArgs[0], data?: PostArgs[1], options?: Options | undefined): IPromise_Fetch<Result>;
+        deferred<ThisArg, DefaultUrl extends PostArgs[0] | undefined, DefaultData extends PostArgs[1] | undefined, DefaultOptions extends ({
+            headers?: HeadersInit | undefined;
+        } & Omit<PostOptions, "headers" | "method"> & Partial<Record<"method", never>>) | undefined = ({
+            headers?: HeadersInit | undefined;
+        } & Omit<PostOptions, "headers" | "method"> & Partial<Record<"method", never>>) | undefined, Delay extends number = number>(deferOptions?: _superutils_promise.DeferredAsyncOptions<ThisArg, Delay> | undefined, defaultUrl?: DefaultUrl | undefined, defaultData?: DefaultData | undefined, defaultOptions?: DefaultOptions | undefined): <T extends unknown = never, Options extends ({
+            headers?: HeadersInit | undefined;
+        } & Omit<PostOptions, "headers" | "method"> & Partial<Record<"method", never>>) | undefined = ({
+            headers?: HeadersInit | undefined;
+        } & Omit<PostOptions, "headers" | "method"> & Partial<Record<"method", never>>) | undefined, TReturn = GetFetchResult<[{
+            method: "patch";
+        }, Options, DefaultOptions, ({
+            headers?: HeadersInit | undefined;
+        } & Omit<PostOptions, "headers" | "method"> & Partial<Record<"method", never>>) | undefined], T>>(...args: PostDeferredCbArgs<DefaultUrl, DefaultData, Options, [url: string | URL, data: PostBody | (() => PostBody), options: PostOptions], undefined extends DefaultUrl ? DefaultUrl & undefined : DefaultUrl, undefined extends DefaultData ? DefaultData & undefined : DefaultData>) => IPromise_Fetch<TReturn>;
+    };
+    /** Make HTTP requests with method POST */
+    post: {
+        <T extends unknown = never, Options extends ({
+            headers?: HeadersInit | undefined;
+        } & Omit<PostOptions, "headers" | "method"> & Partial<Record<"method", never>>) | undefined = ({
+            headers?: HeadersInit | undefined;
+        } & Omit<PostOptions, "headers" | "method"> & Partial<Record<"method", never>>) | undefined, Result = GetFetchResult<[{
+            method: "post";
+        }, Options, ({
+            headers?: HeadersInit | undefined;
+        } & Omit<PostOptions, "headers" | "method"> & Partial<Record<"method", never>>) | undefined], T>>(url: PostArgs[0], data?: PostArgs[1], options?: Options | undefined): IPromise_Fetch<Result>;
+        deferred<ThisArg, DefaultUrl extends PostArgs[0] | undefined, DefaultData extends PostArgs[1] | undefined, DefaultOptions extends ({
+            headers?: HeadersInit | undefined;
+        } & Omit<PostOptions, "headers" | "method"> & Partial<Record<"method", never>>) | undefined = ({
+            headers?: HeadersInit | undefined;
+        } & Omit<PostOptions, "headers" | "method"> & Partial<Record<"method", never>>) | undefined, Delay extends number = number>(deferOptions?: _superutils_promise.DeferredAsyncOptions<ThisArg, Delay> | undefined, defaultUrl?: DefaultUrl | undefined, defaultData?: DefaultData | undefined, defaultOptions?: DefaultOptions | undefined): <T extends unknown = never, Options extends ({
+            headers?: HeadersInit | undefined;
+        } & Omit<PostOptions, "headers" | "method"> & Partial<Record<"method", never>>) | undefined = ({
+            headers?: HeadersInit | undefined;
+        } & Omit<PostOptions, "headers" | "method"> & Partial<Record<"method", never>>) | undefined, TReturn = GetFetchResult<[{
+            method: "post";
+        }, Options, DefaultOptions, ({
+            headers?: HeadersInit | undefined;
+        } & Omit<PostOptions, "headers" | "method"> & Partial<Record<"method", never>>) | undefined], T>>(...args: PostDeferredCbArgs<DefaultUrl, DefaultData, Options, [url: string | URL, data: PostBody | (() => PostBody), options: PostOptions], undefined extends DefaultUrl ? DefaultUrl & undefined : DefaultUrl, undefined extends DefaultData ? DefaultData & undefined : DefaultData>) => IPromise_Fetch<TReturn>;
+    };
+    /** Make HTTP requests with method PUT */
+    put: {
+        <T extends unknown = never, Options extends ({
+            headers?: HeadersInit | undefined;
+        } & Omit<PostOptions, "headers" | "method"> & Partial<Record<"method", never>>) | undefined = ({
+            headers?: HeadersInit | undefined;
+        } & Omit<PostOptions, "headers" | "method"> & Partial<Record<"method", never>>) | undefined, Result = GetFetchResult<[{
+            method: "put";
+        }, Options, ({
+            headers?: HeadersInit | undefined;
+        } & Omit<PostOptions, "headers" | "method"> & Partial<Record<"method", never>>) | undefined], T>>(url: PostArgs[0], data?: PostArgs[1], options?: Options | undefined): IPromise_Fetch<Result>;
+        deferred<ThisArg, DefaultUrl extends PostArgs[0] | undefined, DefaultData extends PostArgs[1] | undefined, DefaultOptions extends ({
+            headers?: HeadersInit | undefined;
+        } & Omit<PostOptions, "headers" | "method"> & Partial<Record<"method", never>>) | undefined = ({
+            headers?: HeadersInit | undefined;
+        } & Omit<PostOptions, "headers" | "method"> & Partial<Record<"method", never>>) | undefined, Delay extends number = number>(deferOptions?: _superutils_promise.DeferredAsyncOptions<ThisArg, Delay> | undefined, defaultUrl?: DefaultUrl | undefined, defaultData?: DefaultData | undefined, defaultOptions?: DefaultOptions | undefined): <T extends unknown = never, Options extends ({
+            headers?: HeadersInit | undefined;
+        } & Omit<PostOptions, "headers" | "method"> & Partial<Record<"method", never>>) | undefined = ({
+            headers?: HeadersInit | undefined;
+        } & Omit<PostOptions, "headers" | "method"> & Partial<Record<"method", never>>) | undefined, TReturn = GetFetchResult<[{
+            method: "put";
+        }, Options, DefaultOptions, ({
+            headers?: HeadersInit | undefined;
+        } & Omit<PostOptions, "headers" | "method"> & Partial<Record<"method", never>>) | undefined], T>>(...args: PostDeferredCbArgs<DefaultUrl, DefaultData, Options, [url: string | URL, data: PostBody | (() => PostBody), options: PostOptions], undefined extends DefaultUrl ? DefaultUrl & undefined : DefaultUrl, undefined extends DefaultData ? DefaultData & undefined : DefaultData>) => IPromise_Fetch<TReturn>;
+    };
+};
+/**
+ * A `fetch()` replacement that simplifies data fetching with automatic JSON parsing, request timeouts, retries,
+ * and handy interceptors that also work as transformers. It also includes deferred and throttled request
+ * capabilities for complex asynchronous control flows.
+ *
+ * Will reject promise if response status code is not 2xx (200 <= status < 300).
+ *
+ * ## Method Specific Functions
+ *
+ * While `fetch()` provides access to all HTTP request methods by specifying it in options (eg: `{ method: 'get' }`),
+ * for ease of use you can also use the following:
+ *
+ * - `fetch.delete(...)`
+ * - `fetch.get(...)`
+ * - `fetch.head(...)`
+ * - `fetch.options(...)`
+ * - `fetch.patch(...)`
+ * - `fetch.post(...)`
+ * - `fetch.put(...)`
+ *
+ * **Deferred variants:** To debounce/throttle requests.
+ *
+ * - `fetch.delete.deferred(...)`
+ * - `fetch.get.deferred(...)`
+ * - `fetch.head.deferred(...)`
+ * - `fetch.options.deferred(...)`
+ * - `fetch.patch.deferred(...)`
+ * - `fetch.post.deferred(...)`
+ * - `fetch.put.deferred(...)`
+ *
+ * @template T The type of the value that the `fetch` resolves to.
+ * @template TReturn Return value type.
+ *
+ * If `T` is not specified defaults to the following based on the value of `options.as`:
+ * - FetchAs.arrayBuffer: `ArrayBuffer`
+ * - FetchAs.blob: `Blob`
+ * - FetchAs.bytes: `Uint8Array<ArrayBuffer>`
+ * - FetchAs.formData: `FormData`
+ * - FetchAs.json: `unknown`
+ * - FetchAs.text: `string`
+ * - FetchAs.response: `Response`
+ *
+ * @param url
+ * @param options (optional) Standard `fetch` options extended with {@link FetchCustomOptions}
+ * @param options.abortCtrl (optional) if not provided `AbortController` will be instantiated when `timeout` used.
+ *
+ * Default: `new AbortController()`
+ * @param options.as (optional) (optional) specify how to parse the result.
+ * For raw `Response` use {@link FetchAs.response}
+ *
+ * Default: {@link FetchAs.json}
+ * @param options.headers (optional) request headers
+ *
+ * Default: `{ 'content-type': 'application/json' }`
+ * @param options.interceptors (optional) request interceptor/transformer callbacks.
+ * See {@link FetchInterceptors} for details.
+ * @param options.method (optional) fetch method.
+ *
+ * Default: `'get'`
+ * @param options.timeout (optional) duration in milliseconds to abort the request.
+ * This duration includes the execution of all interceptors/transformers.
+ *
+ * Default: `30_000`
+ *
+ *
+ *
+ * ---
+ *
+ * @example
+ * #### Drop-in replacement for built-in fetch
+ *
+ * ```javascript
+ * import fetch from '@superutils/fetch'
+ *
+ * fetch('https://dummyjson.com/products/1')
+ *     .then(response => response.json())
+ *     .then(console.log, console.error)
+ * ```
+ *
+ * @example
+ * #### Method specific function with JSON parsing by default
+ * ```javascript
+ * import fetch from '@superutils/fetch'
+ *
+ * // no need for `response.json()` or `result.data.data` drilling
+ * fetch.get('https://dummyjson.com/products/1')
+ *     .then(product => console.log(product))
+ * fetch.get('https://dummyjson.com/products/1')
+ *     .then(product => console.log(product))
+ *
+ *
+ * fetch.post('https://dummyjson.com/products/add', { title: 'Product title' })
+ *     .then(product => console.log(product))
+ * ```
+ *
+ *
+ * @example
+ * #### Set default options.
+ *
+ * Options' default values (excluding `as` and `method`) can be configured to be EFFECTIVE GLOBALLY.
+ *
+ * ```typescript
+ * import fetch from '@superutils/fetch'
+ *
+ * const { defaults, errorMsgs, interceptors } = fetch
+ *
+ * // set default request timeout duration in milliseconds
+ * defaults.timeout = 40_000
+ *
+ * // default headers
+ * defaults.headers = { 'content-type': 'text/plain' }
+ *
+ * // override error messages
+ * errorMsgs.invalidUrl = 'URL is not valid'
+ * errorMsgs.timedout = 'Request took longer than expected'
+ *
+ * // add an interceptor to log all request failures.
+ * const fetchLogger = (fetchErr, url, options) => console.log('Fetch error log', fetchErr)
+ * interceptors.error.push(fetchLogger)
+ *
+ * // add an interceptor to conditionally include header before making requests
+ * interceptors.request.push((url, options) => {
+ * 		// ignore login requests
+ *     if (`${url}`.includes('/login')) return
+ *
+ *     options.headers.set('x-auth-token', 'my-auth-token')
+ * })
+ * ```
+ */
+declare const fetch: typeof fetch$1 & typeof methods;
+
+export { type ClientData, ContentType, type ExcludeOptions, type ExcludePostOptions, type ExtractAs, type ExtractFetchAs, type FetchArgs, type FetchArgsInterceptor, FetchAs, type FetchCustomOptions, type FetchDeferredArgs, type FetchErrMsgs, FetchError, type FetchFunc, type FetchInterceptorError, type FetchInterceptorRequest, type FetchInterceptorResponse, type FetchInterceptorResult, type FetchInterceptors, type FetchInterceptorsMerged, type FetchOptions, type FetchOptionsDefault, type FetchOptionsInterceptor, type FetchResult, type FetchRetryOptions, type GetFetchResult, type IPromise_Fetch, type Interceptor, type PostArgs, type PostBody, type PostDeferredCbArgs, type PostOptions, createClient, createPostClient, fetch as default, executeInterceptors, fetch, mergeOptions };