@zayne-labs/callapi 1.11.30 → 1.11.31

package/README.md

@@ -65,8 +65,8 @@ Structured errors make robust error handling trivial.
 const { data, error } = await callApi("/api/users");
 
 if (error) {
- console.log(error.name); // "HTTPError", "ValidationError"
- console.log(error.errorData); // Actual API response
+	console.log(error.name); // "HTTPError", "ValidationError"
+	console.log(error.errorData); // Actual API response
 }
 ```
 
@@ -76,9 +76,9 @@ Supports exponential backoff and custom retry conditions.
 
 ```js
 await callApi("/api/data", {
- retryAttempts: 3,
- retryStrategy: "exponential",
- retryStatusCodes: [429, 500, 502, 503],
+	retryAttempts: 3,
+	retryStrategy: "exponential",
+	retryStatusCodes: [429, 500, 502, 503],
 });
 ```
 
@@ -92,19 +92,19 @@ import { createFetchClient } from "@zayne-labs/callapi";
 import { defineSchema } from "@zayne-labs/callapi/utils";
 
 const callMainApi = createFetchClient({
- schema: defineSchema({
-  "/users/:id": {
-   data: z.object({
-    id: z.number(),
-    name: z.string(),
-   }),
-  },
- }),
+	schema: defineSchema({
+		"/users/:id": {
+			data: z.object({
+				id: z.number(),
+				name: z.string(),
+			}),
+		},
+	}),
 });
 
 // Fully typed + validated
 const user = await callMainApi("/users/:id", {
- params: { id: 123 },
+	params: { id: 123 },
 });
 ```
 
@@ -114,15 +114,15 @@ Hook into CallApi's lifecycle at any point.
 
 ```js
 const api = createFetchClient({
- onRequest: ({ request }) => {
-  request.headers.set("Authorization", `Bearer ${token}`);
- },
- onError: ({ error }) => {
-  Sentry.captureException(error);
- },
- onResponseStream: ({ event }) => {
-  console.log(`Downloaded ${event.progress}%`);
- },
+	onRequest: ({ request }) => {
+		request.headers.set("Authorization", `Bearer ${token}`);
+	},
+	onError: ({ error }) => {
+		Sentry.captureException(error);
+	},
+	onResponseStream: ({ event }) => {
+		console.log(`Downloaded ${event.progress}%`);
+	},
 });
 ```
 
@@ -132,38 +132,38 @@ Extend functionality with setup, hooks, and middleware.
 
 ```js
 const metricsPlugin = definePlugin({
- id: "metrics",
- name: "Metrics Plugin",
-
- setup: ({ options }) => ({
-  options: {
-   ...options,
-   meta: { startTime: Date.now() },
-  },
- }),
-
- hooks: {
-  onSuccess: ({ options }) => {
-   const duration = Date.now() - options.meta.startTime;
-
-   console.info(`Request took ${duration}ms`);
-  },
- },
-
- middlewares: {
-  fetchMiddleware: (ctx) => async (input, init) => {
-   console.info("→", input);
-
-   const response = await ctx.fetchImpl(input, init);
-
-   console.info("←", response.status);
-   return response;
-  },
- },
+	id: "metrics",
+	name: "Metrics Plugin",
+
+	setup: ({ options }) => ({
+		options: {
+			...options,
+			meta: { startTime: Date.now() },
+		},
+	}),
+
+	hooks: {
+		onSuccess: ({ options }) => {
+			const duration = Date.now() - options.meta.startTime;
+
+			console.info(`Request took ${duration}ms`);
+		},
+	},
+
+	middlewares: {
+		fetchMiddleware: (ctx) => async (input, init) => {
+			console.info("→", input);
+
+			const response = await ctx.fetchImpl(input, init);
+
+			console.info("←", response.status);
+			return response;
+		},
+	},
 });
 
 const api = createFetchClient({
- plugins: [metricsPlugin],
+	plugins: [metricsPlugin],
 });
 ```
 
@@ -195,10 +195,10 @@ const { data } = await callApi("/api/users");
 
 // Configured
 const api = createFetchClient({
- baseURL: "https://api.example.com",
- retryAttempts: 2,
- timeout: 10000,
- onError: ({ error }) => trackError(error),
+	baseURL: "https://api.example.com",
+	retryAttempts: 2,
+	timeout: 10000,
+	onError: ({ error }) => trackError(error),
 });
 ```
 
@@ -206,7 +206,7 @@ const api = createFetchClient({
 
 ```html
 <script type="module">
- import { callApi } from "https://esm.run/@zayne-labs/callapi";
+	import { callApi } from "https://esm.run/@zayne-labs/callapi";
 </script>
 ```
 

package/dist/{index-DvEQIgL-.d.ts → index-DP2YeNBA.d.ts}

@@ -349,6 +349,7 @@ type ResultVariant = "infer-input" | "infer-output";
 type InferSchemaResult<TSchema, TFallbackResult, TResultVariant extends ResultVariant> = undefined extends TSchema ? TFallbackResult : TSchema extends StandardSchemaV1 ? TResultVariant extends "infer-input" ? StandardSchemaV1.InferInput<TSchema> : StandardSchemaV1.InferOutput<TSchema> : TSchema extends AnyFunction<infer TResult> ? Awaited<TResult> : TFallbackResult;
 type InferSchemaOutput<TSchema, TFallbackResult = unknown> = InferSchemaResult<TSchema, TFallbackResult, "infer-output">;
 type InferSchemaInput<TSchema, TFallbackResult = unknown> = InferSchemaResult<TSchema, TFallbackResult, "infer-input">;
+type BooleanObject = { [Key in keyof CallApiSchema]: boolean };
 interface CallApiSchemaConfig {
   /**
    * The base url of the schema. By default it's the baseURL of the callApi instance.
@@ -357,14 +358,14 @@ interface CallApiSchemaConfig {
   /**
    * Disables runtime validation for the schema.
    */
-  disableRuntimeValidation?: boolean;
+  disableRuntimeValidation?: boolean | BooleanObject;
   /**
    * If `true`, the original input value will be used instead of the transformed/validated output.
    *
    * This is useful when you want to validate the input but don't want any transformations
    * applied by the validation schema (e.g., type coercion, default values, etc).
    */
-  disableValidationOutputApplication?: boolean;
+  disableValidationOutputApplication?: boolean | BooleanObject;
   /**
    * Optional url prefix that will be substituted for the `baseURL` of the schemaConfig at runtime.
    *
@@ -1762,24 +1763,17 @@ type CallApiResultErrorVariant<TErrorData> = {
   error: PossibleJavaScriptOrValidationError;
   response: Response | null;
 };
-type CallApiSuccessOrErrorVariant<TData, TError> = CallApiResultErrorVariant<TError> | CallApiResultSuccessVariant<TData>;
-type ResultModeMapWithoutException<TData, TErrorData, TComputedResult extends CallApiSuccessOrErrorVariant<TData, TErrorData> = CallApiSuccessOrErrorVariant<TData, TErrorData>> = UnmaskType<{
+type CallApiResultSuccessOrErrorVariant<TData, TError> = CallApiResultErrorVariant<TError> | CallApiResultSuccessVariant<TData>;
+type ResultModeMap<TData = DefaultDataType, TErrorData = DefaultDataType, TThrowOnError extends ThrowOnErrorUnion = DefaultThrowOnError, TComputedResultWithoutException extends CallApiResultSuccessOrErrorVariant<TData, TErrorData> = CallApiResultSuccessOrErrorVariant<TData, TErrorData>, TComputedResultWithException extends CallApiResultSuccessVariant<TData> = CallApiResultSuccessVariant<TData>, TComputedResult extends (TThrowOnError extends true ? TComputedResultWithException : TComputedResultWithoutException) = (TThrowOnError extends true ? TComputedResultWithException : TComputedResultWithoutException)> = UnmaskType<{
   all: TComputedResult;
   onlyData: TComputedResult["data"];
   onlyResponse: TComputedResult["response"];
-  withoutResponse: DistributiveOmit<TComputedResult, "response">;
+  withoutResponse: Prettify<DistributiveOmit<TComputedResult, "response">>;
 }>;
-type ResultModeMapWithException<TData, TComputedResult extends CallApiResultSuccessVariant<TData> = CallApiResultSuccessVariant<TData>> = {
-  all: TComputedResult;
-  onlyData: TComputedResult["data"];
-  onlyResponse: TComputedResult["response"];
-  withoutResponse: DistributiveOmit<TComputedResult, "response">;
-};
-type ResultModeMap<TData = DefaultDataType, TErrorData = DefaultDataType, TThrowOnError extends ThrowOnErrorUnion = DefaultThrowOnError> = TThrowOnError extends true ? ResultModeMapWithException<TData> : ResultModeMapWithoutException<TData, TErrorData>;
 type ResultModePlaceholder = null;
 type ResultModeUnion = keyof ResultModeMap;
 type ResultModeType = ResultModePlaceholder | ResultModeUnion;
-type InferCallApiResult<TData, TErrorData, TResultMode extends ResultModeType, TThrowOnError extends ThrowOnErrorUnion, TComputedResultModeMapWithException extends ResultModeMapWithException<TData> = ResultModeMapWithException<TData>, TComputedResultModeMap extends ResultModeMap<TData, TErrorData, TThrowOnError> = ResultModeMap<TData, TErrorData, TThrowOnError>> = TErrorData extends false ? TComputedResultModeMapWithException["onlyData"] : TErrorData extends false | undefined ? TComputedResultModeMapWithException["onlyData"] : ResultModePlaceholder extends TResultMode ? TComputedResultModeMap["all"] : TResultMode extends ResultModeUnion ? TComputedResultModeMap[TResultMode] : never;
+type InferCallApiResult<TData, TErrorData, TResultMode extends ResultModeType, TThrowOnError extends ThrowOnErrorUnion, TComputedResultModeMapWithException extends ResultModeMap<TData, TErrorData, true> = ResultModeMap<TData, TErrorData, true>, TComputedResultModeMapWithoutException extends ResultModeMap<TData, TErrorData, TThrowOnError> = ResultModeMap<TData, TErrorData, TThrowOnError>> = TErrorData extends false ? TComputedResultModeMapWithException["onlyData"] : TErrorData extends false | undefined ? TComputedResultModeMapWithException["onlyData"] : ResultModePlaceholder extends TResultMode ? TComputedResultModeMapWithoutException["all"] : TResultMode extends ResultModeUnion ? TComputedResultModeMapWithoutException[TResultMode] : never;
 //#endregion
 //#region src/createFetchClient.d.ts
 declare const createFetchClientWithContext: <TOuterCallApiContext extends CallApiContext = DefaultCallApiContext>() => <TBaseCallApiContext extends CallApiContext = TOuterCallApiContext, TBaseData = TBaseCallApiContext["Data"], TBaseErrorData = TBaseCallApiContext["ErrorData"], TBaseResultMode extends ResultModeType = (TBaseCallApiContext["ResultMode"] extends ResultModeType ? TBaseCallApiContext["ResultMode"] : ResultModeType), TBaseThrowOnError extends ThrowOnErrorUnion = boolean, TBaseResponseType extends ResponseTypeType = ResponseTypeType, const TBaseSchemaAndConfig extends BaseCallApiSchemaAndConfig = BaseCallApiSchemaAndConfig, const TBasePluginArray extends CallApiPlugin[] = DefaultPluginArray, TComputedBaseSchemaConfig extends CallApiSchemaConfig = GetBaseSchemaConfig<TBaseSchemaAndConfig>, TComputedBaseSchemaRoutes extends BaseCallApiSchemaRoutes = GetBaseSchemaRoutes<TBaseSchemaAndConfig>>(initBaseConfig?: BaseCallApiConfig<TBaseCallApiContext, TBaseData, TBaseErrorData, TBaseResultMode, TBaseThrowOnError, TBaseResponseType, TBaseSchemaAndConfig, TBasePluginArray>) => <TData = TBaseData, TErrorData = TBaseErrorData, TResultMode extends ResultModeType = TBaseResultMode, TCallApiContext extends CallApiContext = TBaseCallApiContext, TThrowOnError extends ThrowOnErrorUnion = TBaseThrowOnError, TResponseType extends ResponseTypeType = 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, TComputedData = InferSchemaOutput<TSchema["data"], GetResponseType<TData, TResponseType>>, TComputedErrorData = InferSchemaOutput<TSchema["errorData"], GetResponseType<TErrorData, TResponseType>>, TComputedResult = CallApiResult<TComputedData, TComputedErrorData, TResultMode, TThrowOnError>>(initURL: TInitURL, initConfig?: CallApiConfig<TCallApiContext, TComputedData, TComputedErrorData, TResultMode, TThrowOnError, TResponseType, TComputedBaseSchemaRoutes, TSchema, TComputedBaseSchemaConfig, TSchemaConfig, TInitURL, TCurrentRouteSchemaKey, TBasePluginArray, TPluginArray>) => Promise<TComputedResult>;
@@ -1787,8 +1781,16 @@ declare const createFetchClient: <TBaseCallApiContext extends CallApiContext = D
   all: CallApiResultSuccessVariant<TComputedData>;
   onlyData: NoInferUnMasked<TComputedData>;
   onlyResponse: Response;
-  withoutResponse: Omit<CallApiResultSuccessVariant<TComputedData>, "response">;
-}, ResultModeMap<TComputedData, TComputedErrorData, TThrowOnError>>>(initURL: TInitURL, initConfig?: CallApiConfig<TCallApiContext, TComputedData, TComputedErrorData, TResultMode, TThrowOnError, TResponseType, TComputedBaseSchemaRoutes, TSchema, TComputedBaseSchemaConfig, TSchemaConfig, TInitURL, TCurrentRouteSchemaKey, TBasePluginArray, TPluginArray>) => Promise<TComputedResult>;
+  withoutResponse: {
+    error: null;
+    data: NoInferUnMasked<TComputedData>;
+  };
+}, {
+  all: TThrowOnError extends true ? CallApiResultSuccessVariant<TComputedData> : CallApiResultSuccessOrErrorVariant<TComputedData, TComputedErrorData>;
+  onlyData: (TThrowOnError extends true ? CallApiResultSuccessVariant<TComputedData> : CallApiResultSuccessOrErrorVariant<TComputedData, TComputedErrorData>)["data"];
+  onlyResponse: (TThrowOnError extends true ? CallApiResultSuccessVariant<TComputedData> : CallApiResultSuccessOrErrorVariant<TComputedData, TComputedErrorData>)["response"];
+  withoutResponse: DistributiveOmit<TThrowOnError extends true ? CallApiResultSuccessVariant<TComputedData> : CallApiResultSuccessOrErrorVariant<TComputedData, TComputedErrorData>, "response"> extends infer T ? { [Key in keyof T]: T[Key] } : never;
+}>>(initURL: TInitURL, initConfig?: CallApiConfig<TCallApiContext, TComputedData, TComputedErrorData, TResultMode, TThrowOnError, TResponseType, TComputedBaseSchemaRoutes, TSchema, TComputedBaseSchemaConfig, TSchemaConfig, TInitURL, TCurrentRouteSchemaKey, TBasePluginArray, TPluginArray>) => Promise<TComputedResult>;
 declare const callApi: <TData = unknown, TErrorData = unknown, TResultMode extends ResultModeType = ResultModeType, TCallApiContext extends CallApiContext = DefaultCallApiContext, TThrowOnError extends ThrowOnErrorUnion = boolean, TResponseType extends ResponseTypeType = ResponseTypeType, 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;
   "@default"?: CallApiSchema | undefined;
@@ -1825,8 +1827,16 @@ declare const callApi: <TData = unknown, TErrorData = unknown, TResultMode exten
   all: CallApiResultSuccessVariant<TComputedData>;
   onlyData: NoInferUnMasked<TComputedData>;
   onlyResponse: Response;
-  withoutResponse: Omit<CallApiResultSuccessVariant<TComputedData>, "response">;
-}, ResultModeMap<TComputedData, TComputedErrorData, TThrowOnError>>>(initURL: TInitURL, initConfig?: CallApiConfig<TCallApiContext, TComputedData, TComputedErrorData, TResultMode, TThrowOnError, TResponseType, {
+  withoutResponse: {
+    error: null;
+    data: NoInferUnMasked<TComputedData>;
+  };
+}, {
+  all: TThrowOnError extends true ? CallApiResultSuccessVariant<TComputedData> : CallApiResultSuccessOrErrorVariant<TComputedData, TComputedErrorData>;
+  onlyData: (TThrowOnError extends true ? CallApiResultSuccessVariant<TComputedData> : CallApiResultSuccessOrErrorVariant<TComputedData, TComputedErrorData>)["data"];
+  onlyResponse: (TThrowOnError extends true ? CallApiResultSuccessVariant<TComputedData> : CallApiResultSuccessOrErrorVariant<TComputedData, TComputedErrorData>)["response"];
+  withoutResponse: DistributiveOmit<TThrowOnError extends true ? CallApiResultSuccessVariant<TComputedData> : CallApiResultSuccessOrErrorVariant<TComputedData, TComputedErrorData>, "response"> extends infer T ? { [Key in keyof T]: T[Key] } : never;
+}>>(initURL: TInitURL, initConfig?: CallApiConfig<TCallApiContext, TComputedData, TComputedErrorData, TResultMode, TThrowOnError, TResponseType, {
   [x: AnyString]: CallApiSchema | undefined;
   "@default"?: CallApiSchema | undefined;
   "@delete/"?: CallApiSchema | undefined;
@@ -1836,5 +1846,5 @@ declare const callApi: <TData = unknown, TErrorData = unknown, TResultMode exten
   "@put/"?: CallApiSchema | undefined;
 }, TSchema, CallApiSchemaConfig, TSchemaConfig, TInitURL, TCurrentRouteSchemaKey, DefaultPluginArray, TPluginArray>) => Promise<TComputedResult>;
 //#endregion
-export { Writeable as $, ErrorContext as A, CallApiPlugin as B, InferExtendSchemaContext as C, ValidationError as D, HTTPError as E, ResponseContext as F, BaseSchemaRouteKeyPrefixes as G, PluginSetupContext as H, ResponseErrorContext as I, InferSchemaInput as J, CallApiSchema as K, ResponseStreamContext as L, HooksOrHooksArray as M, RequestContext as N, RetryOptions as O, RequestStreamContext as P, Satisfies as Q, SuccessContext as R, GetExtendSchemaConfigContext as S, Register as T, URLOptions as U, PluginHooks as V, BaseCallApiSchemaRoutes as W, InferParamsFromRoute as X, InferSchemaOutput as Y, AnyFunction as Z, CallApiExtraOptionsForHooks as _, CallApiResultSuccessVariant as a, CallApiRequestOptionsForHooks as b, PossibleJavaScriptError as c, ResponseTypeType as d, ResultModeType as f, CallApiExtraOptions as g, CallApiConfig as h, CallApiResultErrorVariant as i, Hooks as j, DedupeOptions as k, PossibleJavaScriptOrValidationError as l, BaseCallApiExtraOptions as m, createFetchClient as n, CallApiSuccessOrErrorVariant as o, BaseCallApiConfig as p, CallApiSchemaConfig as q, createFetchClientWithContext as r, PossibleHTTPError as s, callApi as t, PossibleValidationError as u, CallApiParameters as v, InstanceContext as w, CallApiResultLoose as x, CallApiRequestOptions as y, DefaultCallApiContext as z };
-//# sourceMappingURL=index-DvEQIgL-.d.ts.map
+export { Writeable as $, ErrorContext as A, CallApiPlugin as B, InferExtendSchemaContext as C, ValidationError as D, HTTPError as E, ResponseContext as F, BaseSchemaRouteKeyPrefixes as G, PluginSetupContext as H, ResponseErrorContext as I, InferSchemaInput as J, CallApiSchema as K, ResponseStreamContext as L, HooksOrHooksArray as M, RequestContext as N, RetryOptions as O, RequestStreamContext as P, Satisfies as Q, SuccessContext as R, GetExtendSchemaConfigContext as S, Register as T, URLOptions as U, PluginHooks as V, BaseCallApiSchemaRoutes as W, InferParamsFromRoute as X, InferSchemaOutput as Y, AnyFunction as Z, CallApiExtraOptionsForHooks as _, CallApiResultSuccessOrErrorVariant as a, CallApiRequestOptionsForHooks as b, PossibleJavaScriptError as c, ResponseTypeType as d, ResultModeType as f, CallApiExtraOptions as g, CallApiConfig as h, CallApiResultErrorVariant as i, Hooks as j, DedupeOptions as k, PossibleJavaScriptOrValidationError as l, BaseCallApiExtraOptions as m, createFetchClient as n, CallApiResultSuccessVariant as o, BaseCallApiConfig as p, CallApiSchemaConfig as q, createFetchClientWithContext as r, PossibleHTTPError as s, callApi as t, PossibleValidationError as u, CallApiParameters as v, InstanceContext as w, CallApiResultLoose as x, CallApiRequestOptions as y, DefaultCallApiContext as z };
+//# sourceMappingURL=index-DP2YeNBA.d.ts.map

package/dist/index.d.ts

@@ -1,3 +1,3 @@
 import "./validation-Do6HBp6Z.js";
-import { A as ErrorContext, B as CallApiPlugin, C as InferExtendSchemaContext, F as ResponseContext, G as BaseSchemaRouteKeyPrefixes, H as PluginSetupContext, I as ResponseErrorContext, J as InferSchemaInput, K as CallApiSchema, L as ResponseStreamContext, M as HooksOrHooksArray, N as RequestContext, O as RetryOptions, P as RequestStreamContext, R as SuccessContext, S as GetExtendSchemaConfigContext, T as Register, U as URLOptions, V as PluginHooks, W as BaseCallApiSchemaRoutes, X as InferParamsFromRoute, Y as InferSchemaOutput, _ as CallApiExtraOptionsForHooks, a as CallApiResultSuccessVariant, b as CallApiRequestOptionsForHooks, c as PossibleJavaScriptError, d as ResponseTypeType, f as ResultModeType, g as CallApiExtraOptions, h as CallApiConfig, i as CallApiResultErrorVariant, j as Hooks, k as DedupeOptions, l as PossibleJavaScriptOrValidationError, m as BaseCallApiExtraOptions, n as createFetchClient, o as CallApiSuccessOrErrorVariant, p as BaseCallApiConfig, q as CallApiSchemaConfig, r as createFetchClientWithContext, s as PossibleHTTPError, t as callApi, u as PossibleValidationError, v as CallApiParameters, w as InstanceContext, x as CallApiResultLoose, y as CallApiRequestOptions, z as DefaultCallApiContext } from "./index-DvEQIgL-.js";
-export { BaseCallApiConfig, BaseCallApiExtraOptions, BaseCallApiSchemaRoutes, BaseSchemaRouteKeyPrefixes, CallApiConfig, CallApiExtraOptions, CallApiExtraOptionsForHooks, CallApiParameters, CallApiPlugin, CallApiRequestOptions, CallApiRequestOptionsForHooks, CallApiResultLoose as CallApiResult, CallApiResultErrorVariant, CallApiResultSuccessVariant, CallApiSchema, CallApiSchemaConfig, CallApiSuccessOrErrorVariant, DedupeOptions, DefaultCallApiContext, ErrorContext, GetExtendSchemaConfigContext, Hooks, HooksOrHooksArray, InferExtendSchemaContext, InferParamsFromRoute, InferSchemaInput, InferSchemaOutput, InstanceContext, PluginHooks, PluginSetupContext, PossibleHTTPError, PossibleJavaScriptError, PossibleJavaScriptOrValidationError, PossibleValidationError, Register, RequestContext, RequestStreamContext, ResponseContext, ResponseErrorContext, ResponseStreamContext, ResponseTypeType, ResultModeType, RetryOptions, SuccessContext, URLOptions, callApi, createFetchClient, createFetchClientWithContext };
+import { A as ErrorContext, B as CallApiPlugin, C as InferExtendSchemaContext, F as ResponseContext, G as BaseSchemaRouteKeyPrefixes, H as PluginSetupContext, I as ResponseErrorContext, J as InferSchemaInput, K as CallApiSchema, L as ResponseStreamContext, M as HooksOrHooksArray, N as RequestContext, O as RetryOptions, P as RequestStreamContext, R as SuccessContext, S as GetExtendSchemaConfigContext, T as Register, U as URLOptions, V as PluginHooks, W as BaseCallApiSchemaRoutes, X as InferParamsFromRoute, Y as InferSchemaOutput, _ as CallApiExtraOptionsForHooks, a as CallApiResultSuccessOrErrorVariant, b as CallApiRequestOptionsForHooks, c as PossibleJavaScriptError, d as ResponseTypeType, f as ResultModeType, g as CallApiExtraOptions, h as CallApiConfig, i as CallApiResultErrorVariant, j as Hooks, k as DedupeOptions, l as PossibleJavaScriptOrValidationError, m as BaseCallApiExtraOptions, n as createFetchClient, o as CallApiResultSuccessVariant, p as BaseCallApiConfig, q as CallApiSchemaConfig, r as createFetchClientWithContext, s as PossibleHTTPError, t as callApi, u as PossibleValidationError, v as CallApiParameters, w as InstanceContext, x as CallApiResultLoose, y as CallApiRequestOptions, z as DefaultCallApiContext } from "./index-DP2YeNBA.js";
+export { BaseCallApiConfig, BaseCallApiExtraOptions, BaseCallApiSchemaRoutes, BaseSchemaRouteKeyPrefixes, CallApiConfig, CallApiExtraOptions, CallApiExtraOptionsForHooks, CallApiParameters, CallApiPlugin, CallApiRequestOptions, CallApiRequestOptionsForHooks, CallApiResultLoose as CallApiResult, CallApiResultErrorVariant, CallApiResultSuccessOrErrorVariant, CallApiResultSuccessVariant, CallApiSchema, CallApiSchemaConfig, DedupeOptions, DefaultCallApiContext, ErrorContext, GetExtendSchemaConfigContext, Hooks, HooksOrHooksArray, InferExtendSchemaContext, InferParamsFromRoute, InferSchemaInput, InferSchemaOutput, InstanceContext, PluginHooks, PluginSetupContext, PossibleHTTPError, PossibleJavaScriptError, PossibleJavaScriptOrValidationError, PossibleValidationError, Register, RequestContext, RequestStreamContext, ResponseContext, ResponseErrorContext, ResponseStreamContext, ResponseTypeType, ResultModeType, RetryOptions, SuccessContext, URLOptions, callApi, createFetchClient, createFetchClientWithContext };

package/dist/index.js

@@ -67,11 +67,15 @@ const routeKeyMethods = defineEnum([
 ]);
 const handleSchemaValidation = async (fullSchema, schemaName, validationOptions) => {
 	const { inputValue, response, schemaConfig } = validationOptions;
-	if (schemaConfig?.disableRuntimeValidation) return inputValue;
-	return await standardSchemaParser(fullSchema, schemaName, {
+	const disableRuntimeValidationBooleanObject = isObject(schemaConfig?.disableRuntimeValidation) ? schemaConfig.disableRuntimeValidation : {};
+	if (schemaConfig?.disableRuntimeValidation === true || disableRuntimeValidationBooleanObject[schemaName] === true) return inputValue;
+	const validResult = await standardSchemaParser(fullSchema, schemaName, {
 		inputValue,
 		response
 	});
+	const disableResultApplicationBooleanObject = isObject(schemaConfig?.disableValidationOutputApplication) ? schemaConfig.disableValidationOutputApplication : {};
+	if (schemaConfig?.disableValidationOutputApplication === true || disableResultApplicationBooleanObject[schemaName] === true) return inputValue;
+	return validResult;
 };
 const extraOptionsToBeValidated = [
 	"meta",
@@ -98,11 +102,13 @@ const requestOptionsToBeValidated = [
 	"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 { request, schema, schemaConfig } = validationOptions;
+	const validationResultArray = await Promise.all(requestOptionsToBeValidated.map((schemaName) => {
+		return handleSchemaValidation(schema, schemaName, {
+			inputValue: request[schemaName],
+			schemaConfig
+		});
+	}));
 	const validatedResultObject = {};
 	for (const [index, propertyKey] of requestOptionsToBeValidated.entries()) {
 		const validationResult = validationResultArray[index];
@@ -112,7 +118,7 @@ const handleRequestOptionsValidation = async (validationOptions) => {
 	return validatedResultObject;
 };
 const handleConfigValidation = async (validationOptions) => {
-	const { baseExtraOptions, currentRouteSchemaKey, extraOptions, options, requestOptions } = validationOptions;
+	const { baseExtraOptions, currentRouteSchemaKey, extraOptions, options, request } = validationOptions;
 	const { currentRouteSchema, resolvedSchema } = getResolvedSchema({
 		baseExtraOptions,
 		currentRouteSchemaKey,
@@ -127,19 +133,12 @@ const handleConfigValidation = async (validationOptions) => {
 		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,
+		request,
 		schema: resolvedSchema,
 		schemaConfig: resolvedSchemaConfig
 	})]);
@@ -147,8 +146,7 @@ const handleConfigValidation = async (validationOptions) => {
 		extraOptionsValidationResult,
 		requestOptionsValidationResult,
 		resolvedSchema,
-		resolvedSchemaConfig,
-		shouldApplySchemaOutput: (Boolean(extraOptionsValidationResult) || Boolean(requestOptionsValidationResult)) && !resolvedSchemaConfig?.disableValidationOutputApplication
+		resolvedSchemaConfig
 	};
 };
 const getResolvedSchema = (context) => {
@@ -327,12 +325,21 @@ const objectifyHeaders = (headers) => {
 	if (!headers || isPlainObject(headers)) return headers;
 	return Object.fromEntries(headers);
 };
+const getResolvedHeaders = (options) => {
+	const { baseHeaders, headers } = options;
+	const resolvedHeaders = isFunction(headers) ? headers({ baseHeaders: baseHeaders ?? {} }) : headers ?? baseHeaders;
+	if (!resolvedHeaders) return;
+	return objectifyHeaders(resolvedHeaders);
+};
 const getHeaders = async (options) => {
-	const { auth, body, headers } = options;
-	if (!(Boolean(headers) || Boolean(body) || Boolean(auth))) return;
+	const { auth, baseHeaders, body, headers } = options;
+	const resolvedHeaders = getResolvedHeaders({
+		baseHeaders,
+		headers
+	});
 	const headersObject = {
 		...await getAuthHeader(auth),
-		...objectifyHeaders(headers)
+		...objectifyHeaders(resolvedHeaders)
 	};
 	if (isQueryString(body)) {
 		headersObject["Content-Type"] = "application/x-www-form-urlencoded";
@@ -803,7 +810,7 @@ const initializePlugins = async (context) => {
 	let resolvedCurrentRouteSchemaKey = currentRouteSchemaKey;
 	let resolvedInitURL = mainInitURL;
 	let resolvedOptions = options;
-	let resolvedRequestOptions = request;
+	let resolvedRequest = request;
 	const executePluginSetupFn = async (pluginSetup) => {
 		if (!pluginSetup) return;
 		const initResult = await pluginSetup(context);
@@ -818,10 +825,24 @@ const initializePlugins = async (context) => {
 			resolvedCurrentRouteSchemaKey = newResult.currentRouteSchemaKey;
 			resolvedInitURL = newResult.mainInitURL;
 		}
-		if (isPlainObject(initResult.request)) resolvedRequestOptions = {
-			...resolvedRequestOptions,
-			...initResult.request
-		};
+		if (isPlainObject(initResult.request)) {
+			const initMethod = getMethod({
+				initURL: resolvedInitURL,
+				method: initResult.request.method ?? resolvedRequest.method
+			});
+			const initHeaders = await getHeaders({
+				auth: options.auth,
+				baseHeaders: baseConfig.headers,
+				body: initResult.request.body ?? resolvedRequest.body,
+				headers: initResult.request.headers ?? resolvedRequest.headers
+			});
+			resolvedRequest = {
+				...resolvedRequest,
+				...initResult.request,
+				headers: initHeaders,
+				method: initMethod
+			};
+		}
 		if (isPlainObject(initResult.options)) resolvedOptions = {
 			...resolvedOptions,
 			...initResult.options
@@ -850,7 +871,7 @@ const initializePlugins = async (context) => {
 		resolvedInitURL,
 		resolvedMiddlewares,
 		resolvedOptions,
-		resolvedRequestOptions
+		resolvedRequest
 	};
 };
 const setupHooksAndMiddlewares = (context) => {
@@ -1000,7 +1021,7 @@ const createFetchClientWithContext = () => {
 				...baseFetchOptions,
 				...!shouldSkipAutoMergeForRequest && fetchOptions
 			};
-			const { resolvedCurrentRouteSchemaKey, resolvedHooks, resolvedInitURL, resolvedMiddlewares, resolvedOptions, resolvedRequestOptions } = await initializePlugins({
+			const { resolvedCurrentRouteSchemaKey, resolvedHooks, resolvedInitURL, resolvedMiddlewares, resolvedOptions, resolvedRequest } = await initializePlugins({
 				baseConfig,
 				config,
 				initURL: initURL.toString(),
@@ -1022,14 +1043,9 @@ const createFetchClientWithContext = () => {
 				initURLNormalized: normalizedInitURL
 			};
 			const newFetchController = new AbortController();
-			const combinedSignal = createCombinedSignal(createTimeoutSignal(options.timeout), resolvedRequestOptions.signal, newFetchController.signal);
-			const initMethod = getMethod({
-				initURL: resolvedInitURL,
-				method: resolvedRequestOptions.method
-			});
+			const combinedSignal = createCombinedSignal(createTimeoutSignal(options.timeout), resolvedRequest.signal, newFetchController.signal);
 			const request = {
-				...resolvedRequestOptions,
-				method: initMethod,
+				...resolvedRequest,
 				signal: combinedSignal
 			};
 			const { getAbortErrorMessage, handleRequestCancelStrategy, handleRequestDeferStrategy, removeDedupeKeyFromCache, resolvedDedupeStrategy } = await createDedupeStrategy({
@@ -1049,32 +1065,30 @@ const createFetchClientWithContext = () => {
 					options,
 					request
 				}));
-				const { extraOptionsValidationResult, requestOptionsValidationResult, resolvedSchema, resolvedSchemaConfig, shouldApplySchemaOutput } = await handleConfigValidation({
+				const { extraOptionsValidationResult, requestOptionsValidationResult, resolvedSchema, resolvedSchemaConfig } = await handleConfigValidation({
 					baseExtraOptions,
 					currentRouteSchemaKey: resolvedCurrentRouteSchemaKey,
 					extraOptions,
 					options,
-					requestOptions: request
-				});
-				if (shouldApplySchemaOutput) Object.assign(options, extraOptionsValidationResult);
-				const validMethod = getMethod({
-					initURL: resolvedInitURL,
-					method: shouldApplySchemaOutput ? requestOptionsValidationResult?.method : request.method
+					request
 				});
+				Object.assign(options, extraOptionsValidationResult);
 				const validBody = getBody({
-					body: shouldApplySchemaOutput ? requestOptionsValidationResult?.body : request.body,
+					body: requestOptionsValidationResult.body,
 					bodySerializer: options.bodySerializer
 				});
-				const resolvedHeaders = isFunction(fetchOptions.headers) ? fetchOptions.headers({ baseHeaders: baseFetchOptions.headers ?? {} }) : fetchOptions.headers ?? baseFetchOptions.headers;
-				const validHeaders = await getHeaders({
-					auth: options.auth,
-					body: validBody,
-					headers: shouldApplySchemaOutput ? requestOptionsValidationResult?.headers : resolvedHeaders
-				});
 				Object.assign(request, {
-					...validBody && { body: validBody },
-					...validHeaders && { headers: validHeaders },
-					...validMethod && { method: validMethod }
+					body: validBody,
+					headers: await getHeaders({
+						auth: options.auth,
+						baseHeaders: baseConfig.headers,
+						body: validBody,
+						headers: requestOptionsValidationResult.headers
+					}),
+					method: getMethod({
+						initURL: resolvedInitURL,
+						method: requestOptionsValidationResult.method
+					})
 				});
 				const readyRequestContext = {
 					baseConfig,