@zayne-labs/callapi 1.7.18 → 1.8.1

package/dist/esm/index.js

@@ -1,729 +1,738 @@
-import { splitConfig, isFunction, splitBaseConfig, createTimeoutSignal, createCombinedSignal, commonDefaults, getHeaders, isSerializable, HTTPError, isHTTPErrorInstance, waitFor, hookDefaults, dedupeDefaults, responseDefaults, retryDefaults, isArray, isPlainObject, isString, toQueryString, getFetchImpl, isReadableStream, isHTTPError, requestOptionDefaults, isObject } from './chunk-F56CKRKR.js';
-export { HTTPError } from './chunk-F56CKRKR.js';
+import { HTTPError, ValidationError, commonDefaults, createCombinedSignal, createTimeoutSignal, dedupeDefaults, defineSchema, getBody, getFetchImpl, getHeaders, handleOptionsValidation, handleValidation, hookDefaults, isArray, isFunction, isHTTPError, isHTTPErrorInstance, isObject, isPlainObject, isReadableStream, isString, isValidationErrorInstance, requestOptionDefaults, responseDefaults, retryDefaults, routeKeyMethods, splitBaseConfig, splitConfig, toQueryString, waitFor } from "./utils-D6Sax78G.js";
 
-// src/result.ts
-var getResponseType = (response, parser) => ({
-  arrayBuffer: () => response.arrayBuffer(),
-  blob: () => response.blob(),
-  formData: () => response.formData(),
-  json: async () => {
-    const text = await response.text();
-    return parser(text);
-  },
-  stream: () => response.body,
-  text: () => response.text()
+//#region src/result.ts
+const getResponseType = (response, parser) => ({
+	arrayBuffer: () => response.arrayBuffer(),
+	blob: () => response.blob(),
+	formData: () => response.formData(),
+	json: async () => {
+		const text = await response.text();
+		return parser(text);
+	},
+	stream: () => response.body,
+	text: () => response.text()
 });
-var resolveResponseData = (response, responseType, parser) => {
-  const selectedParser = parser ?? responseDefaults.responseParser;
-  const selectedResponseType = responseType ?? responseDefaults.responseType;
-  const RESPONSE_TYPE_LOOKUP = getResponseType(response, selectedParser);
-  if (!Object.hasOwn(RESPONSE_TYPE_LOOKUP, selectedResponseType)) {
-    throw new Error(`Invalid response type: ${responseType}`);
-  }
-  return RESPONSE_TYPE_LOOKUP[selectedResponseType]();
+const resolveResponseData = (response, responseType, parser) => {
+	const selectedParser = parser ?? responseDefaults.responseParser;
+	const selectedResponseType = responseType ?? responseDefaults.responseType;
+	const RESPONSE_TYPE_LOOKUP = getResponseType(response, selectedParser);
+	if (!Object.hasOwn(RESPONSE_TYPE_LOOKUP, selectedResponseType)) throw new Error(`Invalid response type: ${responseType}`);
+	return RESPONSE_TYPE_LOOKUP[selectedResponseType]();
 };
-var getResultModeMap = (details) => {
-  const resultModeMap = {
-    all: () => details,
-    allWithException: () => resultModeMap.all(),
-    onlySuccess: () => details.data,
-    onlySuccessWithException: () => resultModeMap.onlySuccess()
-  };
-  return resultModeMap;
+const getResultModeMap = (details) => {
+	const resultModeMap = {
+		all: () => details,
+		allWithException: () => resultModeMap.all(),
+		onlySuccess: () => details.data,
+		onlySuccessWithException: () => resultModeMap.onlySuccess()
+	};
+	return resultModeMap;
 };
-var resolveSuccessResult = (data, info) => {
-  const { response, resultMode } = info;
-  const details = {
-    data,
-    error: null,
-    response
-  };
-  const resultModeMap = getResultModeMap(details);
-  const successResult = resultModeMap[resultMode ?? "all"]();
-  return successResult;
+const resolveSuccessResult = (data, info) => {
+	const { response, resultMode } = info;
+	const details = {
+		data,
+		error: null,
+		response
+	};
+	const resultModeMap = getResultModeMap(details);
+	const successResult = resultModeMap[resultMode ?? "all"]();
+	return successResult;
 };
-var resolveErrorResult = (error, info) => {
-  const { cloneResponse, defaultErrorMessage, message: customErrorMessage, resultMode } = info;
-  let details = {
-    data: null,
-    error: {
-      errorData: error,
-      message: customErrorMessage ?? error.message,
-      name: error.name,
-      originalError: error
-    },
-    response: null
-  };
-  if (isHTTPErrorInstance(error)) {
-    const selectedDefaultErrorMessage = defaultErrorMessage ?? commonDefaults.defaultErrorMessage;
-    const { errorData, message = selectedDefaultErrorMessage, name, response } = error;
-    details = {
-      data: null,
-      error: {
-        errorData,
-        message,
-        name,
-        originalError: error
-      },
-      response: cloneResponse ? response.clone() : response
-    };
-  }
-  const resultModeMap = getResultModeMap(details);
-  const errorResult = resultModeMap[resultMode ?? "all"]();
-  return errorResult;
+const resolveErrorResult = (error, info) => {
+	const { cloneResponse, defaultErrorMessage, message: customErrorMessage, resultMode } = info;
+	let details = {
+		data: null,
+		error: {
+			errorData: error,
+			message: customErrorMessage ?? error.message,
+			name: error.name,
+			originalError: error
+		},
+		response: null
+	};
+	if (isValidationErrorInstance(error)) {
+		const { errorData, message, response } = error;
+		details = {
+			data: null,
+			error: {
+				errorData,
+				message,
+				name: "ValidationError",
+				originalError: error
+			},
+			response
+		};
+	}
+	if (isHTTPErrorInstance(error)) {
+		const selectedDefaultErrorMessage = defaultErrorMessage ?? commonDefaults.defaultErrorMessage;
+		const { errorData, message = selectedDefaultErrorMessage, name, response } = error;
+		details = {
+			data: null,
+			error: {
+				errorData,
+				message,
+				name,
+				originalError: error
+			},
+			response: cloneResponse ? response.clone() : response
+		};
+	}
+	const resultModeMap = getResultModeMap(details);
+	const errorResult = resultModeMap[resultMode ?? "all"]();
+	return errorResult;
 };
-var getCustomizedErrorResult = (errorResult, customErrorInfo) => {
-  if (!errorResult) {
-    return null;
-  }
-  const { message = errorResult.error.message } = customErrorInfo;
-  return {
-    ...errorResult,
-    error: {
-      ...errorResult.error,
-      message
-    }
-  };
+const getCustomizedErrorResult = (errorResult, customErrorInfo) => {
+	if (!errorResult) return null;
+	const { message = errorResult.error.message } = customErrorInfo;
+	return {
+		...errorResult,
+		error: {
+			...errorResult.error,
+			message
+		}
+	};
 };
 
-// src/hooks.ts
-var hookRegistries = {
-  onError: /* @__PURE__ */ new Set(),
-  onRequest: /* @__PURE__ */ new Set(),
-  onRequestError: /* @__PURE__ */ new Set(),
-  onRequestStream: /* @__PURE__ */ new Set(),
-  onResponse: /* @__PURE__ */ new Set(),
-  onResponseError: /* @__PURE__ */ new Set(),
-  onResponseStream: /* @__PURE__ */ new Set(),
-  onRetry: /* @__PURE__ */ new Set(),
-  onSuccess: /* @__PURE__ */ new Set()
+//#endregion
+//#region src/hooks.ts
+const hookRegistries = {
+	onError: /* @__PURE__ */ new Set(),
+	onRequest: /* @__PURE__ */ new Set(),
+	onRequestError: /* @__PURE__ */ new Set(),
+	onRequestStream: /* @__PURE__ */ new Set(),
+	onResponse: /* @__PURE__ */ new Set(),
+	onResponseError: /* @__PURE__ */ new Set(),
+	onResponseStream: /* @__PURE__ */ new Set(),
+	onRetry: /* @__PURE__ */ new Set(),
+	onSuccess: /* @__PURE__ */ new Set(),
+	onValidationError: /* @__PURE__ */ new Set()
 };
-var composeTwoHooks = (hooks, mergedHooksExecutionMode) => {
-  if (hooks.length === 0) return;
-  const mergedHook = async (ctx) => {
-    if (mergedHooksExecutionMode === "sequential") {
-      for (const hook of hooks) {
-        await hook?.(ctx);
-      }
-      return;
-    }
-    if (mergedHooksExecutionMode === "parallel") {
-      const hookArray = [...hooks];
-      await Promise.all(hookArray.map((uniqueHook) => uniqueHook?.(ctx)));
-    }
-  };
-  return mergedHook;
+const composeTwoHooks = (hooks, mergedHooksExecutionMode) => {
+	if (hooks.length === 0) return;
+	const mergedHook = async (ctx) => {
+		if (mergedHooksExecutionMode === "sequential") {
+			for (const hook of hooks) await hook?.(ctx);
+			return;
+		}
+		if (mergedHooksExecutionMode === "parallel") {
+			const hookArray = [...hooks];
+			await Promise.all(hookArray.map((uniqueHook) => uniqueHook?.(ctx)));
+		}
+	};
+	return mergedHook;
 };
-var executeHooksInTryBlock = async (...hookResultsOrPromise) => {
-  await Promise.all(hookResultsOrPromise);
+const executeHooksInTryBlock = async (...hookResultsOrPromise) => {
+	await Promise.all(hookResultsOrPromise);
 };
-var executeHooksInCatchBlock = async (hookResultsOrPromise, hookInfo) => {
-  const { errorInfo, shouldThrowOnError } = hookInfo;
-  try {
-    await Promise.all(hookResultsOrPromise);
-    return null;
-  } catch (hookError) {
-    const hookErrorResult = resolveErrorResult(hookError, errorInfo);
-    if (shouldThrowOnError) {
-      throw hookError;
-    }
-    return hookErrorResult;
-  }
+const executeHooksInCatchBlock = async (hookResultsOrPromise, hookInfo) => {
+	const { errorInfo, shouldThrowOnError } = hookInfo;
+	try {
+		await Promise.all(hookResultsOrPromise);
+		return null;
+	} catch (hookError) {
+		const hookErrorResult = resolveErrorResult(hookError, errorInfo);
+		if (shouldThrowOnError) throw hookError;
+		return hookErrorResult;
+	}
 };
 
-// src/stream.ts
-var createProgressEvent = (options) => {
-  const { chunk, totalBytes, transferredBytes } = options;
-  return {
-    chunk,
-    progress: Math.round(transferredBytes / totalBytes * 100) || 0,
-    totalBytes,
-    transferredBytes
-  };
+//#endregion
+//#region src/stream.ts
+const createProgressEvent = (options) => {
+	const { chunk, totalBytes, transferredBytes } = options;
+	return {
+		chunk,
+		progress: Math.round(transferredBytes / totalBytes * 100) || 0,
+		totalBytes,
+		transferredBytes
+	};
 };
-var calculateTotalBytesFromBody = async (requestBody, existingTotalBytes) => {
-  let totalBytes = existingTotalBytes;
-  if (!requestBody) {
-    return totalBytes;
-  }
-  for await (const chunk of requestBody) {
-    totalBytes += chunk.byteLength;
-  }
-  return totalBytes;
+const calculateTotalBytesFromBody = async (requestBody, existingTotalBytes) => {
+	let totalBytes = existingTotalBytes;
+	if (!requestBody) return totalBytes;
+	for await (const chunk of requestBody) totalBytes += chunk.byteLength;
+	return totalBytes;
 };
-var toStreamableRequest = async (context) => {
-  const { baseConfig, config, options, request, requestInstance } = context;
-  if (!options.onRequestStream || !requestInstance.body) return;
-  const contentLength = requestInstance.headers.get("content-length") ?? new Headers(request.headers).get("content-length") ?? request.body?.size;
-  let totalBytes = Number(contentLength ?? 0);
-  const shouldForceContentLengthCalc = isObject(options.forceCalculateStreamSize) ? options.forceCalculateStreamSize.request : options.forceCalculateStreamSize;
-  if (!contentLength && shouldForceContentLengthCalc) {
-    totalBytes = await calculateTotalBytesFromBody(requestInstance.clone().body, totalBytes);
-  }
-  let transferredBytes = 0;
-  await executeHooksInTryBlock(
-    options.onRequestStream({
-      baseConfig,
-      config,
-      event: createProgressEvent({ chunk: new Uint8Array(), totalBytes, transferredBytes }),
-      options,
-      request,
-      requestInstance
-    })
-  );
-  const body = requestInstance.body;
-  void new ReadableStream({
-    start: async (controller) => {
-      if (!body) return;
-      for await (const chunk of body) {
-        transferredBytes += chunk.byteLength;
-        totalBytes = Math.max(totalBytes, transferredBytes);
-        await executeHooksInTryBlock(
-          options.onRequestStream?.({
-            baseConfig,
-            config,
-            event: createProgressEvent({ chunk, totalBytes, transferredBytes }),
-            options,
-            request,
-            requestInstance
-          })
-        );
-        controller.enqueue(chunk);
-      }
-      controller.close();
-    }
-  });
+const toStreamableRequest = async (context) => {
+	const { baseConfig, config, options, request, requestInstance } = context;
+	if (!options.onRequestStream || !requestInstance.body) return;
+	const contentLength = requestInstance.headers.get("content-length") ?? new Headers(request.headers).get("content-length") ?? request.body?.size;
+	let totalBytes = Number(contentLength ?? 0);
+	const shouldForceContentLengthCalc = isObject(options.forceCalculateStreamSize) ? options.forceCalculateStreamSize.request : options.forceCalculateStreamSize;
+	if (!contentLength && shouldForceContentLengthCalc) totalBytes = await calculateTotalBytesFromBody(requestInstance.clone().body, totalBytes);
+	let transferredBytes = 0;
+	await executeHooksInTryBlock(options.onRequestStream({
+		baseConfig,
+		config,
+		event: createProgressEvent({
+			chunk: new Uint8Array(),
+			totalBytes,
+			transferredBytes
+		}),
+		options,
+		request,
+		requestInstance
+	}));
+	const body = requestInstance.body;
+	new ReadableStream({ start: async (controller) => {
+		if (!body) return;
+		for await (const chunk of body) {
+			transferredBytes += chunk.byteLength;
+			totalBytes = Math.max(totalBytes, transferredBytes);
+			await executeHooksInTryBlock(options.onRequestStream?.({
+				baseConfig,
+				config,
+				event: createProgressEvent({
+					chunk,
+					totalBytes,
+					transferredBytes
+				}),
+				options,
+				request,
+				requestInstance
+			}));
+			controller.enqueue(chunk);
+		}
+		controller.close();
+	} });
 };
-var toStreamableResponse = async (context) => {
-  const { baseConfig, config, options, request, response } = context;
-  if (!options.onResponseStream || !response.body) {
-    return response;
-  }
-  const contentLength = response.headers.get("content-length");
-  let totalBytes = Number(contentLength ?? 0);
-  const shouldForceContentLengthCalc = isObject(options.forceCalculateStreamSize) ? options.forceCalculateStreamSize.response : options.forceCalculateStreamSize;
-  if (!contentLength && shouldForceContentLengthCalc) {
-    totalBytes = await calculateTotalBytesFromBody(response.clone().body, totalBytes);
-  }
-  let transferredBytes = 0;
-  await executeHooksInTryBlock(
-    options.onResponseStream({
-      baseConfig,
-      config,
-      event: createProgressEvent({ chunk: new Uint8Array(), totalBytes, transferredBytes }),
-      options,
-      request,
-      response
-    })
-  );
-  const body = response.body;
-  const stream = new ReadableStream({
-    start: async (controller) => {
-      if (!body) return;
-      for await (const chunk of body) {
-        transferredBytes += chunk.byteLength;
-        totalBytes = Math.max(totalBytes, transferredBytes);
-        await executeHooksInTryBlock(
-          options.onResponseStream?.({
-            baseConfig,
-            config,
-            event: createProgressEvent({ chunk, totalBytes, transferredBytes }),
-            options,
-            request,
-            response
-          })
-        );
-        controller.enqueue(chunk);
-      }
-      controller.close();
-    }
-  });
-  return new Response(stream, response);
+const toStreamableResponse = async (context) => {
+	const { baseConfig, config, options, request, response } = context;
+	if (!options.onResponseStream || !response.body) return response;
+	const contentLength = response.headers.get("content-length");
+	let totalBytes = Number(contentLength ?? 0);
+	const shouldForceContentLengthCalc = isObject(options.forceCalculateStreamSize) ? options.forceCalculateStreamSize.response : options.forceCalculateStreamSize;
+	if (!contentLength && shouldForceContentLengthCalc) totalBytes = await calculateTotalBytesFromBody(response.clone().body, totalBytes);
+	let transferredBytes = 0;
+	await executeHooksInTryBlock(options.onResponseStream({
+		baseConfig,
+		config,
+		event: createProgressEvent({
+			chunk: new Uint8Array(),
+			totalBytes,
+			transferredBytes
+		}),
+		options,
+		request,
+		response
+	}));
+	const body = response.body;
+	const stream = new ReadableStream({ start: async (controller) => {
+		if (!body) return;
+		for await (const chunk of body) {
+			transferredBytes += chunk.byteLength;
+			totalBytes = Math.max(totalBytes, transferredBytes);
+			await executeHooksInTryBlock(options.onResponseStream?.({
+				baseConfig,
+				config,
+				event: createProgressEvent({
+					chunk,
+					totalBytes,
+					transferredBytes
+				}),
+				options,
+				request,
+				response
+			}));
+			controller.enqueue(chunk);
+		}
+		controller.close();
+	} });
+	return new Response(stream, response);
 };
 
-// src/dedupe.ts
-var createDedupeStrategy = async (context) => {
-  const { $RequestInfoCache, baseConfig, config, newFetchController, options, request } = context;
-  const dedupeStrategy = options.dedupeStrategy ?? dedupeDefaults.dedupeStrategy;
-  const generateDedupeKey = () => {
-    const shouldHaveDedupeKey = dedupeStrategy === "cancel" || dedupeStrategy === "defer";
-    if (!shouldHaveDedupeKey) {
-      return null;
-    }
-    return `${options.fullURL}-${JSON.stringify({ options, request })}`;
-  };
-  const dedupeKey = options.dedupeKey ?? generateDedupeKey();
-  const $RequestInfoCacheOrNull = dedupeKey !== null ? $RequestInfoCache : null;
-  if (dedupeKey !== null) {
-    await waitFor(0.1);
-  }
-  const prevRequestInfo = $RequestInfoCacheOrNull?.get(dedupeKey);
-  const handleRequestCancelStrategy = () => {
-    const shouldCancelRequest = prevRequestInfo && dedupeStrategy === "cancel";
-    if (!shouldCancelRequest) return;
-    const message = options.dedupeKey ? `Duplicate request detected - Aborting previous request with key '${options.dedupeKey}' as a new request was initiated` : `Duplicate request detected - Aborting previous request to '${options.fullURL}' as a new request with identical options was initiated`;
-    const reason = new DOMException(message, "AbortError");
-    prevRequestInfo.controller.abort(reason);
-    return Promise.resolve();
-  };
-  const handleRequestDeferStrategy = async () => {
-    const fetchApi = getFetchImpl(options.customFetchImpl);
-    const shouldUsePromiseFromCache = prevRequestInfo && dedupeStrategy === "defer";
-    const requestInstance = new Request(
-      options.fullURL,
-      isReadableStream(request.body) && !request.duplex ? { ...request, duplex: "half" } : request
-    );
-    await toStreamableRequest({
-      baseConfig,
-      config,
-      options,
-      request,
-      requestInstance: requestInstance.clone()
-    });
-    const getFetchApiPromise = () => {
-      if (isReadableStream(request.body)) {
-        return fetchApi(requestInstance.clone());
-      }
-      const method = request.method ?? requestOptionDefaults.method;
-      const modifiedRequest = { ...request, method };
-      return fetchApi(options.fullURL, modifiedRequest);
-    };
-    const responsePromise = shouldUsePromiseFromCache ? prevRequestInfo.responsePromise : getFetchApiPromise();
-    $RequestInfoCacheOrNull?.set(dedupeKey, { controller: newFetchController, responsePromise });
-    const streamableResponse = toStreamableResponse({
-      baseConfig,
-      config,
-      options,
-      request,
-      response: await responsePromise
-    });
-    return streamableResponse;
-  };
-  const removeDedupeKeyFromCache = () => {
-    $RequestInfoCacheOrNull?.delete(dedupeKey);
-  };
-  return {
-    dedupeStrategy,
-    handleRequestCancelStrategy,
-    handleRequestDeferStrategy,
-    removeDedupeKeyFromCache
-  };
+//#endregion
+//#region src/dedupe.ts
+const getAbortErrorMessage = (dedupeKey, fullURL) => {
+	return dedupeKey ? `Duplicate request detected - Aborting previous request with key '${dedupeKey}' as a new request was initiated` : `Duplicate request detected - Aborting previous request to '${fullURL}' as a new request with identical options was initiated`;
+};
+const createDedupeStrategy = async (context) => {
+	const { $RequestInfoCache, baseConfig, config, newFetchController, options: globalOptions, request: globalRequest } = context;
+	const dedupeStrategy = globalOptions.dedupeStrategy ?? dedupeDefaults.dedupeStrategy;
+	const generateDedupeKey = () => {
+		const shouldHaveDedupeKey = dedupeStrategy === "cancel" || dedupeStrategy === "defer";
+		if (!shouldHaveDedupeKey) return null;
+		return `${globalOptions.fullURL}-${JSON.stringify({
+			options: globalOptions,
+			request: globalRequest
+		})}`;
+	};
+	const dedupeKey = globalOptions.dedupeKey ?? generateDedupeKey();
+	const $RequestInfoCacheOrNull = dedupeKey !== null ? $RequestInfoCache : null;
+	/******
+	* == Add a small delay to the execution to ensure proper request deduplication when multiple requests with the same key start simultaneously.
+	* == This gives time for the cache to be updated with the previous request info before the next request checks it.
+	******/
+	if (dedupeKey !== null) await waitFor(.1);
+	const prevRequestInfo = $RequestInfoCacheOrNull?.get(dedupeKey);
+	const handleRequestCancelStrategy = () => {
+		const shouldCancelRequest = prevRequestInfo && dedupeStrategy === "cancel";
+		if (!shouldCancelRequest) return;
+		const message = getAbortErrorMessage(globalOptions.dedupeKey, globalOptions.fullURL);
+		const reason = new DOMException(message, "AbortError");
+		prevRequestInfo.controller.abort(reason);
+		return Promise.resolve();
+	};
+	const handleRequestDeferStrategy = async (options, request) => {
+		const fetchApi = getFetchImpl(options.customFetchImpl);
+		const shouldUsePromiseFromCache = prevRequestInfo && dedupeStrategy === "defer";
+		const requestObjectForStream = isReadableStream(request.body) ? {
+			...request,
+			duplex: request.duplex ?? "half"
+		} : request;
+		const requestInstance = new Request(options.fullURL, requestObjectForStream);
+		await toStreamableRequest({
+			baseConfig,
+			config,
+			options,
+			request,
+			requestInstance: requestInstance.clone()
+		});
+		const getFetchApiPromise = () => {
+			if (isReadableStream(request.body)) return fetchApi(requestInstance.clone());
+			return fetchApi(options.fullURL, request);
+		};
+		const responsePromise = shouldUsePromiseFromCache ? prevRequestInfo.responsePromise : getFetchApiPromise();
+		$RequestInfoCacheOrNull?.set(dedupeKey, {
+			controller: newFetchController,
+			responsePromise
+		});
+		const streamableResponse = toStreamableResponse({
+			baseConfig,
+			config,
+			options,
+			request,
+			response: await responsePromise
+		});
+		return streamableResponse;
+	};
+	const removeDedupeKeyFromCache = () => {
+		$RequestInfoCacheOrNull?.delete(dedupeKey);
+	};
+	return {
+		dedupeStrategy,
+		handleRequestCancelStrategy,
+		handleRequestDeferStrategy,
+		removeDedupeKeyFromCache
+	};
 };
 
-// src/plugins.ts
-var definePlugin = (plugin) => {
-  return plugin;
+//#endregion
+//#region src/plugins.ts
+const definePlugin = (plugin) => {
+	return plugin;
 };
-var resolvePluginArray = (plugins, basePlugins) => {
-  if (!plugins) {
-    return [];
-  }
-  if (isFunction(plugins)) {
-    return plugins({ basePlugins: basePlugins ?? [] });
-  }
-  return plugins;
+const resolvePluginArray = (plugins, basePlugins) => {
+	if (!plugins) return [];
+	if (isFunction(plugins)) return plugins({ basePlugins: basePlugins ?? [] });
+	return plugins;
 };
-var initializePlugins = async (context) => {
-  const { baseConfig, config, initURL, options, request } = context;
-  const clonedHookRegistries = structuredClone(hookRegistries);
-  const addMainHooks = () => {
-    for (const key of Object.keys(clonedHookRegistries)) {
-      const baseHook = baseConfig[key];
-      const instanceHook = config[key];
-      const overriddenHook = options[key];
-      const mainHook = isArray(baseHook) && Boolean(instanceHook) ? [baseHook, instanceHook].flat() : overriddenHook;
-      if (!mainHook) continue;
-      clonedHookRegistries[key].add(mainHook);
-    }
-  };
-  const addPluginHooks = (pluginHooks) => {
-    for (const key of Object.keys(clonedHookRegistries)) {
-      const pluginHook = pluginHooks[key];
-      if (!pluginHook) continue;
-      clonedHookRegistries[key].add(pluginHook);
-    }
-  };
-  const mergedHooksExecutionOrder = options.mergedHooksExecutionOrder ?? hookDefaults.mergedHooksExecutionOrder;
-  if (mergedHooksExecutionOrder === "mainHooksBeforePlugins") {
-    addMainHooks();
-  }
-  const resolvedPlugins = resolvePluginArray(options.plugins, baseConfig.plugins);
-  let resolvedUrl = initURL;
-  let resolvedOptions = options;
-  let resolvedRequestOptions = request;
-  const executePluginInit = async (pluginInit) => {
-    if (!pluginInit) return;
-    const initResult = await pluginInit({
-      baseConfig,
-      config,
-      initURL,
-      options,
-      request
-    });
-    if (!isPlainObject(initResult)) return;
-    if (isString(initResult.initURL)) {
-      resolvedUrl = initResult.initURL;
-    }
-    if (isPlainObject(initResult.request)) {
-      resolvedRequestOptions = initResult.request;
-    }
-    if (isPlainObject(initResult.options)) {
-      resolvedOptions = initResult.options;
-    }
-  };
-  for (const plugin of resolvedPlugins) {
-    await executePluginInit(plugin.init);
-    if (!plugin.hooks) continue;
-    addPluginHooks(plugin.hooks);
-  }
-  if (mergedHooksExecutionOrder === "mainHooksAfterPlugins") {
-    addMainHooks();
-  }
-  const resolvedHooks = {};
-  for (const [key, hookRegistry] of Object.entries(clonedHookRegistries)) {
-    const flattenedHookArray = [...hookRegistry].flat();
-    const mergedHooksExecutionMode = options.mergedHooksExecutionMode ?? hookDefaults.mergedHooksExecutionMode;
-    const composedHook = composeTwoHooks(flattenedHookArray, mergedHooksExecutionMode);
-    composedHook && (resolvedHooks[key] = composedHook);
-  }
-  return {
-    resolvedHooks,
-    resolvedOptions,
-    resolvedRequestOptions,
-    url: resolvedUrl?.toString()
-  };
+const initializePlugins = async (context) => {
+	const { baseConfig, config, initURL, options, request } = context;
+	const clonedHookRegistries = structuredClone(hookRegistries);
+	const addMainHooks = () => {
+		for (const key of Object.keys(clonedHookRegistries)) {
+			const baseHook = baseConfig[key];
+			const instanceHook = config[key];
+			const overriddenHook = options[key];
+			const mainHook = isArray(baseHook) && Boolean(instanceHook) ? [baseHook, instanceHook].flat() : overriddenHook;
+			if (!mainHook) continue;
+			clonedHookRegistries[key].add(mainHook);
+		}
+	};
+	const addPluginHooks = (pluginHooks) => {
+		for (const key of Object.keys(clonedHookRegistries)) {
+			const pluginHook = pluginHooks[key];
+			if (!pluginHook) continue;
+			clonedHookRegistries[key].add(pluginHook);
+		}
+	};
+	const mergedHooksExecutionOrder = options.mergedHooksExecutionOrder ?? hookDefaults.mergedHooksExecutionOrder;
+	if (mergedHooksExecutionOrder === "mainHooksBeforePlugins") addMainHooks();
+	const resolvedPlugins = resolvePluginArray(options.plugins, baseConfig.plugins);
+	let resolvedInitURL = initURL;
+	let resolvedOptions = options;
+	let resolvedRequestOptions = request;
+	const executePluginInit = async (pluginInit) => {
+		if (!pluginInit) return;
+		const initResult = await pluginInit({
+			baseConfig,
+			config,
+			initURL,
+			options,
+			request
+		});
+		if (!isPlainObject(initResult)) return;
+		const urlString = initResult.initURL?.toString();
+		if (isString(urlString)) resolvedInitURL = urlString;
+		if (isPlainObject(initResult.request)) resolvedRequestOptions = initResult.request;
+		if (isPlainObject(initResult.options)) resolvedOptions = initResult.options;
+	};
+	for (const plugin of resolvedPlugins) {
+		await executePluginInit(plugin.init);
+		if (!plugin.hooks) continue;
+		addPluginHooks(plugin.hooks);
+	}
+	if (mergedHooksExecutionOrder === "mainHooksAfterPlugins") addMainHooks();
+	const resolvedHooks = {};
+	for (const [key, hookRegistry] of Object.entries(clonedHookRegistries)) {
+		const flattenedHookArray = [...hookRegistry].flat();
+		const mergedHooksExecutionMode = options.mergedHooksExecutionMode ?? hookDefaults.mergedHooksExecutionMode;
+		const composedHook = composeTwoHooks(flattenedHookArray, mergedHooksExecutionMode);
+		composedHook && (resolvedHooks[key] = composedHook);
+	}
+	return {
+		resolvedHooks,
+		resolvedInitURL: resolvedInitURL.toString(),
+		resolvedOptions,
+		resolvedRequestOptions
+	};
 };
 
-// src/retry.ts
-var getLinearDelay = (currentAttemptCount, options) => {
-  const retryDelay = options.retryDelay ?? options.retry?.delay;
-  const resolveRetryDelay = (isFunction(retryDelay) ? retryDelay(currentAttemptCount) : retryDelay) ?? retryDefaults.delay;
-  return resolveRetryDelay;
+//#endregion
+//#region src/retry.ts
+const getLinearDelay = (currentAttemptCount, options) => {
+	const retryDelay = options.retryDelay ?? options.retry?.delay;
+	const resolveRetryDelay = (isFunction(retryDelay) ? retryDelay(currentAttemptCount) : retryDelay) ?? retryDefaults.delay;
+	return resolveRetryDelay;
 };
-var getExponentialDelay = (currentAttemptCount, options) => {
-  const retryDelay = options.retryDelay ?? options.retry?.delay ?? retryDefaults.delay;
-  const resolvedRetryDelay = Number(
-    isFunction(retryDelay) ? retryDelay(currentAttemptCount) : retryDelay
-  );
-  const maxDelay = Number(options.retryMaxDelay ?? options.retry?.maxDelay ?? retryDefaults.maxDelay);
-  const exponentialDelay = resolvedRetryDelay * 2 ** currentAttemptCount;
-  return Math.min(exponentialDelay, maxDelay);
+const getExponentialDelay = (currentAttemptCount, options) => {
+	const retryDelay = options.retryDelay ?? options.retry?.delay ?? retryDefaults.delay;
+	const resolvedRetryDelay = Number(isFunction(retryDelay) ? retryDelay(currentAttemptCount) : retryDelay);
+	const maxDelay = Number(options.retryMaxDelay ?? options.retry?.maxDelay ?? retryDefaults.maxDelay);
+	const exponentialDelay = resolvedRetryDelay * 2 ** currentAttemptCount;
+	return Math.min(exponentialDelay, maxDelay);
 };
-var createRetryStrategy = (ctx) => {
-  const { options } = ctx;
-  const currentAttemptCount = options["~retryAttemptCount"] ?? 1;
-  const retryStrategy = options.retryStrategy ?? options.retry?.strategy ?? retryDefaults.strategy;
-  const getDelay = () => {
-    switch (retryStrategy) {
-      case "exponential": {
-        return getExponentialDelay(currentAttemptCount, options);
-      }
-      case "linear": {
-        return getLinearDelay(currentAttemptCount, options);
-      }
-      default: {
-        throw new Error(`Invalid retry strategy: ${String(retryStrategy)}`);
-      }
-    }
-  };
-  const shouldAttemptRetry = async () => {
-    const retryCondition = options.retryCondition ?? options.retry?.condition ?? retryDefaults.condition;
-    const maximumRetryAttempts = options.retryAttempts ?? options.retry?.attempts ?? retryDefaults.attempts;
-    const customRetryCondition = await retryCondition(ctx);
-    const baseShouldRetry = maximumRetryAttempts >= currentAttemptCount && customRetryCondition;
-    if (!baseShouldRetry) {
-      return false;
-    }
-    if (!isHTTPError(ctx.error)) {
-      return true;
-    }
-    const selectedMethodArray = options.retryMethods ?? options.retry?.methods ?? retryDefaults.methods;
-    const retryMethods = new Set(selectedMethodArray);
-    const method = ctx.request.method ?? requestOptionDefaults.method;
-    const includesMethod = Boolean(method) && retryMethods.has(method);
-    const selectedStatusCodeArray = options.retryStatusCodes ?? options.retry?.statusCodes;
-    const retryStatusCodes = selectedStatusCodeArray ? new Set(selectedStatusCodeArray) : null;
-    const includesStatusCodes = Boolean(ctx.response?.status) && (retryStatusCodes?.has(ctx.response.status) ?? true);
-    const shouldRetry = includesMethod && includesStatusCodes;
-    return shouldRetry;
-  };
-  return {
-    currentAttemptCount,
-    getDelay,
-    shouldAttemptRetry
-  };
+const createRetryStrategy = (ctx) => {
+	const { options } = ctx;
+	const currentAttemptCount = options["~retryAttemptCount"] ?? 1;
+	const retryStrategy = options.retryStrategy ?? options.retry?.strategy ?? retryDefaults.strategy;
+	const getDelay = () => {
+		switch (retryStrategy) {
+			case "exponential": return getExponentialDelay(currentAttemptCount, options);
+			case "linear": return getLinearDelay(currentAttemptCount, options);
+			default: throw new Error(`Invalid retry strategy: ${String(retryStrategy)}`);
+		}
+	};
+	const shouldAttemptRetry = async () => {
+		const retryCondition = options.retryCondition ?? options.retry?.condition ?? retryDefaults.condition;
+		const maximumRetryAttempts = options.retryAttempts ?? options.retry?.attempts ?? retryDefaults.attempts;
+		const customRetryCondition = await retryCondition(ctx);
+		const baseShouldRetry = maximumRetryAttempts >= currentAttemptCount && customRetryCondition;
+		if (!baseShouldRetry) return false;
+		if (!isHTTPError(ctx.error)) return true;
+		const selectedMethodArray = options.retryMethods ?? options.retry?.methods ?? retryDefaults.methods;
+		const retryMethods = new Set(selectedMethodArray);
+		const method = ctx.request.method ?? requestOptionDefaults.method;
+		const includesMethod = Boolean(method) && retryMethods.has(method);
+		const selectedStatusCodeArray = options.retryStatusCodes ?? options.retry?.statusCodes;
+		const retryStatusCodes = selectedStatusCodeArray ? new Set(selectedStatusCodeArray) : null;
+		const includesStatusCodes = Boolean(ctx.response?.status) && (retryStatusCodes?.has(ctx.response.status) ?? true);
+		const shouldRetry = includesMethod && includesStatusCodes;
+		return shouldRetry;
+	};
+	return {
+		currentAttemptCount,
+		getDelay,
+		shouldAttemptRetry
+	};
 };
 
-// src/url.ts
-var slash = "/";
-var column = ":";
-var mergeUrlWithParams = (url, params) => {
-  if (!params) {
-    return url;
-  }
-  let newUrl = url;
-  if (isArray(params)) {
-    const matchedParamArray = newUrl.split(slash).filter((param) => param.startsWith(column));
-    for (const [index, matchedParam] of matchedParamArray.entries()) {
-      const realParam = params[index];
-      newUrl = newUrl.replace(matchedParam, realParam);
-    }
-    return newUrl;
-  }
-  for (const [key, value] of Object.entries(params)) {
-    newUrl = newUrl.replace(`${column}${key}`, String(value));
-  }
-  return newUrl;
+//#endregion
+//#region src/url.ts
+const slash = "/";
+const column = ":";
+const mergeUrlWithParams = (url, params) => {
+	if (!params) return url;
+	let newUrl = url;
+	if (isArray(params)) {
+		const matchedParamArray = newUrl.split(slash).filter((param) => param.startsWith(column));
+		for (const [index, matchedParam] of matchedParamArray.entries()) {
+			const realParam = params[index];
+			newUrl = newUrl.replace(matchedParam, realParam);
+		}
+		return newUrl;
+	}
+	for (const [key, value] of Object.entries(params)) newUrl = newUrl.replace(`${column}${key}`, String(value));
+	return newUrl;
 };
-var questionMark = "?";
-var ampersand = "&";
-var mergeUrlWithQuery = (url, query) => {
-  if (!query) {
-    return url;
-  }
-  const queryString = toQueryString(query);
-  if (queryString?.length === 0) {
-    return url;
-  }
-  if (url.endsWith(questionMark)) {
-    return `${url}${queryString}`;
-  }
-  if (url.includes(questionMark)) {
-    return `${url}${ampersand}${queryString}`;
-  }
-  return `${url}${questionMark}${queryString}`;
+const questionMark = "?";
+const ampersand = "&";
+const mergeUrlWithQuery = (url, query) => {
+	if (!query) return url;
+	const queryString = toQueryString(query);
+	if (queryString?.length === 0) return url;
+	if (url.endsWith(questionMark)) return `${url}${queryString}`;
+	if (url.includes(questionMark)) return `${url}${ampersand}${queryString}`;
+	return `${url}${questionMark}${queryString}`;
 };
-var mergeUrlWithParamsAndQuery = (url, params, query) => {
-  if (!url) return;
-  const urlWithMergedParams = mergeUrlWithParams(url, params);
-  return mergeUrlWithQuery(urlWithMergedParams, query);
+const getCurrentRouteKey = (url, schemaConfig) => {
+	let currentRouteKey = url;
+	if (schemaConfig?.baseURL && currentRouteKey.startsWith(schemaConfig.baseURL)) currentRouteKey = currentRouteKey.replace(schemaConfig.baseURL, "");
+	return currentRouteKey;
 };
-
-// src/validation.ts
-var standardSchemaParser = async (schema, inputData) => {
-  const result = await schema["~standard"].validate(inputData);
-  if (result.issues) {
-    throw new Error(JSON.stringify(result.issues, null, 2), { cause: result.issues });
-  }
-  return result.value;
+/**
+* @description
+* Extracts the method from the URL if it is a schema modifier.
+*
+* @param initURL - The URL to extract the method from.
+* @returns The method if it is a schema modifier, otherwise undefined.
+*/
+const extractMethodFromURL = (initURL) => {
+	if (!initURL?.startsWith("@")) return;
+	const method = initURL.split("@")[1]?.split("/")[0];
+	if (!method || !routeKeyMethods.includes(method)) return;
+	return method;
+};
+const getMethod = (options) => {
+	const { initURL, method, schemaConfig } = options;
+	if (schemaConfig?.requireHttpMethodProvision === true) return method?.toUpperCase() ?? requestOptionDefaults.method;
+	return method?.toUpperCase() ?? extractMethodFromURL(initURL)?.toUpperCase() ?? requestOptionDefaults.method;
+};
+const normalizeURL = (initURL) => {
+	const methodFromURL = extractMethodFromURL(initURL);
+	if (!methodFromURL) return initURL;
+	const normalizedURL = initURL.replace(`@${methodFromURL}/`, "/");
+	return normalizedURL;
 };
-var handleValidation = async (responseData, schema, validator) => {
-  const validResponseData = validator ? validator(responseData) : responseData;
-  const schemaValidResponseData = schema ? await standardSchemaParser(schema, validResponseData) : validResponseData;
-  return schemaValidResponseData;
+const getFullURL = (options) => {
+	const { baseURL, initURL, params, query } = options;
+	const normalizedURL = normalizeURL(initURL);
+	const urlWithMergedParams = mergeUrlWithParams(normalizedURL, params);
+	const urlWithMergedQueryAndParams = mergeUrlWithQuery(urlWithMergedParams, query);
+	if (urlWithMergedQueryAndParams.startsWith("http") || !baseURL) return urlWithMergedQueryAndParams;
+	return `${baseURL}${urlWithMergedQueryAndParams}`;
 };
 
-// src/createFetchClient.ts
-var createFetchClient = (initBaseConfig = {}) => {
-  const $RequestInfoCache = /* @__PURE__ */ new Map();
-  const callApi2 = async (...parameters) => {
-    const [initURL, initConfig = {}] = parameters;
-    const [fetchOptions, extraOptions] = splitConfig(initConfig);
-    const resolvedBaseConfig = isFunction(initBaseConfig) ? initBaseConfig({ initURL: initURL.toString(), options: extraOptions, request: fetchOptions }) : initBaseConfig;
-    const [baseFetchOptions, baseExtraOptions] = splitBaseConfig(resolvedBaseConfig);
-    const mergedExtraOptions = {
-      ...baseExtraOptions,
-      ...baseExtraOptions.skipAutoMergeFor !== "all" && baseExtraOptions.skipAutoMergeFor !== "options" && extraOptions
-    };
-    const mergedRequestOptions = {
-      ...baseFetchOptions,
-      ...baseExtraOptions.skipAutoMergeFor !== "all" && baseExtraOptions.skipAutoMergeFor !== "request" && fetchOptions
-    };
-    const baseConfig = resolvedBaseConfig;
-    const config = initConfig;
-    const { resolvedHooks, resolvedOptions, resolvedRequestOptions, url } = await initializePlugins({
-      baseConfig,
-      config,
-      initURL,
-      options: mergedExtraOptions,
-      request: mergedRequestOptions
-    });
-    const fullURL = `${resolvedOptions.baseURL ?? ""}${mergeUrlWithParamsAndQuery(url, resolvedOptions.params, resolvedOptions.query)}`;
-    const options = {
-      ...resolvedOptions,
-      ...resolvedHooks,
-      fullURL,
-      initURL: initURL.toString()
-    };
-    const newFetchController = new AbortController();
-    const timeoutSignal = options.timeout != null ? createTimeoutSignal(options.timeout) : null;
-    const combinedSignal = createCombinedSignal(
-      resolvedRequestOptions.signal,
-      timeoutSignal,
-      newFetchController.signal
-    );
-    const bodySerializer = options.bodySerializer ?? commonDefaults.bodySerializer;
-    const request = {
-      ...resolvedRequestOptions,
-      body: isSerializable(resolvedRequestOptions.body) ? bodySerializer(resolvedRequestOptions.body) : resolvedRequestOptions.body,
-      headers: await getHeaders({
-        auth: options.auth,
-        baseHeaders: baseFetchOptions.headers,
-        body: resolvedRequestOptions.body,
-        headers: fetchOptions.headers
-      }),
-      signal: combinedSignal
-    };
-    const {
-      dedupeStrategy,
-      handleRequestCancelStrategy,
-      handleRequestDeferStrategy,
-      removeDedupeKeyFromCache
-    } = await createDedupeStrategy({
-      $RequestInfoCache,
-      baseConfig,
-      config,
-      newFetchController,
-      options,
-      request
-    });
-    await handleRequestCancelStrategy();
-    try {
-      await executeHooksInTryBlock(options.onRequest?.({ baseConfig, config, options, request }));
-      request.headers = await getHeaders({
-        auth: options.auth,
-        body: request.body,
-        headers: request.headers
-      });
-      const response = await handleRequestDeferStrategy();
-      const shouldCloneResponse = dedupeStrategy === "defer" || options.cloneResponse;
-      const schemas = isFunction(options.schemas) ? options.schemas({ baseSchemas: baseExtraOptions.schemas }) : options.schemas;
-      const validators = isFunction(options.validators) ? options.validators({ baseValidators: baseExtraOptions.validators }) : options.validators;
-      if (!response.ok) {
-        const errorData = await resolveResponseData(
-          shouldCloneResponse ? response.clone() : response,
-          options.responseType,
-          options.responseParser
-        );
-        const validErrorData = await handleValidation(
-          errorData,
-          schemas?.errorData,
-          validators?.errorData
-        );
-        throw new HTTPError(
-          {
-            defaultErrorMessage: options.defaultErrorMessage,
-            errorData: validErrorData,
-            response
-          },
-          { cause: validErrorData }
-        );
-      }
-      const successData = await resolveResponseData(
-        shouldCloneResponse ? response.clone() : response,
-        options.responseType,
-        options.responseParser
-      );
-      const validSuccessData = await handleValidation(successData, schemas?.data, validators?.data);
-      const successContext = {
-        baseConfig,
-        config,
-        data: validSuccessData,
-        options,
-        request,
-        response
-      };
-      await executeHooksInTryBlock(
-        options.onSuccess?.(successContext),
-        options.onResponse?.({ ...successContext, error: null })
-      );
-      const successResult = resolveSuccessResult(successContext.data, {
-        response: successContext.response,
-        resultMode: options.resultMode
-      });
-      return successResult;
-    } catch (error) {
-      const errorInfo = {
-        cloneResponse: options.cloneResponse,
-        defaultErrorMessage: options.defaultErrorMessage,
-        resultMode: options.resultMode
-      };
-      const generalErrorResult = resolveErrorResult(error, errorInfo);
-      const errorContext = {
-        baseConfig,
-        config,
-        error: generalErrorResult?.error,
-        options,
-        request,
-        response: generalErrorResult?.response
-      };
-      const shouldThrowOnError = isFunction(options.throwOnError) ? options.throwOnError(errorContext) : options.throwOnError;
-      const hookInfo = {
-        errorInfo,
-        shouldThrowOnError
-      };
-      const handleRetryOrGetErrorResult = async () => {
-        const { currentAttemptCount, getDelay, shouldAttemptRetry } = createRetryStrategy(errorContext);
-        const shouldRetry = !combinedSignal.aborted && await shouldAttemptRetry();
-        if (shouldRetry) {
-          const retryContext = {
-            ...errorContext,
-            retryAttemptCount: currentAttemptCount
-          };
-          const hookError2 = await executeHooksInCatchBlock(
-            [options.onRetry?.(retryContext)],
-            hookInfo
-          );
-          if (hookError2) {
-            return hookError2;
-          }
-          const delay = getDelay();
-          await waitFor(delay);
-          const updatedOptions = {
-            ...config,
-            "~retryAttemptCount": currentAttemptCount + 1
-          };
-          return callApi2(initURL, updatedOptions);
-        }
-        if (shouldThrowOnError) {
-          throw error;
-        }
-        return generalErrorResult;
-      };
-      if (isHTTPErrorInstance(error)) {
-        const hookError2 = await executeHooksInCatchBlock(
-          [
-            options.onResponseError?.(errorContext),
-            options.onError?.(errorContext),
-            options.onResponse?.({ ...errorContext, data: null })
-          ],
-          hookInfo
-        );
-        if (hookError2) {
-          return hookError2;
-        }
-        return await handleRetryOrGetErrorResult();
-      }
-      if (error instanceof DOMException && error.name === "AbortError") {
-        !shouldThrowOnError && console.error(`${error.name}:`, error.message);
-      }
-      let timeoutMessage;
-      if (error instanceof DOMException && error.name === "TimeoutError") {
-        timeoutMessage = `Request timed out after ${options.timeout}ms`;
-        !shouldThrowOnError && console.error(`${error.name}:`, timeoutMessage);
-      }
-      const hookError = await executeHooksInCatchBlock(
-        [options.onRequestError?.(errorContext), options.onError?.(errorContext)],
-        hookInfo
-      );
-      if (hookError) {
-        return hookError;
-      }
-      const errorResult = await handleRetryOrGetErrorResult();
-      return timeoutMessage ? getCustomizedErrorResult(errorResult, { message: timeoutMessage }) : errorResult;
-    } finally {
-      removeDedupeKeyFromCache();
-    }
-  };
-  return callApi2;
+//#endregion
+//#region src/createFetchClient.ts
+const createFetchClient = (initBaseConfig = {}) => {
+	const $RequestInfoCache = /* @__PURE__ */ new Map();
+	const callApi$1 = async (...parameters) => {
+		const [initURLOrURLObject, initConfig = {}] = parameters;
+		const [fetchOptions, extraOptions] = splitConfig(initConfig);
+		const resolvedBaseConfig = isFunction(initBaseConfig) ? initBaseConfig({
+			initURL: initURLOrURLObject.toString(),
+			options: extraOptions,
+			request: fetchOptions
+		}) : initBaseConfig;
+		const [baseFetchOptions, baseExtraOptions] = splitBaseConfig(resolvedBaseConfig);
+		const mergedExtraOptions = {
+			...baseExtraOptions,
+			...baseExtraOptions.skipAutoMergeFor !== "all" && baseExtraOptions.skipAutoMergeFor !== "options" && extraOptions
+		};
+		const mergedRequestOptions = {
+			...baseFetchOptions,
+			...baseExtraOptions.skipAutoMergeFor !== "all" && baseExtraOptions.skipAutoMergeFor !== "request" && fetchOptions
+		};
+		const baseConfig = resolvedBaseConfig;
+		const config = initConfig;
+		const { resolvedHooks, resolvedInitURL, resolvedOptions, resolvedRequestOptions } = await initializePlugins({
+			baseConfig,
+			config,
+			initURL: initURLOrURLObject.toString(),
+			options: mergedExtraOptions,
+			request: mergedRequestOptions
+		});
+		const fullURL = getFullURL({
+			baseURL: resolvedOptions.baseURL,
+			initURL: resolvedInitURL,
+			params: resolvedOptions.params,
+			query: resolvedOptions.query
+		});
+		const resolvedSchemaConfig = isFunction(extraOptions.schemaConfig) ? extraOptions.schemaConfig({ baseSchemaConfig: baseExtraOptions.schemaConfig ?? {} }) : extraOptions.schemaConfig ?? baseExtraOptions.schemaConfig;
+		const currentRouteKey = getCurrentRouteKey(resolvedInitURL, resolvedSchemaConfig);
+		const routeSchema = baseExtraOptions.schema?.[currentRouteKey];
+		const resolvedSchema = isFunction(extraOptions.schema) ? extraOptions.schema({
+			baseSchema: baseExtraOptions.schema ?? {},
+			currentRouteSchema: routeSchema ?? {}
+		}) : extraOptions.schema ?? routeSchema;
+		let options = {
+			...resolvedOptions,
+			...resolvedHooks,
+			fullURL,
+			initURL: resolvedInitURL,
+			initURLNormalized: normalizeURL(resolvedInitURL)
+		};
+		const newFetchController = new AbortController();
+		const timeoutSignal = options.timeout != null ? createTimeoutSignal(options.timeout) : null;
+		const combinedSignal = createCombinedSignal(resolvedRequestOptions.signal, timeoutSignal, newFetchController.signal);
+		let request = {
+			...resolvedRequestOptions,
+			signal: combinedSignal
+		};
+		const { dedupeStrategy, handleRequestCancelStrategy, handleRequestDeferStrategy, removeDedupeKeyFromCache } = await createDedupeStrategy({
+			$RequestInfoCache,
+			baseConfig,
+			config,
+			newFetchController,
+			options,
+			request
+		});
+		try {
+			await handleRequestCancelStrategy();
+			await executeHooksInTryBlock(options.onRequest?.({
+				baseConfig,
+				config,
+				options,
+				request
+			}));
+			const { extraOptionsValidationResult, requestOptionsValidationResult } = await handleOptionsValidation({
+				extraOptions: options,
+				requestOptions: request,
+				schema: resolvedSchema,
+				schemaConfig: resolvedSchemaConfig
+			});
+			const shouldApplySchemaOutput = Boolean(extraOptionsValidationResult) || Boolean(requestOptionsValidationResult) || !resolvedSchemaConfig?.disableValidationOutputApplication;
+			if (shouldApplySchemaOutput) options = {
+				...options,
+				...extraOptionsValidationResult
+			};
+			const validBody = getBody({
+				body: shouldApplySchemaOutput ? requestOptionsValidationResult?.body : request.body,
+				bodySerializer: options.bodySerializer
+			});
+			const validHeaders = await getHeaders({
+				auth: options.auth,
+				baseHeaders: request.headers,
+				body: request.body,
+				headers: shouldApplySchemaOutput ? requestOptionsValidationResult?.headers : request.headers
+			});
+			const validMethod = getMethod({
+				initURL: resolvedInitURL,
+				method: shouldApplySchemaOutput ? requestOptionsValidationResult?.method : request.method,
+				schemaConfig: resolvedSchemaConfig
+			});
+			request = {
+				...request,
+				...Boolean(validBody) && { body: validBody },
+				...Boolean(validHeaders) && { headers: validHeaders },
+				...Boolean(validMethod) && { method: validMethod }
+			};
+			const response = await handleRequestDeferStrategy(options, request);
+			const shouldCloneResponse = dedupeStrategy === "defer" || options.cloneResponse;
+			if (!response.ok) {
+				const errorData = await resolveResponseData(shouldCloneResponse ? response.clone() : response, options.responseType, options.responseParser);
+				const validErrorData = await handleValidation(resolvedSchema?.errorData, {
+					inputValue: errorData,
+					response,
+					schemaConfig: resolvedSchemaConfig
+				});
+				throw new HTTPError({
+					defaultErrorMessage: options.defaultErrorMessage,
+					errorData: validErrorData,
+					response
+				}, { cause: validErrorData });
+			}
+			const successData = await resolveResponseData(shouldCloneResponse ? response.clone() : response, options.responseType, options.responseParser);
+			const validSuccessData = await handleValidation(resolvedSchema?.data, {
+				inputValue: successData,
+				response,
+				schemaConfig: resolvedSchemaConfig
+			});
+			const successContext = {
+				baseConfig,
+				config,
+				data: validSuccessData,
+				options,
+				request,
+				response
+			};
+			await executeHooksInTryBlock(options.onSuccess?.(successContext), options.onResponse?.({
+				...successContext,
+				error: null
+			}));
+			const successResult = resolveSuccessResult(successContext.data, {
+				response: successContext.response,
+				resultMode: options.resultMode
+			});
+			return successResult;
+		} catch (error) {
+			const errorInfo = {
+				cloneResponse: options.cloneResponse,
+				defaultErrorMessage: options.defaultErrorMessage,
+				resultMode: options.resultMode
+			};
+			const generalErrorResult = resolveErrorResult(error, errorInfo);
+			const errorContext = {
+				baseConfig,
+				config,
+				error: generalErrorResult?.error,
+				options,
+				request,
+				response: generalErrorResult?.response
+			};
+			const shouldThrowOnError = isFunction(options.throwOnError) ? options.throwOnError(errorContext) : options.throwOnError;
+			const hookInfo = {
+				errorInfo,
+				shouldThrowOnError
+			};
+			const handleRetryOrGetErrorResult = async () => {
+				const { currentAttemptCount, getDelay, shouldAttemptRetry } = createRetryStrategy(errorContext);
+				const shouldRetry = !combinedSignal.aborted && await shouldAttemptRetry();
+				if (shouldRetry) {
+					const retryContext = {
+						...errorContext,
+						retryAttemptCount: currentAttemptCount
+					};
+					const hookError$1 = await executeHooksInCatchBlock([options.onRetry?.(retryContext)], hookInfo);
+					if (hookError$1) return hookError$1;
+					const delay = getDelay();
+					await waitFor(delay);
+					const updatedOptions = {
+						...config,
+						"~retryAttemptCount": currentAttemptCount + 1
+					};
+					return callApi$1(initURLOrURLObject, updatedOptions);
+				}
+				if (shouldThrowOnError) throw error;
+				return generalErrorResult;
+			};
+			if (isHTTPErrorInstance(error)) {
+				const hookError$1 = await executeHooksInCatchBlock([
+					options.onResponseError?.(errorContext),
+					options.onError?.(errorContext),
+					options.onResponse?.({
+						...errorContext,
+						data: null
+					})
+				], hookInfo);
+				return hookError$1 ?? await handleRetryOrGetErrorResult();
+			}
+			if (isValidationErrorInstance(error)) {
+				const hookError$1 = await executeHooksInCatchBlock([
+					options.onValidationError?.(errorContext),
+					options.onRequestError?.(errorContext),
+					options.onError?.(errorContext)
+				], hookInfo);
+				return hookError$1 ?? await handleRetryOrGetErrorResult();
+			}
+			let message = error?.message;
+			if (error instanceof DOMException && error.name === "AbortError") {
+				message = getAbortErrorMessage(options.dedupeKey, options.fullURL);
+				!shouldThrowOnError && console.error(`${error.name}:`, message);
+			}
+			if (error instanceof DOMException && error.name === "TimeoutError") {
+				message = `Request timed out after ${options.timeout}ms`;
+				!shouldThrowOnError && console.error(`${error.name}:`, message);
+			}
+			const hookError = await executeHooksInCatchBlock([options.onRequestError?.(errorContext), options.onError?.(errorContext)], hookInfo);
+			return hookError ?? getCustomizedErrorResult(await handleRetryOrGetErrorResult(), { message });
+		} finally {
+			removeDedupeKeyFromCache();
+		}
+	};
+	return callApi$1;
 };
-var callApi = createFetchClient();
+const callApi = createFetchClient();
 
-// src/defineParameters.ts
-var defineParameters = (...parameters) => {
-  return parameters;
+//#endregion
+//#region src/defineParameters.ts
+const defineParameters = (...parameters) => {
+	return parameters;
 };
 
-export { callApi, createFetchClient, defineParameters, definePlugin };
-//# sourceMappingURL=index.js.map
+//#endregion
+export { HTTPError, ValidationError, callApi, createFetchClient, defineParameters, definePlugin, defineSchema };
 //# sourceMappingURL=index.js.map