@zayne-labs/callapi 1.8.2 → 1.8.4

package/dist/esm/{common-Cg-2dq0u.d.ts → common-BR-RZ84M.d.ts}

@@ -74,27 +74,6 @@ type Auth = BearerOrTokenAuth | BasicAuth | CustomAuth;
 //#region src/constants/common.d.ts
 declare const fetchSpecificKeys: (keyof RequestInit | "duplex")[];
 //#endregion
-//#region src/error.d.ts
-type ErrorDetails<TErrorData> = {
-  defaultErrorMessage: CallApiExtraOptions["defaultErrorMessage"];
-  errorData: TErrorData;
-  response: Response;
-};
-declare class HTTPError<TErrorData = Record<string, unknown>> extends Error {
-  errorData: ErrorDetails<TErrorData>["errorData"];
-  httpErrorSymbol: symbol;
-  isHTTPError: boolean;
-  name: "HTTPError";
-  response: ErrorDetails<TErrorData>["response"];
-  constructor(errorDetails: ErrorDetails<TErrorData>, errorOptions?: ErrorOptions);
-  /**
-   * @description Checks if the given error is an instance of HTTPError
-   * @param error - The error to check
-   * @returns true if the error is an instance of HTTPError, false otherwise
-   */
-  static isError<TErrorData>(error: unknown): error is HTTPError<TErrorData>;
-}
-//#endregion
 //#region src/types/standard-schema.d.ts
 /**
  * The Standard Schema interface.
@@ -195,16 +174,34 @@ declare namespace StandardSchemaV1 {
   type InferOutput<Schema extends StandardSchemaV1> = NonNullable<Schema["~standard"]["types"]>["output"];
 }
 //#endregion
-//#region src/validation.d.ts
-type InferSchemaResult<TSchema, TFallbackResult = NonNullable<unknown>> = undefined extends TSchema ? TFallbackResult : TSchema extends StandardSchemaV1 ? StandardSchemaV1.InferOutput<TSchema> : TSchema extends AnyFunction<infer TResult> ? Awaited<TResult> : TFallbackResult;
+//#region src/error.d.ts
+type HTTPErrorDetails<TErrorData> = {
+  defaultErrorMessage: CallApiExtraOptions["defaultErrorMessage"];
+  errorData: TErrorData;
+  response: Response;
+};
+declare class HTTPError<TErrorData = Record<string, unknown>> extends Error {
+  errorData: HTTPErrorDetails<TErrorData>["errorData"];
+  httpErrorSymbol: symbol;
+  isHTTPError: boolean;
+  name: "HTTPError";
+  response: HTTPErrorDetails<TErrorData>["response"];
+  constructor(errorDetails: HTTPErrorDetails<TErrorData>, errorOptions?: ErrorOptions);
+  /**
+   * @description Checks if the given error is an instance of HTTPError
+   * @param error - The error to check
+   * @returns true if the error is an instance of HTTPError, false otherwise
+   */
+  static isError<TErrorData>(error: unknown): error is HTTPError<TErrorData>;
+}
 type ValidationErrorDetails = {
   issues: readonly StandardSchemaV1.Issue[];
   response: Response | null;
 };
 declare class ValidationError extends Error {
-  errorData: readonly StandardSchemaV1.Issue[];
+  errorData: ValidationErrorDetails["issues"];
   name: string;
-  response: Response | null;
+  response: ValidationErrorDetails["response"];
   validationErrorSymbol: symbol;
   constructor(details: ValidationErrorDetails, errorOptions?: ErrorOptions);
   /**
@@ -214,6 +211,9 @@ declare class ValidationError extends Error {
    */
   static isError(error: unknown): error is ValidationError;
 }
+//#endregion
+//#region src/validation.d.ts
+type InferSchemaResult<TSchema, TFallbackResult = NonNullable<unknown>> = undefined extends TSchema ? TFallbackResult : TSchema extends StandardSchemaV1 ? StandardSchemaV1.InferOutput<TSchema> : TSchema extends AnyFunction<infer TResult> ? Awaited<TResult> : TFallbackResult;
 interface CallApiSchemaConfig {
   /**
    * The base url of the schema. By default it's the baseURL of the fetch instance.
@@ -299,7 +299,7 @@ type AllowedQueryParamValues = UnmaskType<boolean | number | string>;
 type Params = UnmaskType<Record<string, AllowedQueryParamValues> | AllowedQueryParamValues[]>;
 type Query = UnmaskType<Record<string, AllowedQueryParamValues>>;
 type InitURLOrURLObject = string | URL;
-interface UrlOptions {
+interface URLOptions {
   /**
    * Base URL to be prepended to all request URLs
    */
@@ -334,8 +334,8 @@ type PluginInitResult = Partial<Omit<PluginInitContext, "initURL" | "request"> &
   initURL: InitURLOrURLObject;
   request: CallApiRequestOptions;
 }>;
-type PluginHooksWithMoreOptions<TMoreOptions = unknown> = HooksOrHooksArray<never, never, TMoreOptions>;
-type PluginHooks<TData = never, TErrorData = never, TMoreOptions = unknown> = HooksOrHooksArray<TData, TErrorData, TMoreOptions>;
+type PluginHooksWithMoreOptions<TMoreOptions = unknown> = HooksOrHooksArray<never, never, CallApiSchema, string, TMoreOptions>;
+type PluginHooks<TData = never, TErrorData = never, TMoreOptions = unknown> = HooksOrHooksArray<TData, TErrorData, CallApiSchema, string, TMoreOptions>;
 interface CallApiPlugin {
   /**
    * Defines additional options that can be passed to callApi
@@ -458,51 +458,51 @@ declare global {
 type PluginExtraOptions<TPluginOptions = unknown> = {
   options: Partial<TPluginOptions>;
 };
-interface Hooks<TData = DefaultDataType, TErrorData = DefaultDataType, TPluginOptions = unknown> {
+interface Hooks<TData = DefaultDataType, TErrorData = DefaultDataType, TPluginOptions = unknown, TSchema extends CallApiSchema = CallApiSchema, TCurrentRouteKey extends string = string> {
   /**
    * Hook that will be called when any error occurs within the request/response lifecycle, regardless of whether the error is from the api or not.
    * It is basically a combination of `onRequestError` and `onResponseError` hooks
    */
-  onError?: (context: ErrorContext<TErrorData> & PluginExtraOptions<TPluginOptions>) => Awaitable<unknown>;
+  onError?: (context: ErrorContext<TErrorData> & RequestContext<TSchema, TCurrentRouteKey> & PluginExtraOptions<TPluginOptions>) => Awaitable<unknown>;
   /**
    * Hook that will be called just before the request is being made.
    */
-  onRequest?: (context: RequestContext & PluginExtraOptions<TPluginOptions>) => Awaitable<unknown>;
+  onRequest?: (context: RequestContext<TSchema, TCurrentRouteKey> & PluginExtraOptions<TPluginOptions>) => Awaitable<unknown>;
   /**
    *  Hook that will be called when an error occurs during the fetch request.
    */
-  onRequestError?: (context: RequestErrorContext & PluginExtraOptions<TPluginOptions>) => Awaitable<unknown>;
+  onRequestError?: (context: RequestErrorContext & RequestContext<TSchema, TCurrentRouteKey> & PluginExtraOptions<TPluginOptions>) => Awaitable<unknown>;
   /**
    * Hook that will be called when upload stream progress is tracked
    */
-  onRequestStream?: (context: RequestStreamContext & PluginExtraOptions<TPluginOptions>) => Awaitable<unknown>;
+  onRequestStream?: (context: RequestStreamContext & RequestContext<TSchema, TCurrentRouteKey> & PluginExtraOptions<TPluginOptions>) => Awaitable<unknown>;
   /**
    * Hook that will be called when any response is received from the api, whether successful or not
    */
-  onResponse?: (context: ResponseContext<TData, TErrorData> & PluginExtraOptions<TPluginOptions>) => Awaitable<unknown>;
+  onResponse?: (context: ResponseContext<TData, TErrorData> & RequestContext<TSchema, TCurrentRouteKey> & PluginExtraOptions<TPluginOptions>) => Awaitable<unknown>;
   /**
    *  Hook that will be called when an error response is received from the api.
    */
-  onResponseError?: (context: ResponseErrorContext<TErrorData> & PluginExtraOptions<TPluginOptions>) => Awaitable<unknown>;
+  onResponseError?: (context: ResponseErrorContext<TErrorData> & RequestContext<TSchema, TCurrentRouteKey> & PluginExtraOptions<TPluginOptions>) => Awaitable<unknown>;
   /**
    * Hook that will be called when download stream progress is tracked
    */
-  onResponseStream?: (context: ResponseStreamContext & PluginExtraOptions<TPluginOptions>) => Awaitable<unknown>;
+  onResponseStream?: (context: ResponseStreamContext & RequestContext<TSchema, TCurrentRouteKey> & PluginExtraOptions<TPluginOptions>) => Awaitable<unknown>;
   /**
    * Hook that will be called when a request is retried.
    */
-  onRetry?: (response: RetryContext<TErrorData> & PluginExtraOptions<TPluginOptions>) => Awaitable<unknown>;
+  onRetry?: (response: RetryContext<TErrorData> & RequestContext<TSchema, TCurrentRouteKey> & PluginExtraOptions<TPluginOptions>) => Awaitable<unknown>;
   /**
    * Hook that will be called when a successful response is received from the api.
    */
-  onSuccess?: (context: SuccessContext<TData> & PluginExtraOptions<TPluginOptions>) => Awaitable<unknown>;
+  onSuccess?: (context: SuccessContext<TData> & RequestContext<TSchema, TCurrentRouteKey> & PluginExtraOptions<TPluginOptions>) => Awaitable<unknown>;
   /**
    * Hook that will be called when a validation error occurs.
    */
-  onValidationError?: (context: ValidationErrorContext & PluginExtraOptions<TPluginOptions>) => Awaitable<unknown>;
+  onValidationError?: (context: ValidationErrorContext & RequestContext<TSchema, TCurrentRouteKey> & PluginExtraOptions<TPluginOptions>) => Awaitable<unknown>;
 }
-type HooksOrHooksArray<TData = DefaultDataType, TErrorData = DefaultDataType, TMoreOptions = unknown> = { [Key in keyof Hooks<TData, TErrorData, TMoreOptions>]: Hooks<TData, TErrorData, TMoreOptions>[Key] | Array<Hooks<TData, TErrorData, TMoreOptions>[Key]> };
-type RequestContext = {
+type HooksOrHooksArray<TData = DefaultDataType, TErrorData = DefaultDataType, TSchema extends CallApiSchema = CallApiSchema, TCurrentRouteKey extends string = string, TMoreOptions = unknown> = { [Key in keyof Hooks<TData, TErrorData, TMoreOptions, TSchema, TCurrentRouteKey>]: Hooks<TData, TErrorData, TMoreOptions, TSchema, TCurrentRouteKey>[Key] | Array<Hooks<TData, TErrorData, TMoreOptions, TSchema, TCurrentRouteKey>[Key]> };
+type RequestContext<TSchema extends CallApiSchema = CallApiSchema, TCurrentRouteKey extends string = string> = {
   /**
    * Config object passed to createFetchClient
    */
@@ -515,13 +515,13 @@ type RequestContext = {
    * Merged options consisting of extra options from createFetchClient, the callApi instance and default options.
    *
    */
-  options: CombinedCallApiExtraOptions;
+  options: InferExtraOptions<TSchema, TCurrentRouteKey> & Omit<CombinedCallApiExtraOptions, keyof InferExtraOptions<CallApiSchema, string>>;
   /**
    * Merged request consisting of request options from createFetchClient, the callApi instance and default request options.
    */
-  request: CallApiRequestOptionsForHooks;
+  request: Omit<CallApiRequestOptionsForHooks, keyof Omit<InferRequestOptions<TSchema, CallApiSchemaConfig, string>, "headers">> & Omit<InferRequestOptions<TSchema, CallApiSchemaConfig, string>, "headers">;
 };
-type ResponseContext<TData, TErrorData> = RequestContext & ({
+type ResponseContext<TData, TErrorData> = {
   data: null;
   error: PossibleHTTPError<TErrorData>;
   response: Response;
@@ -533,44 +533,50 @@ type ResponseContext<TData, TErrorData> = RequestContext & ({
   data: TData;
   error: null;
   response: Response;
-});
-type ValidationErrorContext = RequestContext & {
+};
+type ValidationErrorContext = {
   error: ValidationError;
   response: Response | null;
 };
-type SuccessContext<TData> = RequestContext & {
+type SuccessContext<TData> = {
   data: TData;
   response: Response;
 };
-type RequestErrorContext = UnmaskType<RequestContext & {
+type RequestErrorContext = {
   error: PossibleJavaScriptOrValidationError;
   response: null;
-}>;
-type ResponseErrorContext<TErrorData> = UnmaskType<RequestContext & {
+};
+type ResponseErrorContext<TErrorData> = Extract<ErrorContext<TErrorData>, {
   error: PossibleHTTPError<TErrorData>;
-  response: Response;
 }>;
-type RetryContext<TErrorData> = UnmaskType<ErrorContext<TErrorData> & {
+type RetryContext<TErrorData> = ErrorContext<TErrorData> & {
   retryAttemptCount: number;
-}>;
-type ErrorContext<TErrorData> = UnmaskType<RequestContext & ({
+};
+type ErrorContext<TErrorData> = {
   error: PossibleHTTPError<TErrorData>;
   response: Response;
 } | {
   error: PossibleJavaScriptOrValidationError;
   response: Response | null;
-})>;
-type RequestStreamContext = UnmaskType<RequestContext & {
+};
+type RequestStreamContext = {
   event: StreamProgressEvent;
   requestInstance: Request;
-}>;
-type ResponseStreamContext = UnmaskType<RequestContext & {
+};
+type ResponseStreamContext = {
   event: StreamProgressEvent;
   response: Response;
-}>;
+};
 //#endregion
 //#region src/dedupe.d.ts
 type DedupeOptions = {
+  /**
+   * Defines the scope of the deduplication cache, can be set to "global" | "local".
+   * - If set to "global", the deduplication cache will be shared across all requests, regardless of whether they shared the same `createFetchClient` or not.
+   * - If set to "local", the deduplication cache will be scoped to the current request.
+   * @default "local"
+   */
+  dedupeCacheScope?: "global" | "local";
   /**
    * Custom request key to be used to identify a request in the fetch deduplication strategy.
    * @default the full request url + string formed from the request options
@@ -669,7 +675,7 @@ type InferMethodOption<TSchema extends CallApiSchema, TSchemaConfig extends Call
    */
   method?: InferSchemaResult<TSchema["method"], InferMethodFromURL<TInitURL>>;
 }>>;
-type HeadersOption = UnmaskType<Record<"Authorization", CommonAuthorizationHeaders> | Record<"Content-Type", CommonContentTypes> | Record<CommonRequestHeaders, string | undefined> | Record<string, string | undefined> | RequestInit["headers"]>;
+type HeadersOption = UnmaskType<Record<"Authorization", CommonAuthorizationHeaders | undefined> | Record<"Content-Type", CommonContentTypes | undefined> | Record<CommonRequestHeaders, string | undefined> | Record<string, string | undefined> | Array<[string, string]>>;
 type InferHeadersOption<TSchema extends CallApiSchema> = MakeSchemaOptionRequired<TSchema["headers"], {
   /**
    * Headers to be used in the request.
@@ -693,14 +699,14 @@ type InferQueryOption<TSchema extends CallApiSchema> = MakeSchemaOptionRequired<
   query?: InferSchemaResult<TSchema["query"], Query>;
 }>;
 type EmptyString = "";
-type InferParamFromPath<TPath> = TPath extends `${infer IgnoredPrefix}:${infer TCurrentParam}/${infer TRemainingPath}` ? TCurrentParam extends EmptyString ? InferParamFromPath<TRemainingPath> : Prettify<Record<TCurrentParam | (Params extends InferParamFromPath<TRemainingPath> ? never : keyof Extract<InferParamFromPath<TRemainingPath>, Record<string, unknown>>), AllowedQueryParamValues>> | [AllowedQueryParamValues, ...(Params extends InferParamFromPath<TRemainingPath> ? [] : Extract<InferParamFromPath<TRemainingPath>, unknown[]>)] : TPath extends `${infer IgnoredPrefix}:${infer TCurrentParam}` ? TCurrentParam extends EmptyString ? Params : Prettify<Record<TCurrentParam, AllowedQueryParamValues>> | [AllowedQueryParamValues] : Params;
-type InferParamsOption<TPath, TSchema extends CallApiSchema> = MakeSchemaOptionRequired<TSchema["params"], {
+type InferParamFromRoute<TRoute> = TRoute extends `${infer IgnoredPrefix}:${infer TCurrentParam}/${infer TRemainingPath}` ? TCurrentParam extends EmptyString ? InferParamFromRoute<TRemainingPath> : Prettify<Record<TCurrentParam | (Params extends InferParamFromRoute<TRemainingPath> ? never : keyof Extract<InferParamFromRoute<TRemainingPath>, Record<string, unknown>>), AllowedQueryParamValues>> | [AllowedQueryParamValues, ...(Params extends InferParamFromRoute<TRemainingPath> ? [] : Extract<InferParamFromRoute<TRemainingPath>, unknown[]>)] : TRoute extends `${infer IgnoredPrefix}:${infer TCurrentParam}` ? TCurrentParam extends EmptyString ? Params : Prettify<Record<TCurrentParam, AllowedQueryParamValues>> | [AllowedQueryParamValues] : Params;
+type InferParamsOption<TSchema extends CallApiSchema, TCurrentRouteKey> = MakeSchemaOptionRequired<TSchema["params"], {
   /**
    * Parameters to be appended to the URL (i.e: /:id)
    */
-  params?: InferSchemaResult<TSchema["params"], InferParamFromPath<TPath>>;
+  params?: InferSchemaResult<TSchema["params"], InferParamFromRoute<TCurrentRouteKey>>;
 }>;
-type InferExtraOptions<TSchema extends CallApiSchema, TPath> = InferMetaOption<TSchema> & InferParamsOption<TPath, TSchema> & InferQueryOption<TSchema>;
+type InferExtraOptions<TSchema extends CallApiSchema, TCurrentRouteKey> = InferMetaOption<TSchema> & InferParamsOption<TSchema, TCurrentRouteKey> & InferQueryOption<TSchema>;
 type InferPluginOptions<TPluginArray extends CallApiPlugin[]> = UnionToIntersection<TPluginArray extends Array<infer TPlugin> ? TPlugin extends CallApiPlugin ? TPlugin["defineExtraOptions"] extends AnyFunction<infer TResult> ? InferSchemaResult<TResult> : never : never : never>;
 type ExtractKeys<TUnion, TSelectedUnion extends TUnion> = Extract<TUnion, TSelectedUnion>;
 type ResultModeOption<TErrorData, TResultMode extends ResultModeUnion> = TErrorData extends false ? {
@@ -714,11 +720,13 @@ type ResultModeOption<TErrorData, TResultMode extends ResultModeUnion> = TErrorD
 } : {
   resultMode: TResultMode;
 };
-type ThrowOnErrorOption<TErrorData> = TErrorData extends false ? {
+type ThrowOnErrorOption<TErrorData, TThrowOnError extends DefaultThrowOnError> = TErrorData extends false ? {
   throwOnError: true;
 } : TErrorData extends false | undefined ? {
   throwOnError?: true;
-} : NonNullable<unknown>;
+} : {
+  throwOnError?: TThrowOnError | ((context: ErrorContext<TErrorData>) => TThrowOnError);
+};
 //#endregion
 //#region src/types/common.d.ts
 type FetchSpecificKeysUnion = Exclude<(typeof fetchSpecificKeys)[number], "body" | "headers" | "method">;
@@ -741,14 +749,18 @@ type CallApiRequestOptions = Prettify<{
   method?: MethodUnion;
 } & Pick<ModifiedRequestInit, FetchSpecificKeysUnion>>;
 type CallApiRequestOptionsForHooks = Omit<CallApiRequestOptions, "headers"> & {
-  headers?: Record<string, string | undefined>;
+  headers: Record<string, string | undefined>;
 };
 type FetchImpl = UnmaskType<(input: string | Request | URL, init?: RequestInit) => Promise<Response>>;
-type SharedExtraOptions<TData = DefaultDataType, TErrorData = DefaultDataType, TResultMode extends ResultModeUnion = ResultModeUnion, TThrowOnError extends boolean = DefaultThrowOnError, TResponseType extends ResponseTypeUnion = ResponseTypeUnion, TPluginArray extends CallApiPlugin[] = DefaultPluginArray> = {
+type SharedExtraOptions<TResultMode extends ResultModeUnion = ResultModeUnion, TThrowOnError extends boolean = DefaultThrowOnError, TResponseType extends ResponseTypeUnion = ResponseTypeUnion> = DedupeOptions & URLOptions & {
   /**
    * Authorization header value.
    */
   auth?: string | Auth | null;
+  /**
+   * Base URL for the request.
+   */
+  baseURL?: string;
   /**
    * Custom function to serialize the body object into a string.
    */
@@ -832,14 +844,13 @@ type SharedExtraOptions<TData = DefaultDataType, TErrorData = DefaultDataType, T
    * The function is passed the error object and can be used to conditionally throw the error
    * @default false
    */
-  throwOnError?: TThrowOnError | ((context: ErrorContext<TErrorData>) => TThrowOnError);
+  throwOnError?: TThrowOnError;
   /**
    * Request timeout in milliseconds
    */
   timeout?: number;
-} & DedupeOptions & HooksOrHooksArray<TData, TErrorData, Partial<InferPluginOptions<TPluginArray>>> & Partial<InferPluginOptions<TPluginArray>> & RetryOptions<TErrorData> & ResultModeOption<TErrorData, TResultMode> & ThrowOnErrorOption<TErrorData> & UrlOptions;
-type BaseCallApiExtraOptions<TBaseData = DefaultDataType, TBaseErrorData = DefaultDataType, TBaseResultMode extends ResultModeUnion = ResultModeUnion, TBaseThrowOnError extends boolean = DefaultThrowOnError, TBaseResponseType extends ResponseTypeUnion = ResponseTypeUnion, TBasePluginArray extends CallApiPlugin[] = DefaultPluginArray, TBaseSchema extends BaseCallApiSchema = BaseCallApiSchema, TBaseSchemaConfig extends CallApiSchemaConfig = CallApiSchemaConfig> = SharedExtraOptions<TBaseData, TBaseErrorData, TBaseResultMode, TBaseThrowOnError, TBaseResponseType, TBasePluginArray> & {
-  baseURL?: string;
+};
+type BaseCallApiExtraOptions<TBaseData = DefaultDataType, TBaseErrorData = DefaultDataType, TBaseResultMode extends ResultModeUnion = ResultModeUnion, TBaseThrowOnError extends boolean = DefaultThrowOnError, TBaseResponseType extends ResponseTypeUnion = ResponseTypeUnion, TBasePluginArray extends CallApiPlugin[] = DefaultPluginArray, TBaseSchema extends BaseCallApiSchema = BaseCallApiSchema, TBaseSchemaConfig extends CallApiSchemaConfig = CallApiSchemaConfig> = SharedExtraOptions<TBaseResultMode, TBaseThrowOnError, TBaseResponseType> & {
   /**
    * An array of base callApi plugins. It allows you to extend the behavior of the library.
    */
@@ -873,8 +884,8 @@ type BaseCallApiExtraOptions<TBaseData = DefaultDataType, TBaseErrorData = Defau
    * ```
    */
   skipAutoMergeFor?: "all" | "options" | "request";
-};
-type CallApiExtraOptions<TData = DefaultDataType, TErrorData = DefaultDataType, TResultMode extends ResultModeUnion = ResultModeUnion, TThrowOnError extends boolean = DefaultThrowOnError, TResponseType extends ResponseTypeUnion = ResponseTypeUnion, TBasePluginArray extends CallApiPlugin[] = DefaultPluginArray, TPluginArray extends CallApiPlugin[] = DefaultPluginArray, TBaseSchema extends BaseCallApiSchema = BaseCallApiSchema, TSchema extends CallApiSchema = CallApiSchema, TBaseSchemaConfig extends CallApiSchemaConfig = CallApiSchemaConfig, TSchemaConfig extends CallApiSchemaConfig = CallApiSchemaConfig, TCurrentRouteKey extends string = string> = SharedExtraOptions<TData, TErrorData, TResultMode, TThrowOnError, TResponseType, TPluginArray> & {
+} & HooksOrHooksArray<TBaseData, TBaseErrorData, CallApiSchema, string, Partial<InferPluginOptions<TBasePluginArray>>> & Partial<InferPluginOptions<TBasePluginArray>> & ResultModeOption<TBaseErrorData, TBaseResultMode> & RetryOptions<TBaseErrorData> & ThrowOnErrorOption<TBaseErrorData, TBaseThrowOnError>;
+type CallApiExtraOptions<TData = DefaultDataType, TErrorData = DefaultDataType, TResultMode extends ResultModeUnion = ResultModeUnion, TThrowOnError extends boolean = DefaultThrowOnError, TResponseType extends ResponseTypeUnion = ResponseTypeUnion, TBasePluginArray extends CallApiPlugin[] = DefaultPluginArray, TPluginArray extends CallApiPlugin[] = DefaultPluginArray, TBaseSchema extends BaseCallApiSchema = BaseCallApiSchema, TSchema extends CallApiSchema = CallApiSchema, TBaseSchemaConfig extends CallApiSchemaConfig = CallApiSchemaConfig, TSchemaConfig extends CallApiSchemaConfig = CallApiSchemaConfig, TCurrentRouteKey extends string = string> = SharedExtraOptions<TResultMode, TThrowOnError, TResponseType> & {
   /**
    * An array of instance CallApi plugins. It allows you to extend the behavior of the library.
    */
@@ -894,7 +905,7 @@ type CallApiExtraOptions<TData = DefaultDataType, TErrorData = DefaultDataType,
   schemaConfig?: Writeable<TSchemaConfig, "deep"> | ((context: {
     baseSchemaConfig: NonNullable<Writeable<TBaseSchemaConfig, "deep">>;
   }) => Writeable<TSchemaConfig, "deep">);
-};
+} & HooksOrHooksArray<TData, TErrorData, CallApiSchema, TCurrentRouteKey, Partial<InferPluginOptions<TPluginArray>>> & Partial<InferPluginOptions<TPluginArray>> & ResultModeOption<TErrorData, TResultMode> & RetryOptions<TErrorData> & ThrowOnErrorOption<TErrorData, TThrowOnError>;
 interface CombinedCallApiExtraOptions extends Omit<CallApiExtraOptions, keyof Hooks>, Hooks {}
 type BaseCallApiConfig<TBaseData = DefaultDataType, TBaseErrorData = DefaultDataType, TBaseResultMode extends ResultModeUnion = ResultModeUnion, TBaseThrowOnError extends boolean = DefaultThrowOnError, TBaseResponseType extends ResponseTypeUnion = ResponseTypeUnion, TBaseSchema extends BaseCallApiSchema = BaseCallApiSchema, TBaseSchemaConfig extends CallApiSchemaConfig = CallApiSchemaConfig, TBasePluginArray extends CallApiPlugin[] = DefaultPluginArray> = (CallApiRequestOptions & BaseCallApiExtraOptions<TBaseData, TBaseErrorData, TBaseResultMode, TBaseThrowOnError, TBaseResponseType, TBasePluginArray, TBaseSchema, TBaseSchemaConfig>) | ((context: {
   initURL: string;
@@ -905,5 +916,5 @@ type CallApiConfig<TData = DefaultDataType, TErrorData = DefaultDataType, TResul
 type CallApiParameters<TData = DefaultDataType, TErrorData = DefaultDataType, TResultMode extends ResultModeUnion = ResultModeUnion, TThrowOnError extends boolean = DefaultThrowOnError, TResponseType extends ResponseTypeUnion = ResponseTypeUnion, TBaseSchema extends BaseCallApiSchema = BaseCallApiSchema, TSchema extends CallApiSchema = CallApiSchema, TBaseSchemaConfig extends CallApiSchemaConfig = CallApiSchemaConfig, TSchemaConfig extends CallApiSchemaConfig = CallApiSchemaConfig, TInitURL extends InferInitURL<BaseCallApiSchema, TSchemaConfig> = InferInitURL<BaseCallApiSchema, TSchemaConfig>, TCurrentRouteKey extends string = string, TBasePluginArray extends CallApiPlugin[] = DefaultPluginArray, TPluginArray extends CallApiPlugin[] = DefaultPluginArray> = [initURL: TInitURL, config?: CallApiConfig<TData, TErrorData, TResultMode, TThrowOnError, TResponseType, TBaseSchema, TSchema, TBaseSchemaConfig, TSchemaConfig, TInitURL, TCurrentRouteKey, TBasePluginArray, TPluginArray>];
 type CallApiResult<TData, TErrorData, TResultMode extends ResultModeUnion, TThrowOnError extends boolean, TResponseType extends ResponseTypeUnion> = Promise<GetCallApiResult<TData, TErrorData, TResultMode, TThrowOnError, TResponseType>>;
 //#endregion
-export { BaseCallApiConfig, BaseCallApiExtraOptions, BaseCallApiSchema, CallApiConfig, CallApiExtraOptions, CallApiParameters, CallApiPlugin, CallApiRequestOptions, CallApiRequestOptionsForHooks, CallApiResult, CallApiResultErrorVariant, CallApiResultSuccessVariant, CallApiSchema, CallApiSchemaConfig, CombinedCallApiExtraOptions, DefaultDataType, DefaultPluginArray, DefaultThrowOnError, ErrorContext, GetCurrentRouteKey, HTTPError, Hooks, HooksOrHooksArray, InferInitURL, InferParamFromPath, InferSchemaResult, PluginHooks, PluginHooksWithMoreOptions, PluginInitContext, PossibleHTTPError, PossibleJavaScriptError, PossibleValidationError, Register, RequestContext, RequestStreamContext, ResponseContext, ResponseErrorContext, ResponseStreamContext, ResponseTypeUnion, ResultModeUnion, RetryOptions, SuccessContext, ValidationError, definePlugin, defineSchema };
-//# sourceMappingURL=common-Cg-2dq0u.d.ts.map
+export { BaseCallApiConfig, BaseCallApiExtraOptions, BaseCallApiSchema, CallApiConfig, CallApiExtraOptions, CallApiParameters, CallApiPlugin, CallApiRequestOptions, CallApiRequestOptionsForHooks, CallApiResult, CallApiResultErrorVariant, CallApiResultSuccessVariant, CallApiSchema, CallApiSchemaConfig, CombinedCallApiExtraOptions, DedupeOptions, DefaultDataType, DefaultPluginArray, DefaultThrowOnError, ErrorContext, GetCurrentRouteKey, HTTPError, Hooks, HooksOrHooksArray, InferInitURL, InferParamFromRoute, InferSchemaResult, PluginHooks, PluginHooksWithMoreOptions, PluginInitContext, PossibleHTTPError, PossibleJavaScriptError, PossibleValidationError, Register, RequestContext, RequestStreamContext, ResponseContext, ResponseErrorContext, ResponseStreamContext, ResponseTypeUnion, ResultModeUnion, RetryOptions, SuccessContext, URLOptions, ValidationError, definePlugin, defineSchema };
+//# sourceMappingURL=common-BR-RZ84M.d.ts.map

package/dist/esm/index.d.ts

@@ -1,4 +1,4 @@
-import { BaseCallApiConfig, BaseCallApiExtraOptions, BaseCallApiSchema, CallApiConfig, CallApiExtraOptions, CallApiParameters, CallApiPlugin, CallApiRequestOptions, CallApiRequestOptionsForHooks, CallApiResult, CallApiResultErrorVariant, CallApiResultSuccessVariant, CallApiSchema, CallApiSchemaConfig, CombinedCallApiExtraOptions, DefaultDataType, DefaultPluginArray, DefaultThrowOnError, ErrorContext, GetCurrentRouteKey, HTTPError, Hooks, HooksOrHooksArray, InferInitURL, InferParamFromPath, InferSchemaResult, PluginHooks, PluginHooksWithMoreOptions, PluginInitContext, PossibleHTTPError, PossibleJavaScriptError, PossibleValidationError, Register, RequestContext, RequestStreamContext, ResponseContext, ResponseErrorContext, ResponseStreamContext, ResponseTypeUnion, ResultModeUnion, RetryOptions, SuccessContext, ValidationError, definePlugin, defineSchema } from "./common-Cg-2dq0u.js";
+import { BaseCallApiConfig, BaseCallApiExtraOptions, BaseCallApiSchema, CallApiConfig, CallApiExtraOptions, CallApiParameters, CallApiPlugin, CallApiRequestOptions, CallApiRequestOptionsForHooks, CallApiResult, CallApiResultErrorVariant, CallApiResultSuccessVariant, CallApiSchema, CallApiSchemaConfig, CombinedCallApiExtraOptions, DedupeOptions, DefaultDataType, DefaultPluginArray, DefaultThrowOnError, ErrorContext, GetCurrentRouteKey, HTTPError, Hooks, HooksOrHooksArray, InferInitURL, InferParamFromRoute, InferSchemaResult, PluginHooks, PluginHooksWithMoreOptions, PluginInitContext, PossibleHTTPError, PossibleJavaScriptError, PossibleValidationError, Register, RequestContext, RequestStreamContext, ResponseContext, ResponseErrorContext, ResponseStreamContext, ResponseTypeUnion, ResultModeUnion, RetryOptions, SuccessContext, URLOptions, ValidationError, definePlugin, defineSchema } from "./common-BR-RZ84M.js";
 
 //#region src/createFetchClient.d.ts
 
@@ -8,5 +8,5 @@ declare const callApi: <TData = unknown, TErrorData = unknown, TResultMode exten
 //#region src/defineParameters.d.ts
 declare const defineParameters: <TData = DefaultDataType, TErrorData = DefaultDataType, TResultMode extends ResultModeUnion = ResultModeUnion, TThrowOnError extends boolean = DefaultThrowOnError, TResponseType extends ResponseTypeUnion = ResponseTypeUnion, TBaseSchema extends BaseCallApiSchema = BaseCallApiSchema, TSchema extends CallApiSchema = CallApiSchema, TBaseSchemaConfig extends CallApiSchemaConfig = CallApiSchemaConfig, TSchemaConfig extends CallApiSchemaConfig = CallApiSchemaConfig, TInitURL extends InferInitURL<BaseCallApiSchema, TSchemaConfig> = InferInitURL<BaseCallApiSchema, TSchemaConfig>, TCurrentRouteKey extends string = string, TBasePluginArray extends CallApiPlugin[] = DefaultPluginArray, TPluginArray extends CallApiPlugin[] = DefaultPluginArray>(...parameters: CallApiParameters<TData, TErrorData, TResultMode, TThrowOnError, TResponseType, TBaseSchema, TSchema, TBaseSchemaConfig, TSchemaConfig, TInitURL, TCurrentRouteKey, TBasePluginArray, TPluginArray>) => CallApiParameters<TData, TErrorData, TResultMode, TThrowOnError, TResponseType, TBaseSchema, TSchema, TBaseSchemaConfig, TSchemaConfig, TInitURL, TCurrentRouteKey, TBasePluginArray, TPluginArray>;
 //#endregion
-export { BaseCallApiExtraOptions, BaseCallApiSchema, CallApiExtraOptions, CallApiParameters, CallApiPlugin, CallApiRequestOptions, CallApiRequestOptionsForHooks, CallApiResult, CallApiResultErrorVariant, CallApiResultSuccessVariant, CallApiSchema, CallApiSchemaConfig, CombinedCallApiExtraOptions, ErrorContext, HTTPError, Hooks, HooksOrHooksArray, InferParamFromPath, InferSchemaResult, PluginHooks, PluginHooksWithMoreOptions, PluginInitContext, PossibleHTTPError, PossibleJavaScriptError, PossibleValidationError, Register, RequestContext, RequestStreamContext, ResponseContext, ResponseErrorContext, ResponseStreamContext, ResponseTypeUnion, ResultModeUnion, RetryOptions, SuccessContext, ValidationError, callApi, createFetchClient, defineParameters, definePlugin, defineSchema };
+export { BaseCallApiConfig, BaseCallApiExtraOptions, BaseCallApiSchema, CallApiConfig, CallApiExtraOptions, CallApiParameters, CallApiPlugin, CallApiRequestOptions, CallApiRequestOptionsForHooks, CallApiResult, CallApiResultErrorVariant, CallApiResultSuccessVariant, CallApiSchema, CallApiSchemaConfig, CombinedCallApiExtraOptions, DedupeOptions, ErrorContext, HTTPError, Hooks, HooksOrHooksArray, InferParamFromRoute, InferSchemaResult, PluginHooks, PluginHooksWithMoreOptions, PluginInitContext, PossibleHTTPError, PossibleJavaScriptError, PossibleValidationError, Register, RequestContext, RequestStreamContext, ResponseContext, ResponseErrorContext, ResponseStreamContext, ResponseTypeUnion, ResultModeUnion, RetryOptions, SuccessContext, URLOptions, ValidationError, callApi, createFetchClient, defineParameters, definePlugin, defineSchema };
 //# sourceMappingURL=index.d.ts.map

package/dist/esm/index.js

@@ -1,4 +1,4 @@
-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-B6o_GJAn.js";
+import { HTTPError, ValidationError, commonDefaults, createCombinedSignal, createTimeoutSignal, dedupeDefaults, defineEnum, getBody, getFetchImpl, getHeaders, hookDefaults, isArray, isFunction, isHTTPError, isHTTPErrorInstance, isObject, isPlainObject, isReadableStream, isString, isValidationErrorInstance, requestOptionDefaults, responseDefaults, retryDefaults, splitBaseConfig, splitConfig, toQueryString, waitFor } from "./utils-BbmhntpS.js";
 
 //#region src/result.ts
 const getResponseType = (response, parser) => ({
@@ -248,7 +248,7 @@ 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 { $GlobalRequestInfoCache: $GlobalRequestInfoCache$1, $LocalRequestInfoCache, baseConfig, config, newFetchController, options: globalOptions, request: globalRequest } = context;
 	const dedupeStrategy = globalOptions.dedupeStrategy ?? dedupeDefaults.dedupeStrategy;
 	const generateDedupeKey = () => {
 		const shouldHaveDedupeKey = dedupeStrategy === "cancel" || dedupeStrategy === "defer";
@@ -259,6 +259,11 @@ const createDedupeStrategy = async (context) => {
 		})}`;
 	};
 	const dedupeKey = globalOptions.dedupeKey ?? generateDedupeKey();
+	const dedupeCacheScope = globalOptions.dedupeCacheScope ?? dedupeDefaults.dedupeCacheScope;
+	const $RequestInfoCache = {
+		global: $GlobalRequestInfoCache$1,
+		local: $LocalRequestInfoCache
+	}[dedupeCacheScope];
 	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.
@@ -274,24 +279,25 @@ const createDedupeStrategy = async (context) => {
 		prevRequestInfo.controller.abort(reason);
 		return Promise.resolve();
 	};
-	const handleRequestDeferStrategy = async (options, request) => {
-		const fetchApi = getFetchImpl(options.customFetchImpl);
+	const handleRequestDeferStrategy = async (deferContext) => {
+		const { options: localOptions, request: localRequest } = deferContext;
+		const fetchApi = getFetchImpl(localOptions.customFetchImpl);
 		const shouldUsePromiseFromCache = prevRequestInfo && dedupeStrategy === "defer";
-		const requestObjectForStream = isReadableStream(request.body) ? {
-			...request,
-			duplex: request.duplex ?? "half"
-		} : request;
-		const requestInstance = new Request(options.fullURL, requestObjectForStream);
+		const requestObjectForStream = isReadableStream(localRequest.body) ? {
+			...localRequest,
+			duplex: localRequest.duplex ?? "half"
+		} : localRequest;
+		const requestInstance = new Request(localOptions.fullURL, requestObjectForStream);
 		await toStreamableRequest({
 			baseConfig,
 			config,
-			options,
-			request,
+			options: localOptions,
+			request: localRequest,
 			requestInstance: requestInstance.clone()
 		});
 		const getFetchApiPromise = () => {
-			if (isReadableStream(request.body)) return fetchApi(requestInstance.clone());
-			return fetchApi(options.fullURL, request);
+			if (isReadableStream(localRequest.body)) return fetchApi(requestInstance.clone());
+			return fetchApi(localOptions.fullURL, localRequest);
 		};
 		const responsePromise = shouldUsePromiseFromCache ? prevRequestInfo.responsePromise : getFetchApiPromise();
 		$RequestInfoCacheOrNull?.set(dedupeKey, {
@@ -301,8 +307,8 @@ const createDedupeStrategy = async (context) => {
 		const streamableResponse = toStreamableResponse({
 			baseConfig,
 			config,
-			options,
-			request,
+			options: localOptions,
+			request: localRequest,
 			response: await responsePromise
 		});
 		return streamableResponse;
@@ -333,7 +339,7 @@ const initializePlugins = async (context) => {
 	const clonedHookRegistries = structuredClone(hookRegistries);
 	const addMainHooks = () => {
 		for (const key of Object.keys(clonedHookRegistries)) {
-			const baseHook = baseConfig[key];
+			const baseHook = baseConfig;
 			const instanceHook = config[key];
 			const overriddenHook = options[key];
 			const mainHook = isArray(baseHook) && Boolean(instanceHook) ? [baseHook, instanceHook].flat() : overriddenHook;
@@ -439,6 +445,105 @@ const createRetryStrategy = (ctx) => {
 	};
 };
 
+//#endregion
+//#region src/validation.ts
+const handleValidatorFunction = async (validator, inputData) => {
+	try {
+		const result = await validator(inputData);
+		return {
+			issues: void 0,
+			value: result
+		};
+	} catch (error) {
+		return {
+			issues: error,
+			value: void 0
+		};
+	}
+};
+const standardSchemaParser = async (schema, inputData, response) => {
+	const result = isFunction(schema) ? await handleValidatorFunction(schema, inputData) : await schema["~standard"].validate(inputData);
+	if (result.issues) throw new ValidationError({
+		issues: result.issues,
+		response: response ?? null
+	}, { cause: result.issues });
+	return result.value;
+};
+const routeKeyMethods = defineEnum([
+	"delete",
+	"get",
+	"patch",
+	"post",
+	"put"
+]);
+const defineSchema = (baseSchema) => {
+	return baseSchema;
+};
+const handleValidation = async (schema, validationOptions) => {
+	const { inputValue, response, schemaConfig } = validationOptions;
+	if (!schema || schemaConfig?.disableRuntimeValidation) return inputValue;
+	const validResult = await standardSchemaParser(schema, inputValue, response);
+	return validResult;
+};
+const extraOptionsToBeValidated = [
+	"meta",
+	"params",
+	"query"
+];
+const handleExtraOptionsValidation = async (validationOptions) => {
+	const { extraOptions, schema, schemaConfig } = validationOptions;
+	const validationResultArray = await Promise.all(extraOptionsToBeValidated.map((propertyKey) => handleValidation(schema?.[propertyKey], {
+		inputValue: extraOptions[propertyKey],
+		schemaConfig
+	})));
+	const validatedResultObject = {};
+	for (const [index, propertyKey] of extraOptionsToBeValidated.entries()) {
+		const validationResult = validationResultArray[index];
+		if (validationResult === void 0) continue;
+		validatedResultObject[propertyKey] = validationResult;
+	}
+	return validatedResultObject;
+};
+const requestOptionsToBeValidated = [
+	"body",
+	"headers",
+	"method"
+];
+const handleRequestOptionsValidation = async (validationOptions) => {
+	const { requestOptions, schema, schemaConfig } = validationOptions;
+	const validationResultArray = await Promise.all(requestOptionsToBeValidated.map((propertyKey) => handleValidation(schema?.[propertyKey], {
+		inputValue: requestOptions[propertyKey],
+		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 handleOptionsValidation = async (validationOptions) => {
+	const { extraOptions, requestOptions, schema, schemaConfig } = validationOptions;
+	if (schemaConfig?.disableRuntimeValidation) return {
+		extraOptionsValidationResult: null,
+		requestOptionsValidationResult: null
+	};
+	const [extraOptionsValidationResult, requestOptionsValidationResult] = await Promise.all([handleExtraOptionsValidation({
+		extraOptions,
+		schema,
+		schemaConfig
+	}), handleRequestOptionsValidation({
+		requestOptions,
+		schema,
+		schemaConfig
+	})]);
+	return {
+		extraOptionsValidationResult,
+		requestOptionsValidationResult
+	};
+};
+
 //#endregion
 //#region src/url.ts
 const slash = "/";
@@ -507,8 +612,9 @@ const getFullURL = (options) => {
 
 //#endregion
 //#region src/createFetchClient.ts
+const $GlobalRequestInfoCache = /* @__PURE__ */ new Map();
 const createFetchClient = (initBaseConfig = {}) => {
-	const $RequestInfoCache = /* @__PURE__ */ new Map();
+	const $LocalRequestInfoCache = /* @__PURE__ */ new Map();
 	const callApi$1 = async (...parameters) => {
 		const [initURLOrURLObject, initConfig = {}] = parameters;
 		const [fetchOptions, extraOptions] = splitConfig(initConfig);
@@ -560,10 +666,12 @@ const createFetchClient = (initBaseConfig = {}) => {
 		const combinedSignal = createCombinedSignal(resolvedRequestOptions.signal, timeoutSignal, newFetchController.signal);
 		let request = {
 			...resolvedRequestOptions,
+			headers: resolvedRequestOptions.headers ?? {},
 			signal: combinedSignal
 		};
 		const { dedupeStrategy, handleRequestCancelStrategy, handleRequestDeferStrategy, removeDedupeKeyFromCache } = await createDedupeStrategy({
-			$RequestInfoCache,
+			$GlobalRequestInfoCache,
+			$LocalRequestInfoCache,
 			baseConfig,
 			config,
 			newFetchController,
@@ -589,15 +697,16 @@ const createFetchClient = (initBaseConfig = {}) => {
 				...options,
 				...extraOptionsValidationResult
 			};
+			const rawBody = shouldApplySchemaOutput ? requestOptionsValidationResult?.body : request.body;
 			const validBody = getBody({
-				body: shouldApplySchemaOutput ? requestOptionsValidationResult?.body : request.body,
+				body: rawBody,
 				bodySerializer: options.bodySerializer
 			});
+			const resolvedHeaders = isFunction(fetchOptions.headers) ? fetchOptions.headers({ baseHeaders: baseFetchOptions.headers ?? {} }) : fetchOptions.headers ?? baseFetchOptions.headers;
 			const validHeaders = await getHeaders({
 				auth: options.auth,
-				baseHeaders: request.headers,
-				body: request.body,
-				headers: shouldApplySchemaOutput ? requestOptionsValidationResult?.headers : request.headers
+				body: rawBody,
+				headers: shouldApplySchemaOutput ? requestOptionsValidationResult?.headers : resolvedHeaders
 			});
 			const validMethod = getMethod({
 				initURL: resolvedInitURL,
@@ -610,7 +719,10 @@ const createFetchClient = (initBaseConfig = {}) => {
 				...Boolean(validHeaders) && { headers: validHeaders },
 				...Boolean(validMethod) && { method: validMethod }
 			};
-			const response = await handleRequestDeferStrategy(options, request);
+			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);