@superutils/fetch 1.2.2 → 1.3.0

package/dist/index.d.ts

@@ -1,18 +1,24 @@
 import * as _superutils_promise from '@superutils/promise';
-import { RetryOptions, DeferredAsyncOptions, IPromisE } from '@superutils/promise';
+import { RetryOptions, RetryIfFunc, DeferredAsyncOptions, IPromisE_Timeout } from '@superutils/promise';
 export { DeferredAsyncOptions, ResolveError, ResolveIgnored } from '@superutils/promise';
 import { ValueOrPromise } from '@superutils/core';
 
-type ExcludeOptions<Target, // options to exclude
-Options extends FetchOptions = FetchOptions> = Target extends FetchOptions ? {
-    headers?: Options['headers'];
-} & Omit<Options, 'headers' | keyof Target> & Partial<Record<Exclude<keyof Target, 'headers'>, never>> : Options;
-type ExcludePostOptions<Target> = ExcludeOptions<Target, PostOptions>;
-type FetchArgs = [url: string | URL, options?: FetchOptions];
-type FetchArgsInterceptor = [
-    url: string | URL,
-    options: FetchOptionsInterceptor
-];
+/** 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",
@@ -22,53 +28,18 @@ declare enum FetchAs {
     response = "response",
     text = "text"
 }
-/** Extract `FetchAs` from `FetchOptions` */
-type FetchAsFromOptions<TOptions, TFallback = FetchAs.json> = TOptions extends {
-    as: infer As;
-} ? As extends FetchAs ? As : TFallback : TFallback;
-/** 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;
-    abortCtrl?: AbortController;
-    body?: PostBody | (() => PostBody);
-    errMsgs?: FetchErrMsgs;
-    interceptors?: FetchInterceptors;
-    /** Request timeout in milliseconds. */
-    timeout?: number;
-    validateUrl?: boolean;
-} & FetchRetryOptions;
-/** Default args */
-type FetchDeferredArgs<OmitMethod extends boolean = false> = [
-    url?: string | URL,
-    options?: Omit<FetchOptions, 'abortCtrl' | (OmitMethod extends true ? 'method' : never)>
-];
-type FetchErrMsgs = {
-    invalidUrl?: string;
-    parseFailed?: string;
-    reqTimedout?: string;
-    requestFailed?: string;
-};
-/** Custom error message for fetch requests with more detailed info about the request URL, fetch options and response */
-declare class FetchError extends Error {
-    options: FetchOptions;
-    response?: Response;
-    url: string | URL;
-    constructor(message: string, options: {
-        cause?: unknown;
-        options: FetchOptions;
-        response?: Response;
-        url: string | URL;
-    });
-    clone: (newMessage: string) => FetchError;
-}
+
+/**
+ * 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
@@ -201,10 +172,10 @@ type FetchInterceptorResult<Args extends unknown[] = FetchArgsInterceptor> = Int
 /**
  * All valid interceptors for fetch requests are:
  * ---
- * 1. error,
+ * 1. error
  * 2. request
  * 3. response
- * 4. result.
+ * 4. result
  *
  * An interceptor can be any of the following:
  * ---
@@ -223,10 +194,9 @@ type FetchInterceptorResult<Args extends unknown[] = FetchArgsInterceptor> = Int
  * 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 & examples:
+ * More info about specific interceptor types & examples:
  * ---
  * See the following for more details and examples:
  *
@@ -236,24 +206,108 @@ type FetchInterceptorResult<Args extends unknown[] = FetchArgsInterceptor> = Int
  * - `result`: {@link FetchInterceptorResult}
  */
 type FetchInterceptors = {
+    /** Request error interceptors/transformers. See {@link FetchInterceptorError} for more details. */
     error?: FetchInterceptorError[];
+    /** Request request interceptors/transformers. See {@link FetchInterceptorRequest} for more details. */
     request?: FetchInterceptorRequest[];
+    /** Request response interceptors/transformers. See {@link FetchInterceptorResponse} for more details. */
     response?: FetchInterceptorResponse[];
+    /** Request result interceptors/transformers. See {@link FetchInterceptorResult} for more details. */
     result?: FetchInterceptorResult[];
 };
+
+type ExcludeOptions<Target, // options to exclude
+Options extends FetchOptions = FetchOptions> = Target extends FetchOptions ? {
+    headers?: Options['headers'];
+} & Omit<Options, 'headers' | keyof Target> & Partial<Record<Exclude<keyof Target, 'headers'>, never>> : Options;
+type ExcludePostOptions<Target> = ExcludeOptions<Target, PostOptions>;
+type FetchArgs = [url: string | URL, options?: FetchOptions];
+type FetchArgsInterceptor = [
+    url: string | URL,
+    options: FetchOptionsInterceptor
+];
+/** Extract `FetchAs` from `FetchOptions` */
+type FetchAsFromOptions<TOptions, TFallback = FetchAs.json> = TOptions extends {
+    as: infer As;
+} ? As extends FetchAs ? As : TFallback : TFallback;
+/** 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?: (...args: FetchArgs) => Promise<Response>;
+    errMsgs?: FetchErrMsgs;
+    /**
+     * Interceptor/transformer callback executed at different stages of the request.
+     * See {@link FetchInterceptors} for more details.
+     */
+    interceptors?: FetchInterceptors;
+    /** Request timeout in milliseconds */
+    timeout?: number;
+    /** Whether to validate URL before making the request. Default: `true` */
+    validateUrl?: boolean;
+} & FetchRetryOptions;
+/** Default args */
+type FetchDeferredArgs<OmitMethod extends boolean = false> = [
+    url?: string | URL,
+    options?: Omit<FetchOptions, 'abortCtrl' | (OmitMethod extends true ? 'method' : never)>
+];
+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;
+};
 /**
  * Fetch request options
  */
 type FetchOptions = Omit<RequestInit, 'body'> & FetchCustomOptions;
-type FetchOptionsDefaults = Omit<FetchOptionsInterceptor, 'as' | 'method' | 'retryIf'>;
+/** 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
+ * Fetch options available to interceptors.
+ *
  */
-type FetchOptionsInterceptor = Omit<FetchOptions, 'as' | 'errMsgs' | 'interceptors' | 'headers' | keyof FetchRetryOptions> & {
+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: Required<FetchInterceptors>;
+    timeout: number;
 } & FetchRetryOptions;
 /**
  * Result types for specific parsers ("as": FetchAs)
@@ -279,12 +333,8 @@ type FetchRetryOptions = Omit<Partial<RetryOptions>, 'retry' | 'retryIf'> & {
      * Default: `0`
      */
     retry?: number;
-    retryIf?: null | ((response: Response | undefined, retryCount: number, error?: unknown) => boolean | Promise<boolean>);
+    retryIf?: RetryIfFunc<Response>;
 };
-/**
- * Generic fetch interceptor type
- */
-type Interceptor<T, TArgs extends unknown[]> = (...args: [value: T, ...TArgs]) => ValueOrPromise<void> | ValueOrPromise<T>;
 type PostBody = Record<string, unknown> | BodyInit | null;
 type PostArgs<OmitMethod = false> = [
     url: string | URL,
@@ -324,45 +374,166 @@ type PostArgs<OmitMethod = false> = [
  * f4().then(console.log, console.warn)
  * ```
  */
-type PostDeferredCbArgs<TUrl = undefined, TData = undefined, Options = PostOptions, CbArgsReq extends unknown[] = Required<PostArgs>> = [TUrl, TData] extends [CbArgsReq[0], undefined] ? [data?: PostArgs[1], options?: Options] : [TUrl, TData] extends [undefined, CbArgsReq[1]] ? [url: PostArgs[0], options?: Options] : [TUrl, TData] extends [CbArgsReq[0], CbArgsReq[1]] ? [options?: Options] : PostArgs;
+type PostDeferredCbArgs<TUrl = undefined, TData = undefined, Options = undefined, CbArgsReq extends unknown[] = Required<PostArgs>> = [TUrl, TData] extends [CbArgsReq[0], undefined] ? [
+    data?: PostArgs[1],
+    options?: PostArgs[2]
+] : [
+    TUrl,
+    TData
+] extends [undefined, CbArgsReq[1]] ? [url: PostArgs[0], options?: PostArgs[2]] : [
+    TUrl,
+    TData
+] extends [CbArgsReq[0], CbArgsReq[1]] ? [options?: PostArgs[2]] : [TUrl, TData, 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;
+    });
+}
+
 /**
  * Create a reusable fetch client with shared options. The returned function comes attached with a
- * `.deferred()` function for debounced and throttled request.
+ * `.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)
+ * 		delayMs: 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: <MandatoryOpts extends FetchOptions | undefined, CommonOpts extends ExcludeOptions<MandatoryOpts> | undefined, MandatoryAs extends FetchAs | undefined = FetchAsFromOptions<MandatoryOpts, undefined>>(
+declare const createClient: <FixedOpts extends FetchOptions | undefined, CommonOpts extends ExcludeOptions<FixedOpts> | undefined, FixedAs extends FetchAs | undefined = FetchAsFromOptions<FixedOpts, undefined>>(
 /** Mandatory fetch options that cannot be overriden by individual request */
-mandatoryOptions?: MandatoryOpts, 
+fixedOptions?: FixedOpts, 
 /** Common fetch options that can be overriden by individual request */
 commonOptions?: FetchOptions & CommonOpts, commonDeferOptions?: DeferredAsyncOptions<unknown, unknown>) => {
-    <T, TOptions extends ExcludeOptions<MandatoryOpts> | undefined = ExcludeOptions<MandatoryOpts> | undefined, TAs extends FetchAs = MandatoryAs extends FetchAs ? MandatoryAs : FetchAsFromOptions<TOptions, FetchAsFromOptions<CommonOpts>>, TReturn = FetchResult<T>[TAs]>(url: FetchArgs[0], options?: TOptions): IPromisE<TReturn>;
-    deferred<ThisArg = unknown, TDelay extends number = number, DefaultUrl extends FetchArgs[0] | undefined = string | URL | undefined, DefaultOptions extends ExcludeOptions<MandatoryOpts> | undefined = ExcludeOptions<MandatoryOpts> | undefined>(deferOptions?: DeferredAsyncOptions<ThisArg, TDelay>, defaultUrl?: DefaultUrl, defaultOptions?: DefaultOptions): <TResult = unknown, TOptions_1 extends ExcludeOptions<MandatoryOpts> | undefined = ExcludeOptions<MandatoryOpts> | undefined, TAs_1 extends FetchAs = MandatoryAs extends FetchAs ? MandatoryAs : FetchAsFromOptions<TOptions_1, FetchAsFromOptions<CommonOpts>>, TReturn_1 = FetchResult<TResult>[TAs_1]>(...args: DefaultUrl extends undefined ? [url: FetchArgs[0], options?: TOptions_1] : [options?: TOptions_1]) => IPromisE<TReturn_1>;
+    <T, TOptions extends ExcludeOptions<FixedOpts> | undefined = ExcludeOptions<FixedOpts> | undefined, TAs extends FetchAs = FixedAs extends FetchAs ? FixedAs : FetchAsFromOptions<TOptions, FetchAsFromOptions<CommonOpts>>, TReturn = FetchResult<T>[TAs]>(url: FetchArgs[0], options?: TOptions): _superutils_promise.IPromisE_Timeout<TReturn>;
+    deferred<ThisArg = unknown, Delay extends number = number, DefaultUrl extends FetchArgs[0] | undefined = string | URL | undefined, DefaultOptions extends ExcludeOptions<FixedOpts> | undefined = ExcludeOptions<FixedOpts> | undefined>(deferOptions?: DeferredAsyncOptions<ThisArg, Delay>, defaultUrl?: DefaultUrl, defaultOptions?: DefaultOptions): <TResult = unknown, TOptions_1 extends ExcludeOptions<FixedOpts> | undefined = ExcludeOptions<FixedOpts> | undefined, TAs_1 extends FetchAs = FixedAs extends FetchAs ? FixedAs : FetchAsFromOptions<TOptions_1, FetchAsFromOptions<CommonOpts>>, TReturn_1 = FetchResult<TResult>[TAs_1]>(...args: DefaultUrl extends undefined ? [url: FetchArgs[0], options?: TOptions_1] : [options?: TOptions_1]) => _superutils_promise.IPromisE_Timeout<TReturn_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(
+ * 	{
+ * 		delayMs: 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: <MandatoryOpts extends PostOptions | undefined, CommonOpts extends ExcludePostOptions<MandatoryOpts> | undefined, MandatoryAs extends FetchAs | undefined = FetchAsFromOptions<MandatoryOpts, undefined>>(
+declare const createPostClient: <FixedOpts extends PostOptions | undefined, CommonOpts extends ExcludePostOptions<FixedOpts> | undefined, FixedAs extends FetchAs | undefined = FetchAsFromOptions<FixedOpts, undefined>>(
 /** Mandatory fetch options that cannot be overriden by individual request */
-mandatoryOptions?: MandatoryOpts, 
+fixedOptions?: FixedOpts, 
 /** Common fetch options that can be overriden by individual request */
 commonOptions?: PostOptions & CommonOpts, commonDeferOptions?: DeferredAsyncOptions<unknown, unknown>) => {
-    <T, TOptions extends ExcludePostOptions<MandatoryOpts> | undefined, TAs extends FetchAs = MandatoryAs extends FetchAs ? MandatoryAs : FetchAsFromOptions<TOptions, FetchAsFromOptions<CommonOpts>>, TReturn = FetchResult<T>[TAs]>(url: PostArgs[0], data?: PostArgs[1], options?: TOptions): IPromisE<TReturn>;
-    deferred<ThisArg = unknown, TDelay extends number = number, DefaultUrl extends PostArgs[0] | undefined = string | URL | undefined, DefaultData extends PostArgs[1] = PostBody | (() => PostBody) | undefined, DefaultOptions extends ExcludePostOptions<MandatoryOpts> | undefined = ExcludePostOptions<MandatoryOpts> | undefined>(deferOptions?: DeferredAsyncOptions<ThisArg, TDelay>, defaultUrl?: DefaultUrl, defaultData?: DefaultData, defaultOptions?: DefaultOptions): <TResult = unknown, TOptions_1 extends ExcludePostOptions<MandatoryOpts> | undefined = ExcludePostOptions<MandatoryOpts> | undefined, TAs_1 extends FetchAs = MandatoryAs extends FetchAs ? MandatoryAs : FetchAsFromOptions<TOptions_1, FetchAsFromOptions<CommonOpts>>, TReturn_1 = FetchResult<TResult>[TAs_1]>(...args: PostDeferredCbArgs<DefaultUrl, DefaultData, TOptions_1>) => IPromisE<TReturn_1>;
+    <T = unknown, TOptions extends ExcludePostOptions<FixedOpts> | undefined = ExcludePostOptions<FixedOpts> | undefined, TAs extends FetchAs = FixedAs extends FetchAs ? FixedAs : FetchAsFromOptions<TOptions, FetchAsFromOptions<CommonOpts>>, TReturn = FetchResult<T>[TAs]>(url: PostArgs[0], data?: PostArgs[1], options?: TOptions): IPromisE_Timeout<TReturn>;
+    deferred<ThisArg, Delay extends number, DefaultUrl extends PostArgs[0] | undefined, DefaultData extends PostArgs[1] = undefined, DefaultOptions extends ExcludePostOptions<FixedOpts> | undefined = undefined>(deferOptions?: DeferredAsyncOptions<ThisArg, Delay>, defaultUrl?: DefaultUrl, defaultData?: DefaultData, defaultOptions?: DefaultOptions): <TResult = unknown, TOptions_1 extends ExcludePostOptions<FixedOpts> | undefined = ExcludePostOptions<FixedOpts>, TAs_1 extends FetchAs = FixedAs extends FetchAs ? FixedAs : FetchAsFromOptions<TOptions_1, FetchAsFromOptions<CommonOpts>>, TReturn_1 = FetchResult<TResult>[TAs_1]>(...args: PostDeferredCbArgs<DefaultUrl, DefaultData, TOptions_1>) => IPromisE_Timeout<TReturn_1>;
 };
 
+/** Node.js setTimeout limit is 2147483647 (2^31-1). Larger values fire immediately. */
+declare const MAX_TIMEOUT = 2147483647;
 /**
  * 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 is 'application/json'
- * @param options.as (optional) determines who to parse the result. Default: {@link FetchAs.json}
+ * 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
@@ -375,21 +546,19 @@ commonOptions?: PostOptions & CommonOpts, commonDeferOptions?: DeferredAsyncOpti
  * ```
  */
 declare const fetch: {
-    <T, TOptions extends FetchOptions = FetchOptions, TAs extends FetchAs = TOptions["as"] extends FetchAs ? TOptions["as"] : FetchAs.json, TReturn = FetchResult<T>[TAs]>(url: string | URL, options?: TOptions): IPromisE<TReturn>;
+    <T, TOptions extends FetchOptions = FetchOptions, TAs extends FetchAs = TOptions["as"] extends FetchAs ? TOptions["as"] : FetchAs.json, TReturn = FetchResult<T>[TAs]>(url: string | URL, options?: FetchOptions & TOptions): IPromisE_Timeout<TReturn>;
     /** Default fetch options */
-    defaults: FetchOptionsDefaults;
+    defaults: FetchOptionsDefault;
 };
 
 /**
  * Drop-in replacement for built-in `fetch()` with with timeout, retry etc options and Response as default return type.
  *
  * @param url request URL
- * @param options (optional) Standard `fetch` options extended with {@link FetchCustomOptions}
- * @param options.as (optional) determines who to parse the result. Default: {@link FetchAs.response}
- * @param options.method (optional) fetch method. Default: `'get'`
+ * @param options (optional) Standard `fetch` options extended with "FetchCustomOptions"
  *
  * @example Make a simple HTTP requests
- * ```typescript
+ * ```javascript
  * import { fetchResponse } from '@superutils/fetch'
  *
  * fetchResponse('https://dummyjson.com/products/1')
@@ -397,129 +566,123 @@ declare const fetch: {
  *     .then(console.log, console.error)
  * ```
  */
-declare const fetchResponse: <T = Response, TOptions extends FetchOptions = FetchOptions, TAs extends FetchAs = TOptions["as"] extends FetchAs ? TOptions["as"] : FetchAs.response, TReturn = FetchResult<T>[TAs]>(...args: Parameters<typeof fetch<T, TOptions, TAs, TReturn>>) => IPromisE<TReturn>;
-
-declare const _get: {
-    <T, 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, TAs extends FetchAs = FetchAsFromOptions<TOptions, FetchAs.json>, TReturn = FetchResult<T>[TAs]>(url: FetchArgs[0], options?: TOptions | undefined): _superutils_promise.IPromisE<TReturn>;
-    deferred<ThisArg = unknown, TDelay extends number = 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, TDelay>, defaultUrl?: DefaultUrl | undefined, defaultOptions?: DefaultOptions | undefined): <TResult = unknown, 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, TAs extends FetchAs = FetchAsFromOptions<TOptions, FetchAs.json>, TReturn = FetchResult<TResult>[TAs]>(...args: DefaultUrl extends undefined ? [url: string | URL, options?: TOptions | undefined] : [options?: TOptions | undefined]) => _superutils_promise.IPromisE<TReturn>;
-};
-declare const _head: {
-    <T, 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, TAs extends FetchAs = FetchAsFromOptions<TOptions, FetchAs.json>, TReturn = FetchResult<T>[TAs]>(url: FetchArgs[0], options?: TOptions | undefined): _superutils_promise.IPromisE<TReturn>;
-    deferred<ThisArg = unknown, TDelay extends number = 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, TDelay>, defaultUrl?: DefaultUrl | undefined, defaultOptions?: DefaultOptions | undefined): <TResult = unknown, 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, TAs extends FetchAs = FetchAsFromOptions<TOptions, FetchAs.json>, TReturn = FetchResult<TResult>[TAs]>(...args: DefaultUrl extends undefined ? [url: string | URL, options?: TOptions | undefined] : [options?: TOptions | undefined]) => _superutils_promise.IPromisE<TReturn>;
-};
-declare const _options: {
-    <T, 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, TAs extends FetchAs = FetchAsFromOptions<TOptions, FetchAs.json>, TReturn = FetchResult<T>[TAs]>(url: FetchArgs[0], options?: TOptions | undefined): _superutils_promise.IPromisE<TReturn>;
-    deferred<ThisArg = unknown, TDelay extends number = 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, TDelay>, defaultUrl?: DefaultUrl | undefined, defaultOptions?: DefaultOptions | undefined): <TResult = unknown, 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, TAs extends FetchAs = FetchAsFromOptions<TOptions, FetchAs.json>, TReturn = FetchResult<TResult>[TAs]>(...args: DefaultUrl extends undefined ? [url: string | URL, options?: TOptions | undefined] : [options?: TOptions | undefined]) => _superutils_promise.IPromisE<TReturn>;
-};
-declare const _delete: {
-    <T, TOptions extends ({
-        headers?: HeadersInit | undefined;
-    } & Omit<PostOptions, "headers" | "method"> & Partial<Record<"method", never>>) | undefined, TAs extends FetchAs = FetchAsFromOptions<TOptions, FetchAs.json>, TReturn = FetchResult<T>[TAs]>(url: PostArgs[0], data?: PostArgs[1], options?: TOptions | undefined): _superutils_promise.IPromisE<TReturn>;
-    deferred<ThisArg = unknown, TDelay extends number = number, DefaultUrl extends PostArgs[0] | undefined = string | URL | undefined, DefaultData extends PostArgs[1] = PostBody | (() => PostBody) | 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>(deferOptions?: _superutils_promise.DeferredAsyncOptions<ThisArg, TDelay>, defaultUrl?: DefaultUrl | undefined, defaultData?: DefaultData | undefined, defaultOptions?: DefaultOptions | undefined): <TResult = unknown, TOptions 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, TAs extends FetchAs = FetchAsFromOptions<TOptions, FetchAs.json>, TReturn = FetchResult<TResult>[TAs]>(...args: PostDeferredCbArgs<DefaultUrl, DefaultData, TOptions, [url: string | URL, data: PostBody | (() => PostBody), options: PostOptions]>) => _superutils_promise.IPromisE<TReturn>;
+declare const fetchResponse: {
+    <T = Response, TOptions extends FetchOptions = FetchOptions, TAs extends FetchAs = TOptions["as"] extends FetchAs ? TOptions["as"] : FetchAs.response, TReturn = FetchResult<T>[TAs]>(url: FetchArgs[0], options?: Parameters<typeof fetch<T, TOptions, TAs, TReturn>>[1]): IPromisE_Timeout<TReturn>;
+    defaults: FetchOptionsDefault;
 };
-declare const _patch: {
-    <T, TOptions extends ({
-        headers?: HeadersInit | undefined;
-    } & Omit<PostOptions, "headers" | "method"> & Partial<Record<"method", never>>) | undefined, TAs extends FetchAs = FetchAsFromOptions<TOptions, FetchAs.json>, TReturn = FetchResult<T>[TAs]>(url: PostArgs[0], data?: PostArgs[1], options?: TOptions | undefined): _superutils_promise.IPromisE<TReturn>;
-    deferred<ThisArg = unknown, TDelay extends number = number, DefaultUrl extends PostArgs[0] | undefined = string | URL | undefined, DefaultData extends PostArgs[1] = PostBody | (() => PostBody) | 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>(deferOptions?: _superutils_promise.DeferredAsyncOptions<ThisArg, TDelay>, defaultUrl?: DefaultUrl | undefined, defaultData?: DefaultData | undefined, defaultOptions?: DefaultOptions | undefined): <TResult = unknown, TOptions 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, TAs extends FetchAs = FetchAsFromOptions<TOptions, FetchAs.json>, TReturn = FetchResult<TResult>[TAs]>(...args: PostDeferredCbArgs<DefaultUrl, DefaultData, TOptions, [url: string | URL, data: PostBody | (() => PostBody), options: PostOptions]>) => _superutils_promise.IPromisE<TReturn>;
-};
-declare const _post: {
-    <T, TOptions extends ({
-        headers?: HeadersInit | undefined;
-    } & Omit<PostOptions, "headers" | "method"> & Partial<Record<"method", never>>) | undefined, TAs extends FetchAs = FetchAsFromOptions<TOptions, FetchAs.json>, TReturn = FetchResult<T>[TAs]>(url: PostArgs[0], data?: PostArgs[1], options?: TOptions | undefined): _superutils_promise.IPromisE<TReturn>;
-    deferred<ThisArg = unknown, TDelay extends number = number, DefaultUrl extends PostArgs[0] | undefined = string | URL | undefined, DefaultData extends PostArgs[1] = PostBody | (() => PostBody) | 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>(deferOptions?: _superutils_promise.DeferredAsyncOptions<ThisArg, TDelay>, defaultUrl?: DefaultUrl | undefined, defaultData?: DefaultData | undefined, defaultOptions?: DefaultOptions | undefined): <TResult = unknown, TOptions 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, TAs extends FetchAs = FetchAsFromOptions<TOptions, FetchAs.json>, TReturn = FetchResult<TResult>[TAs]>(...args: PostDeferredCbArgs<DefaultUrl, DefaultData, TOptions, [url: string | URL, data: PostBody | (() => PostBody), options: PostOptions]>) => _superutils_promise.IPromisE<TReturn>;
-};
-declare const _put: {
-    <T, TOptions extends ({
-        headers?: HeadersInit | undefined;
-    } & Omit<PostOptions, "headers" | "method"> & Partial<Record<"method", never>>) | undefined, TAs extends FetchAs = FetchAsFromOptions<TOptions, FetchAs.json>, TReturn = FetchResult<T>[TAs]>(url: PostArgs[0], data?: PostArgs[1], options?: TOptions | undefined): _superutils_promise.IPromisE<TReturn>;
-    deferred<ThisArg = unknown, TDelay extends number = number, DefaultUrl extends PostArgs[0] | undefined = string | URL | undefined, DefaultData extends PostArgs[1] = PostBody | (() => PostBody) | 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>(deferOptions?: _superutils_promise.DeferredAsyncOptions<ThisArg, TDelay>, defaultUrl?: DefaultUrl | undefined, defaultData?: DefaultData | undefined, defaultOptions?: DefaultOptions | undefined): <TResult = unknown, TOptions 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, TAs extends FetchAs = FetchAsFromOptions<TOptions, FetchAs.json>, TReturn = FetchResult<TResult>[TAs]>(...args: PostDeferredCbArgs<DefaultUrl, DefaultData, TOptions, [url: string | URL, data: PostBody | (() => PostBody), options: PostOptions]>) => _superutils_promise.IPromisE<TReturn>;
-};
-type FetchWithMethods = typeof fetchResponse & {
-    /** Default options */
-    defaults: typeof fetch.defaults;
-    /** Make HTTP `DELETE` request, result automatically parsed as JSON */
-    delete: typeof _delete;
-    /** Make HTTP `GET` request, result automatically parsed as JSON */
-    get: typeof _get;
-    /** Make HTTP `HEAD` request, result automatically parsed as JSON */
-    head: typeof _head;
-    /** Make HTTP `OPTIONS` request, result automatically parsed as JSON */
-    options: typeof _options;
-    /** Make HTTP `PATCH` request, result automatically parsed as JSON */
-    patch: typeof _patch;
-    /** Make HTTP `POST` request, result automatically parsed as JSON */
-    post: typeof _post;
-    /** Make HTTP `PUT` request, result automatically parsed as JSON */
-    put: typeof _put;
+
+declare const methods: {
+    /** Make HTTP requests with method GET */
+    get: {
+        <T, 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, TAs extends FetchAs = FetchAsFromOptions<TOptions, FetchAs.json>, TReturn = FetchResult<T>[TAs]>(url: FetchArgs[0], options?: TOptions | undefined): _superutils_promise.IPromisE_Timeout<TReturn>;
+        deferred<ThisArg = unknown, Delay extends number = 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>, defaultUrl?: DefaultUrl | undefined, defaultOptions?: DefaultOptions | undefined): <TResult = unknown, 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, TAs extends FetchAs = FetchAsFromOptions<TOptions, FetchAs.json>, TReturn = FetchResult<TResult>[TAs]>(...args: DefaultUrl extends undefined ? [url: string | URL, options?: TOptions | undefined] : [options?: TOptions | undefined]) => _superutils_promise.IPromisE_Timeout<TReturn>;
+    };
+    /** Make HTTP requests with method HEAD */
+    head: {
+        <T, 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, TAs extends FetchAs = FetchAsFromOptions<TOptions, FetchAs.json>, TReturn = FetchResult<T>[TAs]>(url: FetchArgs[0], options?: TOptions | undefined): _superutils_promise.IPromisE_Timeout<TReturn>;
+        deferred<ThisArg = unknown, Delay extends number = 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>, defaultUrl?: DefaultUrl | undefined, defaultOptions?: DefaultOptions | undefined): <TResult = unknown, 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, TAs extends FetchAs = FetchAsFromOptions<TOptions, FetchAs.json>, TReturn = FetchResult<TResult>[TAs]>(...args: DefaultUrl extends undefined ? [url: string | URL, options?: TOptions | undefined] : [options?: TOptions | undefined]) => _superutils_promise.IPromisE_Timeout<TReturn>;
+    };
+    /** Make HTTP requests with method OPTIONS */
+    options: {
+        <T, 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, TAs extends FetchAs = FetchAsFromOptions<TOptions, FetchAs.json>, TReturn = FetchResult<T>[TAs]>(url: FetchArgs[0], options?: TOptions | undefined): _superutils_promise.IPromisE_Timeout<TReturn>;
+        deferred<ThisArg = unknown, Delay extends number = 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>, defaultUrl?: DefaultUrl | undefined, defaultOptions?: DefaultOptions | undefined): <TResult = unknown, 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, TAs extends FetchAs = FetchAsFromOptions<TOptions, FetchAs.json>, TReturn = FetchResult<TResult>[TAs]>(...args: DefaultUrl extends undefined ? [url: string | URL, options?: TOptions | undefined] : [options?: TOptions | undefined]) => _superutils_promise.IPromisE_Timeout<TReturn>;
+    };
+    /** Make HTTP requests with method DELETE */
+    delete: {
+        <T = unknown, TOptions 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, TAs extends FetchAs = FetchAsFromOptions<TOptions, FetchAs.json>, TReturn = FetchResult<T>[TAs]>(url: PostArgs[0], data?: PostArgs[1], options?: TOptions | undefined): _superutils_promise.IPromisE_Timeout<TReturn>;
+        deferred<ThisArg, Delay extends number, DefaultUrl extends PostArgs[0] | undefined, DefaultData extends PostArgs[1] = undefined, DefaultOptions extends ({
+            headers?: HeadersInit | undefined;
+        } & Omit<PostOptions, "headers" | "method"> & Partial<Record<"method", never>>) | undefined = undefined>(deferOptions?: _superutils_promise.DeferredAsyncOptions<ThisArg, Delay>, defaultUrl?: DefaultUrl | undefined, defaultData?: DefaultData | undefined, defaultOptions?: DefaultOptions | undefined): <TResult = unknown, TOptions extends ({
+            headers?: HeadersInit | undefined;
+        } & Omit<PostOptions, "headers" | "method"> & Partial<Record<"method", never>>) | undefined = {
+            headers?: HeadersInit | undefined;
+        } & Omit<PostOptions, "headers" | "method"> & Partial<Record<"method", never>>, TAs extends FetchAs = FetchAsFromOptions<TOptions, FetchAs.json>, TReturn = FetchResult<TResult>[TAs]>(...args: PostDeferredCbArgs<DefaultUrl, DefaultData, TOptions, [url: string | URL, data: PostBody | (() => PostBody), options: PostOptions]>) => _superutils_promise.IPromisE_Timeout<TReturn>;
+    };
+    /** Make HTTP requests with method PATCH */
+    patch: {
+        <T = unknown, TOptions 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, TAs extends FetchAs = FetchAsFromOptions<TOptions, FetchAs.json>, TReturn = FetchResult<T>[TAs]>(url: PostArgs[0], data?: PostArgs[1], options?: TOptions | undefined): _superutils_promise.IPromisE_Timeout<TReturn>;
+        deferred<ThisArg, Delay extends number, DefaultUrl extends PostArgs[0] | undefined, DefaultData extends PostArgs[1] = undefined, DefaultOptions extends ({
+            headers?: HeadersInit | undefined;
+        } & Omit<PostOptions, "headers" | "method"> & Partial<Record<"method", never>>) | undefined = undefined>(deferOptions?: _superutils_promise.DeferredAsyncOptions<ThisArg, Delay>, defaultUrl?: DefaultUrl | undefined, defaultData?: DefaultData | undefined, defaultOptions?: DefaultOptions | undefined): <TResult = unknown, TOptions extends ({
+            headers?: HeadersInit | undefined;
+        } & Omit<PostOptions, "headers" | "method"> & Partial<Record<"method", never>>) | undefined = {
+            headers?: HeadersInit | undefined;
+        } & Omit<PostOptions, "headers" | "method"> & Partial<Record<"method", never>>, TAs extends FetchAs = FetchAsFromOptions<TOptions, FetchAs.json>, TReturn = FetchResult<TResult>[TAs]>(...args: PostDeferredCbArgs<DefaultUrl, DefaultData, TOptions, [url: string | URL, data: PostBody | (() => PostBody), options: PostOptions]>) => _superutils_promise.IPromisE_Timeout<TReturn>;
+    };
+    /** Make HTTP requests with method POST */
+    post: {
+        <T = unknown, TOptions 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, TAs extends FetchAs = FetchAsFromOptions<TOptions, FetchAs.json>, TReturn = FetchResult<T>[TAs]>(url: PostArgs[0], data?: PostArgs[1], options?: TOptions | undefined): _superutils_promise.IPromisE_Timeout<TReturn>;
+        deferred<ThisArg, Delay extends number, DefaultUrl extends PostArgs[0] | undefined, DefaultData extends PostArgs[1] = undefined, DefaultOptions extends ({
+            headers?: HeadersInit | undefined;
+        } & Omit<PostOptions, "headers" | "method"> & Partial<Record<"method", never>>) | undefined = undefined>(deferOptions?: _superutils_promise.DeferredAsyncOptions<ThisArg, Delay>, defaultUrl?: DefaultUrl | undefined, defaultData?: DefaultData | undefined, defaultOptions?: DefaultOptions | undefined): <TResult = unknown, TOptions extends ({
+            headers?: HeadersInit | undefined;
+        } & Omit<PostOptions, "headers" | "method"> & Partial<Record<"method", never>>) | undefined = {
+            headers?: HeadersInit | undefined;
+        } & Omit<PostOptions, "headers" | "method"> & Partial<Record<"method", never>>, TAs extends FetchAs = FetchAsFromOptions<TOptions, FetchAs.json>, TReturn = FetchResult<TResult>[TAs]>(...args: PostDeferredCbArgs<DefaultUrl, DefaultData, TOptions, [url: string | URL, data: PostBody | (() => PostBody), options: PostOptions]>) => _superutils_promise.IPromisE_Timeout<TReturn>;
+    };
+    /** Make HTTP requests with method PUT */
+    put: {
+        <T = unknown, TOptions 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, TAs extends FetchAs = FetchAsFromOptions<TOptions, FetchAs.json>, TReturn = FetchResult<T>[TAs]>(url: PostArgs[0], data?: PostArgs[1], options?: TOptions | undefined): _superutils_promise.IPromisE_Timeout<TReturn>;
+        deferred<ThisArg, Delay extends number, DefaultUrl extends PostArgs[0] | undefined, DefaultData extends PostArgs[1] = undefined, DefaultOptions extends ({
+            headers?: HeadersInit | undefined;
+        } & Omit<PostOptions, "headers" | "method"> & Partial<Record<"method", never>>) | undefined = undefined>(deferOptions?: _superutils_promise.DeferredAsyncOptions<ThisArg, Delay>, defaultUrl?: DefaultUrl | undefined, defaultData?: DefaultData | undefined, defaultOptions?: DefaultOptions | undefined): <TResult = unknown, TOptions extends ({
+            headers?: HeadersInit | undefined;
+        } & Omit<PostOptions, "headers" | "method"> & Partial<Record<"method", never>>) | undefined = {
+            headers?: HeadersInit | undefined;
+        } & Omit<PostOptions, "headers" | "method"> & Partial<Record<"method", never>>, TAs extends FetchAs = FetchAsFromOptions<TOptions, FetchAs.json>, TReturn = FetchResult<TResult>[TAs]>(...args: PostDeferredCbArgs<DefaultUrl, DefaultData, TOptions, [url: string | URL, data: PostBody | (() => PostBody), options: PostOptions]>) => _superutils_promise.IPromisE_Timeout<TReturn>;
+    };
 };
 /**
  * A `fetch()` replacement that simplifies data fetching with automatic JSON parsing, request timeouts, retries,
@@ -562,49 +725,34 @@ type FetchWithMethods = typeof fetchResponse & {
  * - FetchAs.json: `unknown`
  * - FetchAs.text: `string`
  * - FetchAs.response: `Response`
+ *
  * @param url
  * @param options (optional) Standard `fetch` options extended with {@link FetchCustomOptions}
- * @param options.as (optional) determines who to parse the result. Default: {@link FetchAs.response}
+ * @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' }` (unless changed in the fetch.defaults).
- * @param options.method (optional) fetch method. Default: `'get'`
  *
- * Options' default values (excluding `as`, `method` and `retryIf`) can be configured to be EFFECTIVE GLOBALLY.
+ * Default: `{ 'content-type': 'application/json' }`
+ * @param options.interceptors (optional) request interceptor/transformer callbacks.
+ * See {@link FetchInterceptors} for details.
+ * @param options.method (optional) fetch method.
  *
- * ```typescript
- * import fetch from '@superutils/fetch'
+ * Default: `'get'`
+ * @param options.timeout (optional) duration in milliseconds to abort the request.
+ * This duration includes the execution of all interceptors/transformers.
  *
- * fetch.defaults = {
- *     errMsgs: {
- *        invalidUrl: 'Invalid URL',
- *        parseFailed: 'Failed to parse response as',
- *        reqTimedout: 'Request timed out',
- *        requestFailed: 'Request failed with status code:',
- *     },
- *     headers: new Headers([['content-type', 'application/json']]),
- * 	   // Global/application-wide Interceptor & Transfermers
- *     interceptors: {
- *     	   error: [],
- *     	   request: [],
- *     	   response: [],
- *     	   result: [],
- *     },
- *     timeout: 0,
- *     //........
- * }
- * ```
+ * Default: `30_000`
  *
- * @property options.abortCtrl (optional) if not provided `AbortController` will be instantiated when `timeout` used.
- * @property options.headers (optional) request headers. Default: `{ 'content-type' : 'application/json'}`
- * @property options.interceptors (optional) request interceptor callbacks.  See {@link FetchInterceptors} for details.
- * @property options.method (optional) Default: `"get"`
- * @property options.timeout (optional) duration in milliseconds to abort the request if it takes longer.
- * @property options.parse (optional) specify how to parse the result.
- * Default: {@link FetchAs.json}
- * For raw `Response` use {@link FetchAs.response}
+ * ---
  *
- * @example Drop-in replacement for built-in `fetch`
- * ```typescript
+ * @example Drop-in replacement for built-in fetch
+ *
+ * ```javascript
  * import fetch from '@superutils/fetch'
  *
  * fetch('https://dummyjson.com/products/1')
@@ -613,7 +761,7 @@ type FetchWithMethods = typeof fetchResponse & {
  * ```
  *
  * @example Method specific function with JSON parsing by default
- * ```typescript
+ * ```javascript
  * import fetch from '@superutils/fetch'
  *
  * // no need for `response.json()` or `result.data.data` drilling
@@ -626,8 +774,77 @@ type FetchWithMethods = typeof fetchResponse & {
  * 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 defaultFetch: typeof fetchResponse & typeof methods;
+
+/**
+ * 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>;
+
+/**
+ * Add AbortController to options if not present and propagate external abort signal if provided.
+ *
+ * @param options The fetch options object.
+ *
+ * @returns The AbortController instance associated with the options.
+ */
+declare const getAbortCtrl: (options: Partial<FetchOptions>) => AbortController;
+
+/**
+ * Execute built-in `fetch()` and retry if request fails and `options.retry > 0`.
+ *
+ * @param url request URL
+ * @param options (optional)
+ *
+ * @returns response
  */
-declare const fetchDefault: FetchWithMethods;
+declare const getResponse: (url: FetchArgs[0], options?: FetchArgs[1]) => Promise<Response>;
 
 /**
  * Merge one or more {@link FetchOptions}
@@ -647,4 +864,4 @@ declare const mergeFetchOptions: (...allOptions: FetchOptions[]) => FetchOptions
 /** Merges partial fetch options ignoring empty or undefined. Otherwise, will return the first argument. */
 declare const mergePartialOptions: (...optionsAr: (Partial<FetchOptions> | undefined)[]) => Partial<FetchOptions> | undefined;
 
-export { type ExcludeOptions, type ExcludePostOptions, type FetchArgs, type FetchArgsInterceptor, FetchAs, type FetchAsFromOptions, type FetchCustomOptions, type FetchDeferredArgs, type FetchErrMsgs, FetchError, type FetchInterceptorError, type FetchInterceptorRequest, type FetchInterceptorResponse, type FetchInterceptorResult, type FetchInterceptors, type FetchOptions, type FetchOptionsDefaults, type FetchOptionsInterceptor, type FetchResult, type FetchRetryOptions, type FetchWithMethods, type Interceptor, type PostArgs, type PostBody, type PostDeferredCbArgs, type PostOptions, createClient, createPostClient, fetchDefault as default, fetch, fetchResponse, mergeFetchOptions, mergePartialOptions };
+export { ContentType, type ExcludeOptions, type ExcludePostOptions, type FetchArgs, type FetchArgsInterceptor, FetchAs, type FetchAsFromOptions, type FetchCustomOptions, type FetchDeferredArgs, type FetchErrMsgs, FetchError, type FetchInterceptorError, type FetchInterceptorRequest, type FetchInterceptorResponse, type FetchInterceptorResult, type FetchInterceptors, type FetchOptions, type FetchOptionsDefault, type FetchOptionsInterceptor, type FetchResult, type FetchRetryOptions, type Interceptor, MAX_TIMEOUT, type PostArgs, type PostBody, type PostDeferredCbArgs, type PostOptions, createClient, createPostClient, defaultFetch as default, executeInterceptors, fetch, fetchResponse, getAbortCtrl, getResponse, mergeFetchOptions, mergePartialOptions };