@zayne-labs/callapi 1.11.5 → 1.11.7

package/dist/esm/index.d.ts

@@ -1,8 +1,8 @@
-import { AnyFunction, AnyString, ApplyStrictConfig, ApplyURLBasedConfig, BaseCallApiConfig, BaseCallApiExtraOptions, BaseCallApiSchemaAndConfig, BaseCallApiSchemaRoutes, CallApiConfig, CallApiExtraOptions, CallApiExtraOptionsForHooks, CallApiParameters, CallApiPlugin, CallApiRequestOptions, CallApiRequestOptionsForHooks, CallApiResult, CallApiResultErrorVariant, CallApiResultSuccessVariant, CallApiSchema, CallApiSchemaConfig, CallApiSuccessOrErrorVariant, DedupeOptions, DefaultDataType, DefaultPluginArray, DefaultThrowOnError, ErrorContext, GetCallApiResult, GetCurrentRouteSchema, GetCurrentRouteSchemaKey, GetResponseType, HTTPError, Hooks, HooksOrHooksArray, InferInitURL, InferParamsFromRoute, InferSchemaOutputResult, PluginExtraOptions, PluginHooks, PluginHooksWithMoreOptions, PluginSetupContext, PossibleHTTPError, PossibleJavaScriptError, PossibleJavaScriptOrValidationError, PossibleValidationError, Register, RequestContext, RequestStreamContext, ResponseContext, ResponseErrorContext, ResponseStreamContext, ResponseTypeMap, ResponseTypeUnion, ResultModeMap, ResultModeUnion, RetryOptions, SuccessContext, ThrowOnErrorUnion, URLOptions, ValidationError, Writeable, fallBackRouteSchemaKey } from "./common-NVdD93VW.js";
+import { $ as ValidationError, A as ResponseStreamContext, B as PossibleValidationError, C as Hooks, D as RequestStreamContext, E as RequestContext, F as GetCallApiResult, G as DefaultDataType, H as ResponseTypeUnion, I as GetResponseType, J as CallApiPlugin, K as DefaultPluginArray, L as PossibleHTTPError, M as CallApiResultErrorVariant, N as CallApiResultSuccessVariant, O as ResponseContext, P as CallApiSuccessOrErrorVariant, Q as HTTPError, R as PossibleJavaScriptError, S as ErrorContext, T as PluginExtraOptions, U as ResultModeMap, V as ResponseTypeMap, W as ResultModeUnion, X as PluginHooksWithMoreOptions, Y as PluginHooks, Z as PluginSetupContext, _ as InferParamsFromRoute, a as CallApiExtraOptionsForHooks, at as fallBackRouteSchemaKey, b as RetryOptions, c as CallApiRequestOptionsForHooks, d as GetBaseSchemaRoutes, et as BaseCallApiSchemaAndConfig, f as ApplyStrictConfig, g as InferInitURL, h as GetCurrentRouteSchemaKey, i as CallApiExtraOptions, it as InferSchemaOutputResult, j as SuccessContext, k as ResponseErrorContext, l as CallApiResult, m as GetCurrentRouteSchema, n as BaseCallApiExtraOptions, nt as CallApiSchema, o as CallApiParameters, ot as URLOptions, p as ApplyURLBasedConfig, q as DefaultThrowOnError, r as CallApiConfig, rt as CallApiSchemaConfig, s as CallApiRequestOptions, st as AnyString, t as BaseCallApiConfig, tt as BaseCallApiSchemaRoutes, u as GetBaseSchemaConfig, v as Register, w as HooksOrHooksArray, x as DedupeOptions, y as ThrowOnErrorUnion, z as PossibleJavaScriptOrValidationError } from "./common-BsDcf2vu.js";
 
 //#region src/createFetchClient.d.ts
 
-declare const createFetchClient: <TBaseData = DefaultDataType, TBaseErrorData = DefaultDataType, TBaseResultMode extends ResultModeUnion = ResultModeUnion, TBaseThrowOnError extends ThrowOnErrorUnion = DefaultThrowOnError, TBaseResponseType extends ResponseTypeUnion = ResponseTypeUnion, const TBaseSchemaAndConfig extends BaseCallApiSchemaAndConfig = BaseCallApiSchemaAndConfig, const TBasePluginArray extends CallApiPlugin[] = DefaultPluginArray, TComputedBaseSchemaConfig extends CallApiSchemaConfig = NonNullable<Writeable<TBaseSchemaAndConfig["config"], "deep">>, TComputedBaseSchemaRoutes extends BaseCallApiSchemaRoutes = Writeable<TBaseSchemaAndConfig["routes"], "deep">>(initBaseConfig?: BaseCallApiConfig<TBaseData, TBaseErrorData, TBaseResultMode, TBaseThrowOnError, TBaseResponseType, TBaseSchemaAndConfig, TBasePluginArray>) => <TData = TBaseData, TErrorData = TBaseErrorData, TResultMode extends ResultModeUnion = TBaseResultMode, TThrowOnError extends ThrowOnErrorUnion = TBaseThrowOnError, TResponseType extends ResponseTypeUnion = TBaseResponseType, const TSchemaConfig extends CallApiSchemaConfig = TComputedBaseSchemaConfig, TInitURL extends InferInitURL<TComputedBaseSchemaRoutes, TSchemaConfig> = InferInitURL<TComputedBaseSchemaRoutes, TSchemaConfig>, TCurrentRouteSchemaKey extends GetCurrentRouteSchemaKey<TSchemaConfig, TInitURL> = GetCurrentRouteSchemaKey<TSchemaConfig, TInitURL>, const TSchema extends CallApiSchema = GetCurrentRouteSchema<TComputedBaseSchemaRoutes, TCurrentRouteSchemaKey>, const TPluginArray extends CallApiPlugin[] = TBasePluginArray, TComputedResult = CallApiResult<InferSchemaOutputResult<TSchema["data"], TData>, InferSchemaOutputResult<TSchema["errorData"], TErrorData>, TResultMode, TThrowOnError, TResponseType>>(initURL: TInitURL, config?: CallApiConfig<InferSchemaOutputResult<TSchema["data"], GetResponseType<TData, TResponseType>>, InferSchemaOutputResult<TSchema["errorData"], GetResponseType<TErrorData, TResponseType>>, TResultMode, TThrowOnError, TResponseType, TComputedBaseSchemaRoutes, TSchema, TComputedBaseSchemaConfig, TSchemaConfig, TInitURL, TCurrentRouteSchemaKey, TBasePluginArray, TPluginArray> | undefined) => Promise<TComputedResult>;
+declare const createFetchClient: <TBaseData = DefaultDataType, TBaseErrorData = DefaultDataType, TBaseResultMode extends ResultModeUnion = ResultModeUnion, TBaseThrowOnError extends ThrowOnErrorUnion = DefaultThrowOnError, TBaseResponseType extends ResponseTypeUnion = ResponseTypeUnion, const TBaseSchemaAndConfig extends BaseCallApiSchemaAndConfig = BaseCallApiSchemaAndConfig, const TBasePluginArray extends CallApiPlugin[] = DefaultPluginArray, TComputedBaseSchemaConfig extends CallApiSchemaConfig = GetBaseSchemaConfig<TBaseSchemaAndConfig>, TComputedBaseSchemaRoutes extends BaseCallApiSchemaRoutes = GetBaseSchemaRoutes<TBaseSchemaAndConfig>>(initBaseConfig?: BaseCallApiConfig<TBaseData, TBaseErrorData, TBaseResultMode, TBaseThrowOnError, TBaseResponseType, TBaseSchemaAndConfig, TBasePluginArray>) => <TData = TBaseData, TErrorData = TBaseErrorData, TResultMode extends ResultModeUnion = TBaseResultMode, TThrowOnError extends ThrowOnErrorUnion = TBaseThrowOnError, TResponseType extends ResponseTypeUnion = TBaseResponseType, const TSchemaConfig extends CallApiSchemaConfig = TComputedBaseSchemaConfig, TInitURL extends InferInitURL<TComputedBaseSchemaRoutes, TSchemaConfig> = InferInitURL<TComputedBaseSchemaRoutes, TSchemaConfig>, TCurrentRouteSchemaKey extends GetCurrentRouteSchemaKey<TSchemaConfig, TInitURL> = GetCurrentRouteSchemaKey<TSchemaConfig, TInitURL>, const TSchema extends CallApiSchema = GetCurrentRouteSchema<TComputedBaseSchemaRoutes, TCurrentRouteSchemaKey>, const TPluginArray extends CallApiPlugin[] = TBasePluginArray, TComputedResult = CallApiResult<InferSchemaOutputResult<TSchema["data"], TData>, InferSchemaOutputResult<TSchema["errorData"], TErrorData>, TResultMode, TThrowOnError, TResponseType>>(initURL: TInitURL, initConfig?: CallApiConfig<InferSchemaOutputResult<TSchema["data"], GetResponseType<TData, TResponseType>>, InferSchemaOutputResult<TSchema["errorData"], GetResponseType<TErrorData, TResponseType>>, TResultMode, TThrowOnError, TResponseType, TComputedBaseSchemaRoutes, TSchema, TComputedBaseSchemaConfig, TSchemaConfig, TInitURL, TCurrentRouteSchemaKey, TBasePluginArray, TPluginArray>) => Promise<TComputedResult>;
 declare const callApi: <TData = unknown, TErrorData = unknown, TResultMode extends ResultModeUnion = ResultModeUnion, TThrowOnError extends ThrowOnErrorUnion = boolean, TResponseType extends ResponseTypeUnion = ResponseTypeUnion, const TSchemaConfig extends CallApiSchemaConfig = CallApiSchemaConfig, TInitURL extends ApplyStrictConfig<TSchemaConfig, ApplyURLBasedConfig<TSchemaConfig, AnyString | "@delete/" | "@get/" | "@patch/" | "@post/" | "@put/">> = ApplyStrictConfig<TSchemaConfig, ApplyURLBasedConfig<TSchemaConfig, AnyString | "@delete/" | "@get/" | "@patch/" | "@post/" | "@put/">>, TCurrentRouteSchemaKey extends GetCurrentRouteSchemaKey<TSchemaConfig, TInitURL> = GetCurrentRouteSchemaKey<TSchemaConfig, TInitURL>, const TSchema extends CallApiSchema = GetCurrentRouteSchema<{
   [x: AnyString]: CallApiSchema | undefined;
   "@delete/"?: CallApiSchema | undefined;
@@ -10,21 +10,14 @@ declare const callApi: <TData = unknown, TErrorData = unknown, TResultMode exten
   "@patch/"?: CallApiSchema | undefined;
   "@post/"?: CallApiSchema | undefined;
   "@put/"?: CallApiSchema | undefined;
-}, TCurrentRouteSchemaKey, Omit<CallApiSchema | undefined, keyof {
+}, TCurrentRouteSchemaKey, CallApiSchema | undefined, {
   [x: AnyString]: CallApiSchema | undefined;
   "@delete/"?: CallApiSchema | undefined;
   "@get/"?: CallApiSchema | undefined;
   "@patch/"?: CallApiSchema | undefined;
   "@post/"?: CallApiSchema | undefined;
   "@put/"?: CallApiSchema | undefined;
-}[TCurrentRouteSchemaKey]> & {
-  [x: AnyString]: CallApiSchema | undefined;
-  "@delete/"?: CallApiSchema | undefined;
-  "@get/"?: CallApiSchema | undefined;
-  "@patch/"?: CallApiSchema | undefined;
-  "@post/"?: CallApiSchema | undefined;
-  "@put/"?: CallApiSchema | undefined;
-}[TCurrentRouteSchemaKey], NonNullable<Writeable<Omit<CallApiSchema | undefined, keyof {
+}[TCurrentRouteSchemaKey], NonNullable<Omit<CallApiSchema | undefined, keyof {
   [x: AnyString]: CallApiSchema | undefined;
   "@delete/"?: CallApiSchema | undefined;
   "@get/"?: CallApiSchema | undefined;
@@ -38,29 +31,18 @@ declare const callApi: <TData = unknown, TErrorData = unknown, TResultMode exten
   "@patch/"?: CallApiSchema | undefined;
   "@post/"?: CallApiSchema | undefined;
   "@put/"?: CallApiSchema | undefined;
-}[TCurrentRouteSchemaKey], "deep">>>, const TPluginArray extends CallApiPlugin[] = DefaultPluginArray, TComputedResult = GetCallApiResult<InferSchemaOutputResult<TSchema["data"], TData>, InferSchemaOutputResult<TSchema["errorData"], TErrorData>, TResultMode, TThrowOnError, TResponseType, {
+}[TCurrentRouteSchemaKey]>>, const TPluginArray extends CallApiPlugin[] = DefaultPluginArray, TComputedResult = GetCallApiResult<InferSchemaOutputResult<TSchema["data"], TData>, InferSchemaOutputResult<TSchema["errorData"], TErrorData>, TResultMode, TThrowOnError, TResponseType, {
   all: CallApiResultSuccessVariant<GetResponseType<InferSchemaOutputResult<TSchema["data"], TData>, TResponseType, ResponseTypeMap<InferSchemaOutputResult<TSchema["data"], TData>>>>;
   onlyData: NoInfer<GetResponseType<InferSchemaOutputResult<TSchema["data"], TData>, TResponseType, ResponseTypeMap<InferSchemaOutputResult<TSchema["data"], TData>>>>;
   onlyResponse: Response;
-}, ResultModeMap<InferSchemaOutputResult<TSchema["data"], TData>, InferSchemaOutputResult<TSchema["errorData"], TErrorData>, TResponseType, TThrowOnError>>>(initURL: TInitURL, config?: CallApiConfig<InferSchemaOutputResult<TSchema["data"], GetResponseType<TData, TResponseType, ResponseTypeMap<TData>>>, InferSchemaOutputResult<TSchema["errorData"], GetResponseType<TErrorData, TResponseType, ResponseTypeMap<TErrorData>>>, TResultMode, TThrowOnError, TResponseType, {
+}, ResultModeMap<InferSchemaOutputResult<TSchema["data"], TData>, InferSchemaOutputResult<TSchema["errorData"], TErrorData>, TResponseType, TThrowOnError>>>(initURL: TInitURL, initConfig?: CallApiConfig<InferSchemaOutputResult<TSchema["data"], GetResponseType<TData, TResponseType, ResponseTypeMap<TData>>>, InferSchemaOutputResult<TSchema["errorData"], GetResponseType<TErrorData, TResponseType, ResponseTypeMap<TErrorData>>>, TResultMode, TThrowOnError, TResponseType, {
   [x: AnyString]: CallApiSchema | undefined;
   "@delete/"?: CallApiSchema | undefined;
   "@get/"?: CallApiSchema | undefined;
   "@patch/"?: CallApiSchema | undefined;
   "@post/"?: CallApiSchema | undefined;
   "@put/"?: CallApiSchema | undefined;
-}, TSchema, CallApiSchemaConfig, TSchemaConfig, TInitURL, TCurrentRouteSchemaKey, DefaultPluginArray, TPluginArray> | undefined) => Promise<TComputedResult>;
-//#endregion
-//#region src/defineHelpers.d.ts
-declare const defineSchema: <const TBaseSchemaRoutes extends BaseCallApiSchemaRoutes, const TSchemaConfig extends CallApiSchemaConfig>(routes: TBaseSchemaRoutes, config?: TSchemaConfig) => {
-  config: Writeable<TSchemaConfig, "deep"> & {};
-  routes: Writeable<TBaseSchemaRoutes, "deep">;
-};
-declare const defineSchemaConfig: <const TConfig extends CallApiExtraOptions["schemaConfig"]>(config: TConfig) => NonNullable<Writeable<typeof config, "deep">>;
-declare const defineSchemaRoutes: <const TBaseSchemaRoutes extends BaseCallApiSchemaRoutes>(routes: TBaseSchemaRoutes) => Writeable<typeof routes, "deep">;
-declare const definePlugin: <const TPlugin extends CallApiPlugin | AnyFunction<CallApiPlugin>>(plugin: TPlugin) => Writeable<TPlugin, "deep">;
-declare const defineBaseConfig: <const TBaseConfig extends BaseCallApiConfig>(baseConfig: TBaseConfig) => Writeable<typeof baseConfig, "deep">;
-declare const defineParameters: <TData = DefaultDataType, TErrorData = DefaultDataType, TResultMode extends ResultModeUnion = ResultModeUnion, TThrowOnError extends ThrowOnErrorUnion = DefaultThrowOnError, TResponseType extends ResponseTypeUnion = ResponseTypeUnion, TBaseSchemaRoutes extends BaseCallApiSchemaRoutes = BaseCallApiSchemaRoutes, TSchema extends CallApiSchema = CallApiSchema, TBaseSchemaConfig extends CallApiSchemaConfig = CallApiSchemaConfig, TSchemaConfig extends CallApiSchemaConfig = CallApiSchemaConfig, TInitURL extends InferInitURL<BaseCallApiSchemaRoutes, TSchemaConfig> = InferInitURL<BaseCallApiSchemaRoutes, TSchemaConfig>, TCurrentRouteSchemaKey extends string = string, TBasePluginArray extends CallApiPlugin[] = DefaultPluginArray, TPluginArray extends CallApiPlugin[] = DefaultPluginArray>(...parameters: CallApiParameters<TData, TErrorData, TResultMode, TThrowOnError, TResponseType, TBaseSchemaRoutes, TSchema, TBaseSchemaConfig, TSchemaConfig, TInitURL, TCurrentRouteSchemaKey, TBasePluginArray, TPluginArray>) => CallApiParameters<TData, TErrorData, TResultMode, TThrowOnError, TResponseType, TBaseSchemaRoutes, TSchema, TBaseSchemaConfig, TSchemaConfig, TInitURL, TCurrentRouteSchemaKey, TBasePluginArray, TPluginArray>;
+}, TSchema, CallApiSchemaConfig, TSchemaConfig, TInitURL, TCurrentRouteSchemaKey, DefaultPluginArray, TPluginArray>) => Promise<TComputedResult>;
 //#endregion
-export { type BaseCallApiConfig, type BaseCallApiExtraOptions, type BaseCallApiSchemaRoutes, type CallApiConfig, type CallApiExtraOptions, type CallApiExtraOptionsForHooks, type CallApiParameters, type CallApiPlugin, type CallApiRequestOptions, type CallApiRequestOptionsForHooks, type CallApiResult, type CallApiResultErrorVariant, type CallApiResultSuccessVariant, type CallApiSchema, type CallApiSchemaConfig, type CallApiSuccessOrErrorVariant, type DedupeOptions, type ErrorContext, HTTPError, type Hooks, type HooksOrHooksArray, type InferParamsFromRoute, type InferSchemaOutputResult, type PluginExtraOptions, type PluginHooks, type PluginHooksWithMoreOptions, type PluginSetupContext, type PossibleHTTPError, type PossibleJavaScriptError, type PossibleJavaScriptOrValidationError, type PossibleValidationError, type Register, type RequestContext, type RequestStreamContext, type ResponseContext, type ResponseErrorContext, type ResponseStreamContext, type ResponseTypeUnion, type ResultModeUnion, type RetryOptions, type SuccessContext, type URLOptions, ValidationError, callApi, createFetchClient, defineBaseConfig, defineParameters, definePlugin, defineSchema, defineSchemaConfig, defineSchemaRoutes, fallBackRouteSchemaKey };
+export { type BaseCallApiConfig, type BaseCallApiExtraOptions, type BaseCallApiSchemaRoutes, type CallApiConfig, type CallApiExtraOptions, type CallApiExtraOptionsForHooks, type CallApiParameters, type CallApiPlugin, type CallApiRequestOptions, type CallApiRequestOptionsForHooks, type CallApiResult, type CallApiResultErrorVariant, type CallApiResultSuccessVariant, type CallApiSchema, type CallApiSchemaConfig, type CallApiSuccessOrErrorVariant, type DedupeOptions, type ErrorContext, HTTPError, type Hooks, type HooksOrHooksArray, type InferParamsFromRoute, type InferSchemaOutputResult, type PluginExtraOptions, type PluginHooks, type PluginHooksWithMoreOptions, type PluginSetupContext, type PossibleHTTPError, type PossibleJavaScriptError, type PossibleJavaScriptOrValidationError, type PossibleValidationError, type Register, type RequestContext, type RequestStreamContext, type ResponseContext, type ResponseErrorContext, type ResponseStreamContext, type ResponseTypeUnion, type ResultModeUnion, type RetryOptions, type SuccessContext, type URLOptions, ValidationError, callApi, createFetchClient, fallBackRouteSchemaKey };
 //# sourceMappingURL=index.d.ts.map

package/dist/esm/index.js

@@ -1,4 +1,4 @@
-import { HTTPError, ValidationError, createCombinedSignal, createTimeoutSignal, deterministicHashFn, extraOptionDefaults, fallBackRouteSchemaKey, getBody, getCurrentRouteSchemaKeyAndMainInitURL, getFetchImpl, getFullAndNormalizedURL, getHeaders, getMethod, handleConfigValidation, handleSchemaValidation, isArray, isBoolean, isFunction, isHTTPErrorInstance, isObject, isPlainObject, isReadableStream, isString, isValidationErrorInstance, splitBaseConfig, splitConfig, waitFor } from "./common-CfCB_X1k.js";
+import { C as defineEnum, S as requestOptionDefaults, _ as isReadableStream, b as isValidJsonString, c as HTTPError, d as isBoolean, f as isFunction, g as isQueryString, h as isPromise, i as isHTTPErrorInstance, l as ValidationError, m as isPlainObject, n as toQueryString, p as isObject, s as isValidationErrorInstance, u as isArray, v as isSerializable, x as extraOptionDefaults, y as isString } from "./body-BVMFJoeo.js";
 
 //#region src/result.ts
 const getResponseType = (response, parser) => ({
@@ -262,6 +262,427 @@ const toStreamableResponse = async (context) => {
 	return new Response(stream, response);
 };
 
+//#endregion
+//#region src/auth.ts
+const resolveAuthValue = (value) => isFunction(value) ? value() : value;
+const getAuthHeader = async (auth) => {
+	if (auth === void 0) return;
+	if (isPromise(auth) || isFunction(auth) || !isObject(auth)) {
+		const authValue = await resolveAuthValue(auth);
+		if (authValue === void 0) return;
+		return { Authorization: `Bearer ${authValue}` };
+	}
+	switch (auth.type) {
+		case "Basic": {
+			const [username, password] = await Promise.all([resolveAuthValue(auth.username), resolveAuthValue(auth.password)]);
+			if (username === void 0 || password === void 0) return;
+			return { Authorization: `Basic ${globalThis.btoa(`${username}:${password}`)}` };
+		}
+		case "Custom": {
+			const [prefix, value] = await Promise.all([resolveAuthValue(auth.prefix), resolveAuthValue(auth.value)]);
+			if (value === void 0) return;
+			return { Authorization: `${prefix} ${value}` };
+		}
+		default: {
+			const [bearer, token] = await Promise.all([resolveAuthValue(auth.bearer), resolveAuthValue(auth.token)]);
+			if (bearer !== void 0) return { Authorization: `Bearer ${bearer}` };
+			if (token === void 0) return;
+			return { Authorization: `Token ${token}` };
+		}
+	}
+};
+
+//#endregion
+//#region src/constants/common.ts
+const fetchSpecificKeys = defineEnum([
+	"body",
+	"integrity",
+	"duplex",
+	"method",
+	"headers",
+	"signal",
+	"cache",
+	"redirect",
+	"window",
+	"credentials",
+	"keepalive",
+	"referrer",
+	"priority",
+	"mode",
+	"referrerPolicy"
+]);
+
+//#endregion
+//#region src/validation.ts
+const handleValidatorFunction = async (validator, inputData) => {
+	try {
+		return {
+			issues: void 0,
+			value: await validator(inputData)
+		};
+	} catch (error) {
+		return {
+			issues: toArray(error),
+			value: void 0
+		};
+	}
+};
+const standardSchemaParser = async (fullSchema, schemaName, inputData, response) => {
+	const schema = fullSchema?.[schemaName];
+	if (!schema) return inputData;
+	const result = isFunction(schema) ? await handleValidatorFunction(schema, inputData) : await schema["~standard"].validate(inputData);
+	if (result.issues) throw new ValidationError({
+		issueCause: schemaName,
+		issues: result.issues,
+		response: response ?? null
+	});
+	return result.value;
+};
+const routeKeyMethods = defineEnum([
+	"delete",
+	"get",
+	"patch",
+	"post",
+	"put"
+]);
+const handleSchemaValidation = async (fullSchema, schemaName, validationOptions) => {
+	const { inputValue, response, schemaConfig } = validationOptions;
+	if (schemaConfig?.disableRuntimeValidation) return inputValue;
+	return await standardSchemaParser(fullSchema, schemaName, inputValue, response);
+};
+const extraOptionsToBeValidated = [
+	"meta",
+	"params",
+	"query"
+];
+const handleExtraOptionsValidation = async (validationOptions) => {
+	const { options, schema, schemaConfig } = validationOptions;
+	const validationResultArray = await Promise.all(extraOptionsToBeValidated.map((schemaName) => handleSchemaValidation(schema, schemaName, {
+		inputValue: options[schemaName],
+		schemaConfig
+	})));
+	const validatedResultObject = {};
+	for (const [index, schemaName] of extraOptionsToBeValidated.entries()) {
+		const validationResult = validationResultArray[index];
+		if (validationResult === void 0) continue;
+		validatedResultObject[schemaName] = validationResult;
+	}
+	return validatedResultObject;
+};
+const requestOptionsToBeValidated = [
+	"body",
+	"headers",
+	"method"
+];
+const handleRequestOptionsValidation = async (validationOptions) => {
+	const { requestOptions, schema, schemaConfig } = validationOptions;
+	const validationResultArray = await Promise.all(requestOptionsToBeValidated.map((schemaName) => handleSchemaValidation(schema, schemaName, {
+		inputValue: requestOptions[schemaName],
+		schemaConfig
+	})));
+	const validatedResultObject = {};
+	for (const [index, propertyKey] of requestOptionsToBeValidated.entries()) {
+		const validationResult = validationResultArray[index];
+		if (validationResult === void 0) continue;
+		validatedResultObject[propertyKey] = validationResult;
+	}
+	return validatedResultObject;
+};
+const handleConfigValidation = async (validationOptions) => {
+	const { baseExtraOptions, currentRouteSchemaKey, extraOptions, options, requestOptions } = validationOptions;
+	const { currentRouteSchema, resolvedSchema } = getResolvedSchema({
+		baseExtraOptions,
+		currentRouteSchemaKey,
+		extraOptions
+	});
+	const resolvedSchemaConfig = getResolvedSchemaConfig({
+		baseExtraOptions,
+		extraOptions
+	});
+	if (resolvedSchemaConfig?.strict === true && !currentRouteSchema) throw new ValidationError({
+		issueCause: "schemaConfig-(strict)",
+		issues: [{ message: `Strict Mode - No schema found for route '${currentRouteSchemaKey}' ` }],
+		response: null
+	});
+	if (resolvedSchemaConfig?.disableRuntimeValidation) return {
+		extraOptionsValidationResult: null,
+		requestOptionsValidationResult: null,
+		resolvedSchema,
+		resolvedSchemaConfig,
+		shouldApplySchemaOutput: false
+	};
+	const [extraOptionsValidationResult, requestOptionsValidationResult] = await Promise.all([handleExtraOptionsValidation({
+		options,
+		schema: resolvedSchema,
+		schemaConfig: resolvedSchemaConfig
+	}), handleRequestOptionsValidation({
+		requestOptions,
+		schema: resolvedSchema,
+		schemaConfig: resolvedSchemaConfig
+	})]);
+	return {
+		extraOptionsValidationResult,
+		requestOptionsValidationResult,
+		resolvedSchema,
+		resolvedSchemaConfig,
+		shouldApplySchemaOutput: (Boolean(extraOptionsValidationResult) || Boolean(requestOptionsValidationResult)) && !resolvedSchemaConfig?.disableValidationOutputApplication
+	};
+};
+const fallBackRouteSchemaKey = ".";
+const getResolvedSchema = (context) => {
+	const { baseExtraOptions, currentRouteSchemaKey, extraOptions } = context;
+	const fallbackRouteSchema = baseExtraOptions.schema?.routes[fallBackRouteSchemaKey];
+	const currentRouteSchema = baseExtraOptions.schema?.routes[currentRouteSchemaKey];
+	const resolvedRouteSchema = {
+		...fallbackRouteSchema,
+		...currentRouteSchema
+	};
+	return {
+		currentRouteSchema,
+		resolvedSchema: isFunction(extraOptions.schema) ? extraOptions.schema({
+			baseSchemaRoutes: baseExtraOptions.schema?.routes ?? {},
+			currentRouteSchema: resolvedRouteSchema ?? {}
+		}) : extraOptions.schema ?? resolvedRouteSchema
+	};
+};
+const getResolvedSchemaConfig = (context) => {
+	const { baseExtraOptions, extraOptions } = context;
+	return isFunction(extraOptions.schemaConfig) ? extraOptions.schemaConfig({ baseSchemaConfig: baseExtraOptions.schema?.config ?? {} }) : extraOptions.schemaConfig ?? baseExtraOptions.schema?.config;
+};
+const getCurrentRouteSchemaKeyAndMainInitURL = (context) => {
+	const { baseExtraOptions, extraOptions, initURL } = context;
+	const schemaConfig = getResolvedSchemaConfig({
+		baseExtraOptions,
+		extraOptions
+	});
+	let currentRouteSchemaKey = initURL;
+	let mainInitURL = initURL;
+	if (schemaConfig?.prefix && currentRouteSchemaKey.startsWith(schemaConfig.prefix)) {
+		currentRouteSchemaKey = currentRouteSchemaKey.replace(schemaConfig.prefix, "");
+		mainInitURL = mainInitURL.replace(schemaConfig.prefix, schemaConfig.baseURL ?? "");
+	}
+	if (schemaConfig?.baseURL && currentRouteSchemaKey.startsWith(schemaConfig.baseURL)) currentRouteSchemaKey = currentRouteSchemaKey.replace(schemaConfig.baseURL, "");
+	return {
+		currentRouteSchemaKey,
+		mainInitURL
+	};
+};
+
+//#endregion
+//#region src/url.ts
+const slash = "/";
+const colon = ":";
+const openBrace = "{";
+const closeBrace = "}";
+const mergeUrlWithParams = (url, params) => {
+	if (!params) return url;
+	let newUrl = url;
+	if (isArray(params)) {
+		const matchedParamsArray = newUrl.split(slash).filter((part) => part.startsWith(colon) || part.startsWith(openBrace) && part.endsWith(closeBrace));
+		for (const [paramIndex, matchedParam] of matchedParamsArray.entries()) {
+			const stringParamValue = String(params[paramIndex]);
+			newUrl = newUrl.replace(matchedParam, stringParamValue);
+		}
+		return newUrl;
+	}
+	for (const [paramKey, paramValue] of Object.entries(params)) {
+		const colonPattern = `${colon}${paramKey}`;
+		const bracePattern = `${openBrace}${paramKey}${closeBrace}`;
+		const stringValue = String(paramValue);
+		newUrl = newUrl.replace(colonPattern, stringValue);
+		newUrl = newUrl.replace(bracePattern, stringValue);
+	}
+	return newUrl;
+};
+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}`;
+};
+/**
+* @description Extracts the HTTP method from method-prefixed route patterns.
+*
+* Analyzes URLs that start with method modifiers (e.g., "@get/", "@post/") and extracts
+* the HTTP method for use in API requests. This enables method specification directly
+* in route definitions.
+*
+* @param initURL - The URL string to analyze for method modifiers
+* @returns The extracted HTTP method (lowercase) if found, otherwise undefined
+*
+* @example
+* ```typescript
+* // Method extraction from prefixed routes
+* extractMethodFromURL("@get/users");        // Returns: "get"
+* extractMethodFromURL("@post/users");       // Returns: "post"
+* extractMethodFromURL("@put/users/:id");    // Returns: "put"
+* extractMethodFromURL("@delete/users/:id"); // Returns: "delete"
+* extractMethodFromURL("@patch/users/:id");  // Returns: "patch"
+*
+* // No method modifier
+* extractMethodFromURL("/users");            // Returns: undefined
+* extractMethodFromURL("users");             // Returns: undefined
+*
+* // Invalid or unsupported methods
+* extractMethodFromURL("@invalid/users");    // Returns: undefined
+* extractMethodFromURL("@/users");           // Returns: undefined
+*
+* // Edge cases
+* extractMethodFromURL(undefined);           // Returns: undefined
+* extractMethodFromURL("");                  // Returns: undefined
+* ```
+*/
+const extractMethodFromURL = (initURL) => {
+	if (!initURL?.startsWith("@")) return;
+	const method = initURL.split("@")[1]?.split("/")[0];
+	if (!method || !routeKeyMethods.includes(method)) return;
+	return method;
+};
+const normalizeURL = (initURL) => {
+	const methodFromURL = extractMethodFromURL(initURL);
+	if (!methodFromURL) return initURL;
+	return initURL.replace(`@${methodFromURL}/`, "/");
+};
+const getFullAndNormalizedURL = (options) => {
+	const { baseURL, initURL, params, query } = options;
+	const normalizedInitURL = normalizeURL(initURL);
+	const urlWithMergedQueryAndParams = mergeUrlWithQuery(mergeUrlWithParams(normalizedInitURL, params), query);
+	return {
+		fullURL: !urlWithMergedQueryAndParams.startsWith("http") && baseURL ? `${baseURL}${urlWithMergedQueryAndParams}` : urlWithMergedQueryAndParams,
+		normalizedInitURL
+	};
+};
+
+//#endregion
+//#region src/utils/polyfills/combinedSignal.ts
+const createCombinedSignalPolyfill = (signals) => {
+	const controller = new AbortController();
+	const handleAbort = (actualSignal) => {
+		if (controller.signal.aborted) return;
+		controller.abort(actualSignal.reason);
+	};
+	for (const actualSignal of signals) {
+		if (actualSignal.aborted) {
+			handleAbort(actualSignal);
+			break;
+		}
+		actualSignal.addEventListener("abort", () => handleAbort(actualSignal), { signal: controller.signal });
+	}
+	return controller.signal;
+};
+
+//#endregion
+//#region src/utils/polyfills/timeoutSignal.ts
+const createTimeoutSignalPolyfill = (milliseconds) => {
+	const controller = new AbortController();
+	const reason = new DOMException("Request timed out", "TimeoutError");
+	const timeout = setTimeout(() => controller.abort(reason), milliseconds);
+	controller.signal.addEventListener("abort", () => clearTimeout(timeout));
+	return controller.signal;
+};
+
+//#endregion
+//#region src/utils/common.ts
+const omitKeys = (initialObject, keysToOmit) => {
+	const updatedObject = {};
+	const keysToOmitSet = new Set(keysToOmit);
+	for (const [key, value] of Object.entries(initialObject)) if (!keysToOmitSet.has(key)) updatedObject[key] = value;
+	return updatedObject;
+};
+const pickKeys = (initialObject, keysToPick) => {
+	const updatedObject = {};
+	const keysToPickSet = new Set(keysToPick);
+	for (const [key, value] of Object.entries(initialObject)) if (keysToPickSet.has(key)) updatedObject[key] = value;
+	return updatedObject;
+};
+const splitBaseConfig = (baseConfig) => [pickKeys(baseConfig, fetchSpecificKeys), omitKeys(baseConfig, fetchSpecificKeys)];
+const splitConfig = (config) => [pickKeys(config, fetchSpecificKeys), omitKeys(config, fetchSpecificKeys)];
+const objectifyHeaders = (headers) => {
+	if (!headers || isPlainObject(headers)) return headers;
+	return Object.fromEntries(headers);
+};
+const getHeaders = async (options) => {
+	const { auth, body, headers } = options;
+	if (!(Boolean(headers) || Boolean(body) || Boolean(auth))) return;
+	const headersObject = {
+		...await getAuthHeader(auth),
+		...objectifyHeaders(headers)
+	};
+	if (isQueryString(body)) {
+		headersObject["Content-Type"] = "application/x-www-form-urlencoded";
+		return headersObject;
+	}
+	if (isSerializable(body) || isValidJsonString(body)) {
+		headersObject["Content-Type"] = "application/json";
+		headersObject.Accept = "application/json";
+	}
+	return headersObject;
+};
+const getMethod = (ctx) => {
+	const { initURL, method } = ctx;
+	return method?.toUpperCase() ?? extractMethodFromURL(initURL)?.toUpperCase() ?? requestOptionDefaults.method;
+};
+const getBody = (options) => {
+	const { body, bodySerializer } = options;
+	if (isSerializable(body)) return (bodySerializer ?? extraOptionDefaults.bodySerializer)(body);
+	return body;
+};
+const getInitFetchImpl = (customFetchImpl) => {
+	if (customFetchImpl) return customFetchImpl;
+	if (typeof globalThis !== "undefined" && isFunction(globalThis.fetch)) return globalThis.fetch;
+	throw new Error("No fetch implementation found");
+};
+const getFetchImpl = (context) => {
+	const { customFetchImpl, fetchMiddleware, requestContext } = context;
+	const initFetchImpl = getInitFetchImpl(customFetchImpl);
+	return fetchMiddleware ? fetchMiddleware({
+		...requestContext,
+		fetchImpl: initFetchImpl
+	}) : initFetchImpl;
+};
+const PromiseWithResolvers = () => {
+	let reject;
+	let resolve;
+	return {
+		promise: new Promise((res, rej) => {
+			resolve = res;
+			reject = rej;
+		}),
+		reject,
+		resolve
+	};
+};
+const waitFor = (delay) => {
+	if (delay === 0) return;
+	const { promise, resolve } = PromiseWithResolvers();
+	setTimeout(resolve, delay);
+	return promise;
+};
+const createCombinedSignal = (...signals) => {
+	const cleanedSignals = signals.filter((signal) => signal != null);
+	if (!("any" in AbortSignal)) return createCombinedSignalPolyfill(cleanedSignals);
+	return AbortSignal.any(cleanedSignals);
+};
+const createTimeoutSignal = (milliseconds) => {
+	if (milliseconds == null) return null;
+	if (!("timeout" in AbortSignal)) return createTimeoutSignalPolyfill(milliseconds);
+	return AbortSignal.timeout(milliseconds);
+};
+const deterministicHashFn = (value) => {
+	return JSON.stringify(value, (_, val) => {
+		if (!isPlainObject(val)) return val;
+		const sortedKeys = Object.keys(val).toSorted();
+		const result = {};
+		for (const key of sortedKeys) result[key] = val[key];
+		return result;
+	});
+};
+const toArray = (value) => isArray(value) ? value : [value];
+
 //#endregion
 //#region src/dedupe.ts
 const createDedupeStrategy = async (context) => {
@@ -272,16 +693,16 @@ const createDedupeStrategy = async (context) => {
 		if (!(resolvedDedupeStrategy === "cancel" || resolvedDedupeStrategy === "defer")) return null;
 		const dedupeKey$1 = globalOptions.dedupeKey ?? globalOptions.dedupe?.key;
 		const resolvedDedupeKey = isFunction(dedupeKey$1) ? dedupeKey$1(context) : dedupeKey$1;
-		if (resolvedDedupeKey !== void 0) return resolvedDedupeKey;
-		return `${globalOptions.fullURL}-${deterministicHashFn({
+		if (resolvedDedupeKey === void 0) return `${globalOptions.fullURL}-${deterministicHashFn({
 			options: globalOptions,
 			request: globalRequest
 		})}`;
+		return resolvedDedupeKey;
 	};
 	const getDedupeCacheScopeKey = () => {
-		const dedupeCacheScopeKey$1 = globalOptions.dedupeCacheScopeKey ?? globalOptions.dedupe?.cacheScopeKey ?? extraOptionDefaults.dedupeCacheScopeKey;
+		const dedupeCacheScopeKey$1 = globalOptions.dedupeCacheScopeKey ?? globalOptions.dedupe?.cacheScopeKey;
 		const resolvedDedupeCacheScopeKey = isFunction(dedupeCacheScopeKey$1) ? dedupeCacheScopeKey$1(context) : dedupeCacheScopeKey$1;
-		if (resolvedDedupeCacheScopeKey !== void 0) return resolvedDedupeCacheScopeKey;
+		if (resolvedDedupeCacheScopeKey === void 0) return extraOptionDefaults.dedupeCacheScopeKey;
 		return resolvedDedupeCacheScopeKey;
 	};
 	const dedupeKey = getDedupeKey();
@@ -552,11 +973,10 @@ const createRetryStrategy = (ctx) => {
 const $GlobalRequestInfoCache = /* @__PURE__ */ new Map();
 const createFetchClient = (initBaseConfig = {}) => {
 	const $LocalRequestInfoCache = /* @__PURE__ */ new Map();
-	const callApi$1 = async (...parameters) => {
-		const [initURLOrURLObject, initConfig = {}] = parameters;
+	const callApi$1 = async (initURL, initConfig = {}) => {
 		const [fetchOptions, extraOptions] = splitConfig(initConfig);
 		const baseConfig = isFunction(initBaseConfig) ? initBaseConfig({
-			initURL: initURLOrURLObject.toString(),
+			initURL: initURL.toString(),
 			options: extraOptions,
 			request: fetchOptions
 		}) : initBaseConfig;
@@ -576,7 +996,7 @@ const createFetchClient = (initBaseConfig = {}) => {
 		const { resolvedCurrentRouteSchemaKey, resolvedHooks, resolvedInitURL, resolvedMiddlewares, resolvedOptions, resolvedRequestOptions } = await initializePlugins({
 			baseConfig,
 			config,
-			initURL: initURLOrURLObject.toString(),
+			initURL: initURL.toString(),
 			options: mergedExtraOptions,
 			request: mergedRequestOptions
 		});
@@ -595,8 +1015,7 @@ const createFetchClient = (initBaseConfig = {}) => {
 			initURLNormalized: normalizedInitURL
 		};
 		const newFetchController = new AbortController();
-		const timeoutSignal = options.timeout != null ? createTimeoutSignal(options.timeout) : null;
-		const combinedSignal = createCombinedSignal(resolvedRequestOptions.signal, timeoutSignal, newFetchController.signal);
+		const combinedSignal = createCombinedSignal(createTimeoutSignal(options.timeout), resolvedRequestOptions.signal, newFetchController.signal);
 		const initMethod = getMethod({
 			initURL: resolvedInitURL,
 			method: resolvedRequestOptions.method
@@ -728,7 +1147,7 @@ const createFetchClient = (initBaseConfig = {}) => {
 					const hookError = await executeHooksInCatchBlock([options.onRetry?.(retryContext)], hookInfo);
 					if (hookError) return hookError;
 					await waitFor(getDelay());
-					return callApi$1(initURLOrURLObject, {
+					return callApi$1(initURL, {
 						...config,
 						"~retryAttemptCount": currentAttemptCount + 1
 					});
@@ -764,29 +1183,5 @@ const createFetchClient = (initBaseConfig = {}) => {
 const callApi = createFetchClient();
 
 //#endregion
-//#region src/defineHelpers.ts
-const defineSchema = (routes, config) => {
-	return {
-		config: defineSchemaConfig(config),
-		routes: defineSchemaRoutes(routes)
-	};
-};
-const defineSchemaConfig = (config) => {
-	return config;
-};
-const defineSchemaRoutes = (routes) => {
-	return routes;
-};
-const definePlugin = (plugin) => {
-	return plugin;
-};
-const defineBaseConfig = (baseConfig) => {
-	return baseConfig;
-};
-const defineParameters = (...parameters) => {
-	return parameters;
-};
-
-//#endregion
-export { HTTPError, ValidationError, callApi, createFetchClient, defineBaseConfig, defineParameters, definePlugin, defineSchema, defineSchemaConfig, defineSchemaRoutes, fallBackRouteSchemaKey };
+export { HTTPError, ValidationError, callApi, createFetchClient, fallBackRouteSchemaKey };
 //# sourceMappingURL=index.js.map