@superutils/fetch 1.2.1 → 1.2.3

package/dist/index.d.ts

@@ -1,12 +1,30 @@
 import * as _superutils_promise from '@superutils/promise';
-import { RetryOptions, IPromisE, DeferredAsyncOptions } from '@superutils/promise';
+import { RetryOptions, RetryIfFunc, DeferredAsyncOptions, IPromisE } from '@superutils/promise';
 export { DeferredAsyncOptions, ResolveError, ResolveIgnored } from '@superutils/promise';
 import { ValueOrPromise } from '@superutils/core';
 
-type FetchArgs<OmitMethod extends boolean = false> = [
-    url: string | URL,
-    options?: OmitMethod extends true ? Omit<FetchOptions, 'method'> : FetchOptions
-];
+/** 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";
+};
+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
@@ -20,6 +38,10 @@ 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 = {
     /**
@@ -28,10 +50,12 @@ type FetchCustomOptions = {
      */
     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> = [
@@ -214,7 +238,7 @@ 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 interceprors will always be executed before local interceptors.
+ * 3. Execution priority: global interceptors will always be executed before local interceptors.
  *
  *
  *
@@ -236,8 +260,8 @@ type FetchInterceptors = {
 /**
  * Fetch request options
  */
-type FetchOptions = RequestInit & FetchCustomOptions;
-type FetchOptionsDefaults = Omit<FetchOptionsInterceptor, 'as' | 'method' | 'retryIf'>;
+type FetchOptions = Omit<RequestInit, 'body'> & FetchCustomOptions;
+type FetchOptionsDefaults = Omit<FetchOptionsInterceptor, 'as' | 'method'>;
 /**
  * Fetch options available to interceptors
  */
@@ -271,7 +295,7 @@ 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
@@ -284,64 +308,194 @@ type PostArgs<OmitMethod = false> = [
     options?: OmitMethod extends true ? Omit<FetchOptions, 'method'> : PostOptions
 ];
 /**
- * Dynamic arguments for deffered post-like methods.
+ * Dynamic arguments for deferred post-like methods.
  *
  * @example
  * ```typescript
+ * import fetch, { type PostDeferredCbArgs } from '@superutils/fetch'
+ *
  * // test with types
- * type T1 = PostDeferredCallbackArgs<string | URL, undefined> // expected: [data, options]
- * type T2 = PostDeferredCallbackArgs<undefined, string> // expected: [url, options]
- * type T3 = PostDeferredCallbackArgs // expected: [url, data, options]
- * type T4 = PostDeferredCallbackArgs<string, string> // expected: [options]
+ * 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 postDeferred()
- * const f1 = postDeferred({}, '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 = postDeferred({}, undefined, 'dome data')
+ * const f2 = fetch.post.deferred({}, undefined, 'dome data')
  * // expected: [url, options]
  * f2('https').then(console.log, console.warn)
  *
- * const f3 = postDeferred({})
+ * const f3 = fetch.post.deferred({})
  * // expected: [url, data, options]
  * f3('https://domain.com').then(console.log, console.warn)
  *
- * const f4 = postDeferred({}, 'url', 'data')
+ * const f4 = fetch.post.deferred({}, 'url', 'data')
  * // expected: [options]
  * f4().then(console.log, console.warn)
  * ```
  */
-type PostDeferredCbArgs<TUrl = undefined, TData = undefined, OmitMethod extends boolean = true, CbArgs extends PostArgs<OmitMethod> = PostArgs<OmitMethod>, Options = CbArgs[2], CbArgsReq extends unknown[] = Required<CbArgs>> = [TUrl, TData] extends [CbArgsReq[0], undefined] ? [data?: CbArgs[1], options?: Options] : [TUrl, TData] extends [undefined, CbArgsReq[1]] ? [url: CbArgs[0], options?: Options] : [TUrl, TData] extends [CbArgsReq[0], CbArgsReq[1]] ? [options?: Options] : CbArgs;
-type PostOptions = Omit<FetchOptions, 'method'> & {
+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'>;
 
-/** Create a method-specific fetch function attached with a `.deferred()` function */
-declare const createFetchMethodFunc: (method?: Pick<FetchOptions, "method">["method"]) => {
-    <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 | undefined): _superutils_promise.IPromisE<T>;
-    deferred<ThisArg = unknown, Delay extends number = number, GlobalUrl = string | URL | undefined, CbArgs extends unknown[] = undefined extends GlobalUrl ? FetchArgs<true> : [options?: Omit<FetchOptions, "method"> | undefined]>(deferOptions?: _superutils_promise.DeferredAsyncOptions<ThisArg, Delay> | undefined, defaultUrl?: GlobalUrl | undefined, defaultOptions?: FetchOptions | undefined): <TResult = unknown>(...args: undefined extends GlobalUrl ? FetchArgs<false> : [options?: FetchOptions | undefined]) => _superutils_promise.IPromisE<TResult>;
+/**
+ * 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)
+ * 		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: <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 */
+fixedOptions?: FixedOpts, 
+/** Common fetch options that can be overriden by individual request */
+commonOptions?: FetchOptions & CommonOpts, commonDeferOptions?: DeferredAsyncOptions<unknown, unknown>) => {
+    <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): IPromisE<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]) => IPromisE<TReturn_1>;
 };
 
 /**
- * Create a method-specific function for POST-like methods that automatically stringifies `data`
- * and attached with a `.deferred()` function
+ * 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
+ * 	},
+ * 	'https://dummyjson.com/products/1',
+ * 	{
+ * 		method: 'patch',
+ * 		timeout: 3000,
+ * 	},
+ * )
+ * updateProduct({ title: 'New title 1' }) // ignored by debounce
+ * updateProduct({ title: 'New title 2' }) // executed
+ * ```
  */
-declare const createPostMethodFunc: (method?: Pick<PostOptions, "method">["method"]) => {
-    <T, Args extends PostArgs<true> = PostArgs<true>>(url: Args[0], data?: Args[1], options?: Args[2]): _superutils_promise.IPromisE<T>;
-    deferred<ThisArg, Delay extends number = number, GlobalUrl extends PostArgs[0] | undefined = undefined, GlobalData extends PostArgs[1] | undefined = undefined, CbArgs extends unknown[] = PostDeferredCbArgs<GlobalUrl, GlobalData, true>>(deferOptions?: _superutils_promise.DeferredAsyncOptions<ThisArg, Delay> | undefined, defaultUrl?: GlobalUrl | undefined, defaultData?: GlobalData | undefined, defaultOptions?: PostOptions | undefined): <TResult = unknown>(...args: PostDeferredCbArgs<GlobalUrl, GlobalData, false, PostArgs<false>, PostOptions | undefined, [url: string | URL, data: PostBody | (() => PostBody), options: PostOptions]>) => _superutils_promise.IPromisE<TResult>;
+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 */
+fixedOptions?: FixedOpts, 
+/** Common fetch options that can be overriden by individual request */
+commonOptions?: PostOptions & CommonOpts, commonDeferOptions?: DeferredAsyncOptions<unknown, unknown>) => {
+    <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<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<TReturn_1>;
 };
 
+/**
+ * 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	interceptors interceptor 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, 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 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
@@ -354,7 +508,7 @@ declare const createPostMethodFunc: (method?: Pick<PostOptions, "method">["metho
  * ```
  */
 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<TReturn>;
     /** Default fetch options */
     defaults: FetchOptionsDefaults;
 };
@@ -363,12 +517,10 @@ declare const fetch: {
  * 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')
@@ -376,53 +528,120 @@ 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 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<TReturn>;
 
-declare const _get: {
-    <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 | undefined): _superutils_promise.IPromisE<T>;
-    deferred<ThisArg = unknown, Delay extends number = number, GlobalUrl = string | URL | undefined, CbArgs extends unknown[] = undefined extends GlobalUrl ? FetchArgs<true> : [options?: Omit<FetchOptions, "method"> | undefined]>(deferOptions?: _superutils_promise.DeferredAsyncOptions<ThisArg, Delay> | undefined, defaultUrl?: GlobalUrl | undefined, defaultOptions?: FetchOptions | undefined): <TResult = unknown>(...args: undefined extends GlobalUrl ? FetchArgs<false> : [options?: FetchOptions | undefined]) => _superutils_promise.IPromisE<TResult>;
-};
-declare const _head: {
-    <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 | undefined): _superutils_promise.IPromisE<T>;
-    deferred<ThisArg = unknown, Delay extends number = number, GlobalUrl = string | URL | undefined, CbArgs extends unknown[] = undefined extends GlobalUrl ? FetchArgs<true> : [options?: Omit<FetchOptions, "method"> | undefined]>(deferOptions?: _superutils_promise.DeferredAsyncOptions<ThisArg, Delay> | undefined, defaultUrl?: GlobalUrl | undefined, defaultOptions?: FetchOptions | undefined): <TResult = unknown>(...args: undefined extends GlobalUrl ? FetchArgs<false> : [options?: FetchOptions | undefined]) => _superutils_promise.IPromisE<TResult>;
-};
-declare const _options: {
-    <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 | undefined): _superutils_promise.IPromisE<T>;
-    deferred<ThisArg = unknown, Delay extends number = number, GlobalUrl = string | URL | undefined, CbArgs extends unknown[] = undefined extends GlobalUrl ? FetchArgs<true> : [options?: Omit<FetchOptions, "method"> | undefined]>(deferOptions?: _superutils_promise.DeferredAsyncOptions<ThisArg, Delay> | undefined, defaultUrl?: GlobalUrl | undefined, defaultOptions?: FetchOptions | undefined): <TResult = unknown>(...args: undefined extends GlobalUrl ? FetchArgs<false> : [options?: FetchOptions | undefined]) => _superutils_promise.IPromisE<TResult>;
-};
-declare const _delete: {
-    <T, Args extends PostArgs<true> = PostArgs<true>>(url: Args[0], data?: Args[1], options?: Args[2]): _superutils_promise.IPromisE<T>;
-    deferred<ThisArg, Delay extends number = number, GlobalUrl extends PostArgs[0] | undefined = undefined, GlobalData extends PostArgs[1] | undefined = undefined, CbArgs extends unknown[] = PostDeferredCbArgs<GlobalUrl, GlobalData, true>>(deferOptions?: _superutils_promise.DeferredAsyncOptions<ThisArg, Delay> | undefined, defaultUrl?: GlobalUrl | undefined, defaultData?: GlobalData | undefined, defaultOptions?: PostOptions | undefined): <TResult = unknown>(...args: PostDeferredCbArgs<GlobalUrl, GlobalData, false, PostArgs<false>, PostOptions | undefined, [url: string | URL, data: PostBody | (() => PostBody), options: PostOptions]>) => _superutils_promise.IPromisE<TResult>;
-};
-declare const _patch: {
-    <T, Args extends PostArgs<true> = PostArgs<true>>(url: Args[0], data?: Args[1], options?: Args[2]): _superutils_promise.IPromisE<T>;
-    deferred<ThisArg, Delay extends number = number, GlobalUrl extends PostArgs[0] | undefined = undefined, GlobalData extends PostArgs[1] | undefined = undefined, CbArgs extends unknown[] = PostDeferredCbArgs<GlobalUrl, GlobalData, true>>(deferOptions?: _superutils_promise.DeferredAsyncOptions<ThisArg, Delay> | undefined, defaultUrl?: GlobalUrl | undefined, defaultData?: GlobalData | undefined, defaultOptions?: PostOptions | undefined): <TResult = unknown>(...args: PostDeferredCbArgs<GlobalUrl, GlobalData, false, PostArgs<false>, PostOptions | undefined, [url: string | URL, data: PostBody | (() => PostBody), options: PostOptions]>) => _superutils_promise.IPromisE<TResult>;
-};
-declare const _post: {
-    <T, Args extends PostArgs<true> = PostArgs<true>>(url: Args[0], data?: Args[1], options?: Args[2]): _superutils_promise.IPromisE<T>;
-    deferred<ThisArg, Delay extends number = number, GlobalUrl extends PostArgs[0] | undefined = undefined, GlobalData extends PostArgs[1] | undefined = undefined, CbArgs extends unknown[] = PostDeferredCbArgs<GlobalUrl, GlobalData, true>>(deferOptions?: _superutils_promise.DeferredAsyncOptions<ThisArg, Delay> | undefined, defaultUrl?: GlobalUrl | undefined, defaultData?: GlobalData | undefined, defaultOptions?: PostOptions | undefined): <TResult = unknown>(...args: PostDeferredCbArgs<GlobalUrl, GlobalData, false, PostArgs<false>, PostOptions | undefined, [url: string | URL, data: PostBody | (() => PostBody), options: PostOptions]>) => _superutils_promise.IPromisE<TResult>;
-};
-declare const _put: {
-    <T, Args extends PostArgs<true> = PostArgs<true>>(url: Args[0], data?: Args[1], options?: Args[2]): _superutils_promise.IPromisE<T>;
-    deferred<ThisArg, Delay extends number = number, GlobalUrl extends PostArgs[0] | undefined = undefined, GlobalData extends PostArgs[1] | undefined = undefined, CbArgs extends unknown[] = PostDeferredCbArgs<GlobalUrl, GlobalData, true>>(deferOptions?: _superutils_promise.DeferredAsyncOptions<ThisArg, Delay> | undefined, defaultUrl?: GlobalUrl | undefined, defaultData?: GlobalData | undefined, defaultOptions?: PostOptions | undefined): <TResult = unknown>(...args: PostDeferredCbArgs<GlobalUrl, GlobalData, false, PostArgs<false>, PostOptions | undefined, [url: string | URL, data: PostBody | (() => PostBody), options: PostOptions]>) => _superutils_promise.IPromisE<TResult>;
-};
-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<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<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<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<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<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<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<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<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<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<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<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<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<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<TReturn>;
+    };
 };
 /**
  * A `fetch()` replacement that simplifies data fetching with automatic JSON parsing, request timeouts, retries,
@@ -465,49 +684,21 @@ 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.
+ * @param options.as (optional) (optional) specify how to parse the result. Default: {@link FetchAs.json}
+ * For raw `Response` use {@link FetchAs.response}
  * @param options.headers (optional) request headers
- * Default: `{ 'content-type': `'application/json' }` (unless changed in the fetch.defaults).
+ * Default: `{ 'content-type': 'application/json' }` (or whaterver is set in the `fetch.defaults`).
+ * @param options.interceptors (optional) request interceptor 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 if it takes longer.
  *
- * Options' default values (excluding `as`, `method` and `retryIf`) can be configured to be EFFECTIVE GLOBALLY.
- *
- * ```typescript
- * import fetch from '@superutils/fetch'
- *
- * 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,
- *     //........
- * }
- * ```
- *
- * @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')
@@ -516,7 +707,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
@@ -529,195 +720,60 @@ type FetchWithMethods = typeof fetchResponse & {
  * fetch.post('https://dummyjson.com/products/add', { title: 'Product title' })
  *     .then(product => console.log(product))
  * ```
- */
-declare const fetchDefault: FetchWithMethods;
-
-/**
- * Creates a deferred/throttled version of {@link fetch}, powered by {@link PromisE.deferred}.
- * This is ideal for scenarios requiring advanced control over HTTP requests, such as debouncing search inputs,
- * throttling API calls, or ensuring sequential request execution.
  *
- * It leverages the robust capabilities of the underlying {@link fetch} function, which includes features like request timeouts and manual abortion.
- * `fetchDeferred` uses this to automatically abort pending requests when a new one is initiated, preventing race conditions and redundant network traffic.
  *
- * @param deferOptions Configuration for the deferred execution behavior (e.g., `delayMs`, `throttle`).
- * See {@link DeferredAsyncOptions} for details.
- * @param defaultUrl (optional) If a global URL is `undefined`, returned callback will always require an URL.
- * @param defaultOptions (optional) Default {@link FetchOptions} to be used by the returned function.
- * Default options will be merged with the options provided in the callback.
- * If the same property is provided in both cases, defaults will be overriden by the callback.
+ * @example Set default options.
  *
- * @example Debounce/Throttle requests for an auto-complete search input
- * ```typescript
- * import { fetchDeferred, ResolveIgnored } from '@superutils/fetch'
- *
- * // Create a debounced search function with a 300ms delay.
- * const searchProducts = fetchDeferred({
- * 	delayMs: 300, // Debounce delay
- * 	resolveIgnored: ResolveIgnored.WITH_UNDEFINED, // Ignored (aborted) promises will resolve with `undefined`
- * })
- *
- * // User types 'iphone'
- * searchProducts('https://dummyjson.com/products/search?q=iphone').then(result => {
- *   console.log('Result for "iphone":', result);
- * });
- *
- * // Before 300ms has passed, the user continues typing 'iphone 9'
- * setTimeout(() => {
- *   searchProducts('https://dummyjson.com/products/search?q=iphone 9').then(result => {
- *     console.log('Result for "iphone 9":', result);
- *   });
- * }, 200);
- *
- * // Outcome:
- * // The first request for "iphone" is aborted.
- * // The first promise resolves with `undefined`.
- * // The second request for "iphone 9" is executed after the 300ms debounce delay.
- * ```
+ * Options' default values (excluding `as` and `method`) can be configured to be EFFECTIVE GLOBALLY.
  *
- * @example Creating a reusable, pre-configured client
  * ```typescript
- * import { fetchDeferred, ResolveIgnored } from '@superutils/fetch'
- *
- * // Create a throttled function to fetch a random quote.
- * // The URL and a 3-second timeout are set as defaults, creating a reusable client.
- * const getRandomQuote = fetchDeferred(
- * 	{
- * 		delayMs: 300, // Throttle window
- * 		throttle: true,
- *      // Ignored calls will resolve with the result of the last successful call.
- * 		resolveIgnored: ResolveIgnored.WITH_LAST,
- * 	},
- * 	'https://dummyjson.com/quotes/random', // Default URL
- * 	{ timeout: 3000 }, // Default fetch options
- * )
- *
- * // Call the function multiple times in quick succession.
- * getRandomQuote().then(quote => console.log('Call 1 resolved:', quote.id));
- * getRandomQuote().then(quote => console.log('Call 2 resolved:', quote.id));
- * getRandomQuote().then(quote => console.log('Call 3 resolved:', quote.id));
+ * import fetch from '@superutils/fetch'
  *
- * // Outcome:
- * // Due to throttling, only one network request is made.
- * // Because `resolveIgnored` is `WITH_LAST`, all three promises resolve with the same quote.
- * // The promises for the two ignored calls resolve as soon as the first successful call resolves.
- * // Console output will show the same quote ID for all three calls.
+ * 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,
+ *     //........
+ * }
  * ```
  */
-declare function fetchDeferred<ThisArg = unknown, Delay extends number = number, DefaultUrl = FetchArgs[0] | undefined, CbArgs extends unknown[] = undefined extends DefaultUrl ? FetchArgs<false> : [options?: FetchArgs<false>[1]]>(deferOptions?: DeferredAsyncOptions<ThisArg, Delay>, defaultUrl?: DefaultUrl, defaultOptions?: FetchArgs[1]): <TResult = unknown>(...args: CbArgs) => _superutils_promise.IPromisE<TResult>;
+declare const fetchDefault: typeof fetchResponse & typeof methods;
 
 /**
- * Creates a deferred/throttled function for making `DELETE`, `POST`, `PUT`, or `PATCH` requests, powered by
- * {@link PromisE.deferred}.
- *
- * This is ideal for scenarios like auto-saving form data, preventing duplicate submissions on button clicks,
- * or throttling API updates.
- *
- * Like `fetchDeferred`, it automatically aborts pending requests when a new one is initiated, ensuring only
- * the most recent or relevant action is executed.
+ * Add AbortController to options if not present and propagate external abort signal if provided.
  *
- * @param deferOptions Configuration for the deferred execution behavior (e.g., `delayMs`, `throttle`).
- * See {@link DeferredAsyncOptions} for details.
- * @param defaultUrl (optional) If default URL is `undefined`, returned callback will always require an URL.
- * @param defaultData (optional) If default data is `undefined`, returned callback will allow a data parameter.
- * @param defaultOptions (optional) Default {@link FetchOptions} to be used by the returned function.
- * Default options will be merged with the options provided in the callback.
- * If the same property is provided in both cases, defaults will be overriden by the callback.
+ * @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`.
  *
- * #### Example 1: Auto-saving form data with throttling
- *
- * ```typescript
- * import fetch from '@superutils/fetch'
- * import PromisE from '@superutils/promise'
- *
- * // Create a throttled function to auto-save product updates.
- * const saveProductThrottled = fetch.post.deferred(
- * 	{
- * 		delayMs: 1000, // Throttle window of 1 second
- * 		throttle: true,
- * 		trailing: true, // Ensures the very last update is always saved
- * 		onResult: product => console.log(`[Saved] Product: ${product.title}`),
- * 	},
- * 	'https://dummyjson.com/products/add', // Default URL
- * )
- * // Simulate a user typing quickly, triggering multiple saves.
- * console.log('User starts typing...')
- *
- * // Executed immediately (leading edge)
- * saveProductThrottled({ title: 'iPhone' })
- * // Ignored (within 1000ms throttle window)
- * PromisE.delay(200, () => saveProductThrottled({ title: 'iPhone 15' }))
- * // Ignored
- * PromisE.delay(300, () => saveProductThrottled({ title: 'iPhone 15 Pro' }))
- * // Queued to execute on the trailing edge
- * PromisE.delay(400, () => saveProductThrottled({ title: 'iPhone 15 Pro Max' }))
- * // Outcome:
- * // The first call ('iPhone') is executed immediately.
- * // The next two calls are ignored by the throttle.
- * // The final call ('iPhone 15 Pro Max') is executed after the 1000ms throttle window closes,
- * // thanks to `trailing: true`.
- * // This results in only two network requests instead of four.
- * ```
- *
- * #### Example 2: debouncing an authentication token refresh
- *
- * ```typescript
- * import fetch from '@superutils/fetch'
- * import PromisE from '@superutils/promise'
- *
- * // Mock a simple token store
- * let currentRefreshToken = ''
- * // Create a debounced function to refresh the auth token.
- * // It waits 300ms after the last call before executing.
- * const requestNewToken = fetch.post.deferred(
- * 	{
- * 		delayMs: 300, // debounce delay
- * 		onResult: ({ refreshToken = '' }) => {
- * 			console.log(
- * 				`Auth token successfully refreshed at ${new Date().toISOString()}`,
- * 			)
- * 			currentRefreshToken = refreshToken
- * 		},
- * 	},
- * 	'https://dummyjson.com/auth/refresh', // Default URL
- * 	() => ({
- * 		refreshToken: currentRefreshToken,
- * 		expiresInMins: 30,
- * 	}),
- * )
+ * @param url request URL
+ * @param options (optional)
  *
- * // First authenticate user to get the initial refresh token and then request new referesh tokens
- * fetch
- * 	.post<{ refreshToken: string }>(
- * 		'https://dummyjson.com/auth/login',
- * 		{
- * 			username: 'emilys',
- * 			password: 'emilyspass',
- * 			expiresInMins: 30,
- * 		},
- * 		{ credentials: 'include' },
- * 	)
- * 	.then(result => {
- * 		currentRefreshToken = result?.refreshToken
- *
- * 		requestNewToken() // Called at 0ms
- * 		PromisE.delay(50, requestNewToken) // Called at 50ms
- * 		PromisE.delay(100, requestNewToken) // Called at 100ms
- * 	}, console.error)
- * // Outcome:
- * // The first two calls are aborted by the debounce mechanism.
- * // Only the final call executes, 300ms after it was made (at the 400ms mark).
- * // The token is refreshed only once, preventing redundant network requests.
- * ```
+ * @returns response
  */
-declare function postDeferred<ThisArg, Delay = unknown, DefaultUrl extends PostArgs[0] | undefined = undefined, DefaultData extends PostArgs[1] | undefined = undefined, CbArgs extends unknown[] = PostDeferredCbArgs<DefaultUrl, DefaultData, false>>(deferOptions?: DeferredAsyncOptions<ThisArg, Delay>, defaultUrl?: DefaultUrl, defaultData?: DefaultData, defaultOptions?: PostArgs[2]): <TResult = unknown>(...args: CbArgs) => _superutils_promise.IPromisE<TResult>;
+declare const getResponse: (url: FetchArgs[0], options?: FetchArgs[1]) => Promise<Response>;
 
 /**
  * Merge one or more {@link FetchOptions}
  *
  * Notes:
- * - {@link config.fetchOptions} will be added as the base and not necessary to be included
  * - item properties will be prioritized in the order of sequence they were passed in
  * - the following properties will be merged
  *     * `errMsgs`
@@ -729,4 +785,7 @@ declare function postDeferred<ThisArg, Delay = unknown, DefaultUrl extends PostA
  */
 declare const mergeFetchOptions: (...allOptions: FetchOptions[]) => FetchOptionsInterceptor;
 
-export { type FetchArgs, type FetchArgsInterceptor, FetchAs, 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, createFetchMethodFunc, createPostMethodFunc, fetchDefault as default, fetch, fetchDeferred, fetchResponse, mergeFetchOptions, postDeferred };
+/** 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 { 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 FetchOptionsDefaults, type FetchOptionsInterceptor, type FetchResult, type FetchRetryOptions, type Interceptor, type PostArgs, type PostBody, type PostDeferredCbArgs, type PostOptions, createClient, createPostClient, fetchDefault as default, executeInterceptors, fetch, fetchResponse, getAbortCtrl, getResponse, mergeFetchOptions, mergePartialOptions };