@zayne-labs/callapi-plugins 4.0.26 → 4.0.27

package/dist/index.d.ts

@@ -10,7 +10,7 @@ declare const fallBackRouteSchemaKey = "@default";
 type FallBackRouteSchemaKey = typeof fallBackRouteSchemaKey;
 //#endregion
 //#endregion
-//#region ../callapi/dist/validation-BeCBQ6_6.d.ts
+//#region ../callapi/dist/index-HHFgKKcn.d.ts
 //#region src/types/type-helpers.d.ts
 type AnyString = string & NonNullable<unknown>;
 type AnyNumber = number & NonNullable<unknown>;
@@ -75,231 +75,221 @@ type CustomAuth = {
 };
 type Auth = PossibleAuthValueOrGetter | BearerOrTokenAuth | BasicAuth | CustomAuth;
 //#endregion
-//#region src/utils/external/body.d.ts
-
-//#endregion
-//#region src/types/default-types.d.ts
-type DefaultDataType = unknown;
-type DefaultPluginArray = CallApiPlugin[];
-type DefaultThrowOnError = boolean;
-//#endregion
-//#region src/types/standard-schema.d.ts
-/**
- * The Standard Schema interface.
- * @see https://github.com/standard-schema/standard-schema
- */
-interface StandardSchemaV1<Input$1 = unknown, Output$1 = Input$1> {
-  /**
-   * The Standard Schema properties.
-   */
-  readonly "~standard": StandardSchemaV1.Props<Input$1, Output$1>;
-}
-declare namespace StandardSchemaV1 {
-  /**
-   * The Standard Schema properties interface.
-   */
-  interface Props<Input = unknown, Output = Input> {
-    /**
-     * Inferred types associated with the schema.
-     */
-    readonly types?: Types<Input, Output> | undefined;
-    /**
-     * Validates unknown input values.
-     */
-    readonly validate: (value: unknown) => Promise<Result<Output>> | Result<Output>;
-    /**
-     * The vendor name of the schema library.
-     */
-    readonly vendor: string;
-    /**
-     * The version number of the standard.
-     */
-    readonly version: 1;
-  }
-  /**
-   * The result interface of the validate function.
-   */
-  type Result<Output> = FailureResult | SuccessResult<Output>;
-  /**
-   * The result interface if validation succeeds.
-   */
-  interface SuccessResult<Output> {
-    /**
-     * The non-existent issues.
-     */
-    readonly issues?: undefined;
-    /**
-     * The typed output value.
-     */
-    readonly value: Output;
-  }
-  /**
-   * The result interface if validation fails.
-   */
-  interface FailureResult {
-    /**
-     * The issues of failed validation.
-     */
-    readonly issues: readonly Issue[];
-  }
-  /**
-   * The issue interface of the failure output.
-   */
-  interface Issue {
-    /**
-     * The error message of the issue.
-     */
-    readonly message: string;
-    /**
-     * The path of the issue, if any.
-     */
-    readonly path?: ReadonlyArray<PathSegment | PropertyKey> | undefined;
-  }
-  /**
-   * The path segment interface of the issue.
-   */
-  interface PathSegment {
-    /**
-     * The key representing a path segment.
-     */
-    readonly key: PropertyKey;
-  }
-  /**
-   * The Standard Schema types interface.
-   */
-  interface Types<Input = unknown, Output = Input> {
-    /** The input type of the schema. */
-    readonly input: Input;
-    /** The output type of the schema. */
-    readonly output: Output;
-  }
-  /**
-   * Infers the input type of a Standard Schema.
-   */
-  type InferInput<Schema extends StandardSchemaV1> = NonNullable<Schema["~standard"]["types"]>["input"];
-  /**
-   * Infers the output type of a Standard Schema.
-   */
-  type InferOutput<Schema extends StandardSchemaV1> = NonNullable<Schema["~standard"]["types"]>["output"];
-}
-//#endregion
-//#region src/utils/external/error.d.ts
-type HTTPErrorDetails<TErrorData$1> = Pick<CallApiExtraOptions, "defaultHTTPErrorMessage"> & {
-  errorData: TErrorData$1;
-  response: Response;
-};
-declare class HTTPError<TErrorData$1 = Record<string, unknown>> extends Error {
-  errorData: HTTPErrorDetails<TErrorData$1>["errorData"];
-  readonly httpErrorSymbol: symbol;
-  name: "HTTPError";
-  response: HTTPErrorDetails<TErrorData$1>["response"];
-  constructor(errorDetails: HTTPErrorDetails<TErrorData$1>, errorOptions?: ErrorOptions);
+//#region src/dedupe.d.ts
+type DedupeStrategyUnion = UnmaskType<"cancel" | "defer" | "none">;
+type DedupeOptionKeys = Exclude<keyof DedupeOptions, "dedupe">;
+type InnerDedupeOptions = { [Key in DedupeOptionKeys as RemovePrefix<"dedupe", Key>]?: DedupeOptions[Key] };
+type DedupeOptions = {
   /**
-   * @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
+   * All dedupe options in a single object instead of separate properties
    */
-  static isError<TErrorData>(error: unknown): error is HTTPError<TErrorData$1>;
-}
-type SafeExtract<TUnion, TKey extends TUnion> = Extract<TUnion, TKey>;
-type ValidationErrorDetails = {
+  dedupe?: InnerDedupeOptions;
   /**
-   * The cause of the validation error.
+   * Controls the scope of request deduplication caching.
    *
-   * It's either the name the schema for which validation failed, or the name of the schema config option that led to the validation error.
+   * - `"global"`: Shares deduplication cache across all `createFetchClient` instances with the same `dedupeCacheScopeKey`.
+   *   Useful for applications with multiple API clients that should share deduplication state.
+   * - `"local"`: Limits deduplication to requests within the same `createFetchClient` instance.
+   *   Provides better isolation and is recommended for most use cases.
+   *
+   *
+   * **Real-world Scenarios:**
+   * - Use `"global"` when you have multiple API clients (user service, auth service, etc.) that might make overlapping requests
+   * - Use `"local"` (default) for single-purpose clients or when you want strict isolation between different parts of your app
+   *
+   * @example
+   * ```ts
+   * // Local scope - each client has its own deduplication cache
+   * const userClient = createFetchClient({ baseURL: "/api/users" });
+   * const postClient = createFetchClient({ baseURL: "/api/posts" });
+   * // These clients won't share deduplication state
+   *
+   * // Global scope - share cache across related clients
+   * const userClient = createFetchClient({
+   *   baseURL: "/api/users",
+   *   dedupeCacheScope: "global",
+   * });
+   * const postClient = createFetchClient({
+   *   baseURL: "/api/posts",
+   *   dedupeCacheScope: "global",
+   * });
+   * // These clients will share deduplication state
+   * ```
+   *
+   * @default "local"
    */
-  issueCause: "unknown" | `schemaConfig-(${SafeExtract<keyof CallApiSchemaConfig, "strict">})` | keyof CallApiSchema;
+  dedupeCacheScope?: "global" | "local";
   /**
-   * The issues that caused the validation error.
+   * Unique namespace for the global deduplication cache when using `dedupeCacheScope: "global"`.
+   *
+   * This creates logical groupings of deduplication caches. All instances with the same key
+   * will share the same cache namespace, allowing fine-grained control over which clients
+   * share deduplication state.
+   *
+   * **Best Practices:**
+   * - Use descriptive names that reflect the logical grouping (e.g., "user-service", "analytics-api")
+   * - Keep scope keys consistent across related API clients
+   * - Consider using different scope keys for different environments (dev, staging, prod)
+   * - Avoid overly broad scope keys that might cause unintended cache sharing
+   *
+   * **Cache Management:**
+   * - Each scope key maintains its own independent cache
+   * - Caches are automatically cleaned up when no references remain
+   * - Consider the memory implications of multiple global scopes
+   *
+   * @example
+   * ```ts
+   * // Group related API clients together
+   * const userClient = createFetchClient({
+   *   baseURL: "/api/users",
+   *   dedupeCacheScope: "global",
+   *   dedupeCacheScopeKey: "user-service"
+   * });
+   * const profileClient = createFetchClient({
+   *   baseURL: "/api/profiles",
+   *   dedupeCacheScope: "global",
+   *   dedupeCacheScopeKey: "user-service" // Same scope - will share cache
+   * });
+   *
+   * // Separate analytics client with its own cache
+   * const analyticsClient = createFetchClient({
+   *   baseURL: "/api/analytics",
+   *   dedupeCacheScope: "global",
+   *   dedupeCacheScopeKey: "analytics-service" // Different scope
+   * });
+   *
+   * // Environment-specific scoping
+   * const apiClient = createFetchClient({
+   *   dedupeCacheScope: "global",
+   *   dedupeCacheScopeKey: `api-${process.env.NODE_ENV}` // "api-development", "api-production", etc.
+   * });
+   * ```
+   *
+   * @default "default"
    */
-  issues: readonly StandardSchemaV1.Issue[];
+  dedupeCacheScopeKey?: "default" | AnyString | ((context: RequestContext) => string | undefined);
   /**
-   * The response from server, if any.
+   * Custom key generator for request deduplication.
+   *
+   * Override the default key generation strategy to control exactly which requests
+   * are considered duplicates. The default key combines URL, method, body, and
+   * relevant headers (excluding volatile ones like 'Date', 'Authorization', etc.).
+   *
+   * **Default Key Generation:**
+   * The auto-generated key includes:
+   * - Full request URL (including query parameters)
+   * - HTTP method (GET, POST, etc.)
+   * - Request body (for POST/PUT/PATCH requests)
+   * - Stable headers (excludes Date, Authorization, User-Agent, etc.)
+   *
+   * **Custom Key Best Practices:**
+   * - Include only the parts of the request that should affect deduplication
+   * - Avoid including volatile data (timestamps, random IDs, etc.)
+   * - Consider performance - simpler keys are faster to compute and compare
+   * - Ensure keys are deterministic for the same logical request
+   * - Use consistent key formats across your application
+   *
+   * **Performance Considerations:**
+   * - Function-based keys are computed on every request - keep them lightweight
+   * - String keys are fastest but least flexible
+   * - Consider caching expensive key computations if needed
+   *
+   * @example
+   * ```ts
+   * import { callApi } from "@zayne-labs/callapi";
+   *
+   * // Simple static key - useful for singleton requests
+   * const config = callApi("/api/config", {
+   *   dedupeKey: "app-config",
+   *   dedupeStrategy: "defer" // Share the same config across all requests
+   * });
+   *
+   * // URL and method only - ignore headers and body
+   * const userData = callApi("/api/user/123", {
+   *   dedupeKey: (context) => `${context.options.method}:${context.options.fullURL}`
+   * });
+   *
+   * // Include specific headers in deduplication
+   * const apiCall = callApi("/api/data", {
+   *   dedupeKey: (context) => {
+   *     const authHeader = context.request.headers.get("Authorization");
+   *     return `${context.options.fullURL}-${authHeader}`;
+   *   }
+   * });
+   *
+   * // User-specific deduplication
+   * const userSpecificCall = callApi("/api/dashboard", {
+   *   dedupeKey: (context) => {
+   *     const userId = context.options.fullURL.match(/user\/(\d+)/)?.[1];
+   *     return `dashboard-${userId}`;
+   *   }
+   * });
+   *
+   * // Ignore certain query parameters
+   * const searchCall = callApi("/api/search?q=test&timestamp=123456", {
+   *   dedupeKey: (context) => {
+   *     const url = new URL(context.options.fullURL);
+   *     url.searchParams.delete("timestamp"); // Remove volatile param
+   *     return `search:${url.toString()}`;
+   *   }
+   * });
+   * ```
+   *
+   * @default Auto-generated from request details
    */
-  response: Response | null;
-};
-declare class ValidationError extends Error {
-  errorData: ValidationErrorDetails["issues"];
-  issueCause: ValidationErrorDetails["issueCause"];
-  name: "ValidationError";
-  response: ValidationErrorDetails["response"];
-  readonly validationErrorSymbol: symbol;
-  constructor(details: ValidationErrorDetails, errorOptions?: ErrorOptions);
+  dedupeKey?: string | ((context: RequestContext) => string | undefined);
   /**
-   * @description Checks if the given error is an instance of ValidationError
-   * @param error - The error to check
-   * @returns true if the error is an instance of ValidationError, false otherwise
-   */
-  static isError(error: unknown): error is ValidationError;
-}
-//#endregion
-//#region src/result.d.ts
-type Parser<TData$1> = (responseString: string) => Awaitable<TData$1>;
-declare const getResponseType: <TResponse>(response: Response, parser: Parser<TResponse>) => {
-  arrayBuffer: () => Promise<ArrayBuffer>;
-  blob: () => Promise<Blob>;
-  formData: () => Promise<FormData>;
-  json: () => Promise<TResponse>;
-  stream: () => ReadableStream<Uint8Array<ArrayBuffer>> | null;
-  text: () => Promise<string>;
-};
-type InitResponseTypeMap<TResponse$1 = unknown> = ReturnType<typeof getResponseType<TResponse$1>>;
-type ResponseTypeUnion = keyof InitResponseTypeMap;
-type ResponseTypePlaceholder = null;
-type ResponseTypeType = ResponseTypePlaceholder | ResponseTypeUnion;
-type ResponseTypeMap<TResponse$1> = { [Key in keyof InitResponseTypeMap<TResponse$1>]: Awaited<ReturnType<InitResponseTypeMap<TResponse$1>[Key]>> };
-type GetResponseType<TResponse$1, TResponseType extends ResponseTypeType, TComputedResponseTypeMap extends ResponseTypeMap<TResponse$1> = ResponseTypeMap<TResponse$1>> = null extends TResponseType ? TComputedResponseTypeMap["json"] : TResponseType extends NonNullable<ResponseTypeType> ? TComputedResponseTypeMap[TResponseType] : never;
-type CallApiResultSuccessVariant<TData$1> = {
-  data: NoInfer<TData$1>;
-  error: null;
-  response: Response;
-};
-type PossibleJavaScriptError = UnmaskType<{
-  errorData: false;
-  message: string;
-  name: "AbortError" | "Error" | "SyntaxError" | "TimeoutError" | "TypeError" | AnyString;
-  originalError: DOMException | Error | SyntaxError | TypeError;
-}>;
-type PossibleHTTPError<TErrorData$1> = UnmaskType<{
-  errorData: NoInfer<TErrorData$1>;
-  message: string;
-  name: "HTTPError";
-  originalError: HTTPError;
-}>;
-type PossibleValidationError = UnmaskType<{
-  errorData: ValidationError["errorData"];
-  issueCause: ValidationError["issueCause"];
-  message: string;
-  name: "ValidationError";
-  originalError: ValidationError;
-}>;
-type PossibleJavaScriptOrValidationError = UnmaskType<PossibleJavaScriptError | PossibleValidationError>;
-type CallApiResultErrorVariant<TErrorData$1> = {
-  data: null;
-  error: PossibleHTTPError<TErrorData$1>;
-  response: Response;
-} | {
-  data: null;
-  error: PossibleJavaScriptOrValidationError;
-  response: Response | null;
-};
-type CallApiSuccessOrErrorVariant<TData$1, TError> = CallApiResultErrorVariant<TError> | CallApiResultSuccessVariant<TData$1>;
-type ResultModeMapWithoutException<TData$1, TErrorData$1, TResponseType extends ResponseTypeType, TComputedData = GetResponseType<TData$1, TResponseType>, TComputedErrorData = GetResponseType<TErrorData$1, TResponseType>, TComputedResult extends CallApiSuccessOrErrorVariant<TComputedData, TComputedErrorData> = CallApiSuccessOrErrorVariant<TComputedData, TComputedErrorData>> = UnmaskType<{
-  all: TComputedResult;
-  onlyData: TComputedResult["data"];
-  onlyResponse: TComputedResult["response"];
-  withoutResponse: DistributiveOmit<TComputedResult, "response">;
-}>;
-type ResultModeMapWithException<TData$1, TResponseType extends ResponseTypeType, TComputedData = GetResponseType<TData$1, TResponseType>, TComputedResult extends CallApiResultSuccessVariant<TComputedData> = CallApiResultSuccessVariant<TComputedData>> = {
-  all: TComputedResult;
-  onlyData: TComputedResult["data"];
-  onlyResponse: TComputedResult["response"];
-  withoutResponse: DistributiveOmit<TComputedResult, "response">;
+   * Strategy for handling duplicate requests. Can be a static string or callback function.
+   *
+   * **Available Strategies:**
+   * - `"cancel"`: Cancel previous request when new one starts (good for search)
+   * - `"defer"`: Share response between duplicate requests (good for config loading)
+   * - `"none"`: No deduplication, all requests execute independently
+   *
+   * @example
+   * ```ts
+   * // Static strategies
+   * const searchClient = createFetchClient({
+   *   dedupeStrategy: "cancel" // Cancel previous searches
+   * });
+   *
+   * const configClient = createFetchClient({
+   *   dedupeStrategy: "defer" // Share config across components
+   * });
+   *
+   * // Dynamic strategy based on request
+   * const smartClient = createFetchClient({
+   *   dedupeStrategy: (context) => {
+   *     return context.options.method === "GET" ? "defer" : "cancel";
+   *   }
+   * });
+   *
+   * // Search-as-you-type with cancel strategy
+   * const handleSearch = async (query: string) => {
+   *   try {
+   *     const { data } = await callApi("/api/search", {
+   *       method: "POST",
+   *       body: { query },
+   *       dedupeStrategy: "cancel",
+   *       dedupeKey: "search" // Cancel previous searches, only latest one goes through
+   *     });
+   *
+   *     updateSearchResults(data);
+   *   } catch (error) {
+   *     if (error.name === "AbortError") {
+   *       // Previous search cancelled - (expected behavior)
+   *       return;
+   *     }
+   *     console.error("Search failed:", error);
+   *   }
+   * };
+   *
+   * ```
+   *
+   * @default "cancel"
+   */
+  dedupeStrategy?: DedupeStrategyUnion | ((context: RequestContext) => DedupeStrategyUnion);
 };
-type ResultModeMap<TData$1 = DefaultDataType, TErrorData$1 = DefaultDataType, TResponseType extends ResponseTypeType = ResponseTypeType, TThrowOnError extends ThrowOnErrorUnion = DefaultThrowOnError> = TThrowOnError extends true ? ResultModeMapWithException<TData$1, TResponseType> : ResultModeMapWithoutException<TData$1, TErrorData$1, TResponseType>;
-type ResultModePlaceholder = null;
-type ResultModeUnion = keyof ResultModeMap;
-type ResultModeType = ResultModePlaceholder | ResultModeUnion;
 //#endregion
 //#region src/middlewares.d.ts
 type FetchImpl = UnmaskType<(input: string | Request | URL, init?: RequestInit) => Promise<Response>>;
@@ -460,563 +450,333 @@ interface URLOptions {
   query?: Query;
 }
 //#endregion
-//#region src/plugins.d.ts
-type PluginSetupContext<TPluginExtraOptions = unknown> = PluginExtraOptions<TPluginExtraOptions> & RequestContext & {
-  initURL: string;
-};
-type PluginInitResult = Partial<Omit<PluginSetupContext, "initURL" | "request"> & {
-  initURL: InitURLOrURLObject;
-  request: CallApiRequestOptions;
-}>;
-type PluginHooks<TData$1 = never, TErrorData$1 = never, TMoreOptions = unknown> = HooksOrHooksArray<TData$1, TErrorData$1, TMoreOptions>;
-interface CallApiPlugin {
-  /**
-   * Defines additional options that can be passed to callApi
-   */
-  defineExtraOptions?: (...params: never[]) => unknown;
-  /**
-   * A description for the plugin
-   */
-  description?: string;
-  /**
-   * Hooks for the plugin
-   */
-  hooks?: PluginHooks | ((context: PluginSetupContext) => Awaitable<PluginHooks>);
-  /**
-   *  A unique id for the plugin
-   */
-  id: string;
-  /**
-   * Middlewares that for the plugin
-   */
-  middlewares?: Middlewares | ((context: PluginSetupContext) => Awaitable<Middlewares>);
-  /**
-   * A name for the plugin
-   */
-  name: string;
-  /**
-   * Base schema for the client.
-   */
-  schema?: BaseCallApiSchemaAndConfig;
-  /**
-   * A function that will be called when the plugin is initialized. This will be called before the any of the other internal functions.
-   */
-  setup?: (context: PluginSetupContext) => Awaitable<PluginInitResult> | Awaitable<void>;
-  /**
-   *  A version for the plugin
-   */
-  version?: string;
-}
-//#endregion
-//#region src/utils/external/define.d.ts
-
-//#endregion
-//#region src/stream.d.ts
-type StreamProgressEvent = {
-  /**
-   * Current chunk of data being streamed
-   */
-  chunk: Uint8Array;
-  /**
-   * Progress in percentage
-   */
-  progress: number;
-  /**
-   * Total size of data in bytes
-   */
-  totalBytes: number;
-  /**
-   * Amount of data transferred so far
-   */
-  transferredBytes: number;
-};
-declare global {
-  interface ReadableStream<R> {
-    [Symbol.asyncIterator]: () => AsyncIterableIterator<R>;
-  }
-}
-//#endregion
-//#region src/hooks.d.ts
-type PluginExtraOptions<TPluginOptions = unknown> = {
-  /** Plugin-specific options passed to the plugin configuration */
-  options: Partial<TPluginOptions>;
-};
-interface Hooks<TData$1 = DefaultDataType, TErrorData$1 = DefaultDataType, TPluginOptions = unknown> {
-  /**
-   * Hook called when any error occurs within the request/response lifecycle.
-   *
-   * This is a unified error handler that catches both request errors (network failures,
-   * timeouts, etc.) and response errors (HTTP error status codes). It's essentially
-   * a combination of `onRequestError` and `onResponseError` hooks.
-   *
-   * @param context - Error context containing error details, request info, and response (if available)
-   * @returns Promise or void - Hook can be async or sync
-   */
-  onError?: (context: ErrorContext<TErrorData$1> & PluginExtraOptions<TPluginOptions>) => Awaitable<unknown>;
-  /**
-   * Hook called before the HTTP request is sent and before any internal processing of the request object begins.
-   *
-   * This is the ideal place to modify request headers, add authentication,
-   * implement request logging, or perform any setup before the network call.
-   *
-   * @param context - Request context with mutable request object and configuration
-   * @returns Promise or void - Hook can be async or sync
-   *
-   */
-  onRequest?: (context: RequestContext & PluginExtraOptions<TPluginOptions>) => Awaitable<unknown>;
-  /**
-   * Hook called when an error occurs during the fetch request itself.
-   *
-   * This handles network-level errors like connection failures, timeouts,
-   * DNS resolution errors, or other issues that prevent getting an HTTP response.
-   * Note that HTTP error status codes (4xx, 5xx) are handled by `onResponseError`.
-   *
-   * @param context - Request error context with error details and null response
-   * @returns Promise or void - Hook can be async or sync
-   */
-  onRequestError?: (context: RequestErrorContext & PluginExtraOptions<TPluginOptions>) => Awaitable<unknown>;
-  /**
-   * Hook called just before the HTTP request is sent and after the request has been processed.
-   *
-   * @param context - Request context with mutable request object and configuration
-   */
-  onRequestReady?: (context: RequestContext & PluginExtraOptions<TPluginOptions>) => Awaitable<unknown>;
+//#region src/types/conditional-types.d.ts
+/**
+ * @description Makes a type partial if the output type of TSchema is not provided or has undefined in the union, otherwise makes it required
+ */
+type MakeSchemaOptionRequiredIfDefined<TSchemaOption extends CallApiSchema[keyof CallApiSchema], TObject> = undefined extends InferSchemaOutput<TSchemaOption, undefined> ? TObject : Required<TObject>;
+type ApplyURLBasedConfig<TSchemaConfig$1 extends CallApiSchemaConfig, TSchemaRouteKeys extends string> = TSchemaConfig$1["prefix"] extends string ? `${TSchemaConfig$1["prefix"]}${TSchemaRouteKeys}` : TSchemaConfig$1["baseURL"] extends string ? `${TSchemaConfig$1["baseURL"]}${TSchemaRouteKeys}` : TSchemaRouteKeys;
+type ApplyStrictConfig<TSchemaConfig$1 extends CallApiSchemaConfig, TSchemaRouteKeys extends string> = TSchemaConfig$1["strict"] extends true ? TSchemaRouteKeys :
+// eslint-disable-next-line perfectionist/sort-union-types -- Don't sort union types
+TSchemaRouteKeys | Exclude<InitURLOrURLObject, RouteKeyMethodsURLUnion>;
+type ApplySchemaConfiguration<TSchemaConfig$1 extends CallApiSchemaConfig, TSchemaRouteKeys extends string> = ApplyStrictConfig<TSchemaConfig$1, ApplyURLBasedConfig<TSchemaConfig$1, TSchemaRouteKeys>>;
+type InferAllRouteKeys<TBaseSchemaRoutes$1 extends BaseCallApiSchemaRoutes, TSchemaConfig$1 extends CallApiSchemaConfig> = ApplySchemaConfiguration<TSchemaConfig$1, Exclude<Extract<keyof TBaseSchemaRoutes$1, string>, FallBackRouteSchemaKey>>;
+type InferInitURL<TBaseSchemaRoutes$1 extends BaseCallApiSchemaRoutes, TSchemaConfig$1 extends CallApiSchemaConfig> = keyof TBaseSchemaRoutes$1 extends never ? InitURLOrURLObject : InferAllRouteKeys<TBaseSchemaRoutes$1, TSchemaConfig$1>;
+type GetCurrentRouteSchema<TBaseSchemaRoutes$1 extends BaseCallApiSchemaRoutes, TCurrentRouteSchemaKey$1 extends string, TComputedFallBackRouteSchema = TBaseSchemaRoutes$1[FallBackRouteSchemaKey], TComputedCurrentRouteSchema = TBaseSchemaRoutes$1[TCurrentRouteSchemaKey$1], TComputedRouteSchema extends CallApiSchema = NonNullable<Omit<TComputedFallBackRouteSchema, keyof TComputedCurrentRouteSchema> & TComputedCurrentRouteSchema>> = TComputedRouteSchema extends CallApiSchema ? Writeable<TComputedRouteSchema, "deep"> : CallApiSchema;
+type JsonPrimitive = boolean | number | string | null | undefined;
+type SerializableObject = Record<PropertyKey, unknown>;
+type SerializableArray = Array<JsonPrimitive | SerializableObject> | ReadonlyArray<JsonPrimitive | SerializableObject>;
+type Body = UnmaskType<Exclude<RequestInit["body"], undefined> | SerializableArray | SerializableObject>;
+type InferBodyOption<TSchema$1 extends CallApiSchema> = MakeSchemaOptionRequiredIfDefined<TSchema$1["body"], {
   /**
-   * Hook called during upload stream progress tracking.
-   *
-   * This hook is triggered when uploading data (like file uploads) and provides
-   * progress information about the upload. Useful for implementing progress bars
-   * or upload status indicators.
-   *
-   * @param context - Request stream context with progress event and request instance
-   * @returns Promise or void - Hook can be async or sync
-   *
+   * Body of the request, can be a object or any other supported body type.
    */
-  onRequestStream?: (context: RequestStreamContext & PluginExtraOptions<TPluginOptions>) => Awaitable<unknown>;
+  body?: InferSchemaOutput<TSchema$1["body"], Body>;
+}>;
+type MethodUnion = UnmaskType<"CONNECT" | "DELETE" | "GET" | "HEAD" | "OPTIONS" | "PATCH" | "POST" | "PUT" | "TRACE" | AnyString>;
+type InferMethodFromURL<TInitURL$1> = string extends TInitURL$1 ? MethodUnion : TInitURL$1 extends `@${infer TMethod extends RouteKeyMethods}/${string}` ? Uppercase<TMethod> : MethodUnion;
+type InferMethodOption<TSchema$1 extends CallApiSchema, TInitURL$1> = MakeSchemaOptionRequiredIfDefined<TSchema$1["method"], {
   /**
-   * Hook called when any HTTP response is received from the API.
-   *
-   * This hook is triggered for both successful (2xx) and error (4xx, 5xx) responses.
-   * It's useful for response logging, metrics collection, or any processing that
-   * should happen regardless of response status.
-   *
-   * @param context - Response context with either success data or error information
-   * @returns Promise or void - Hook can be async or sync
-   *
+   * HTTP method for the request.
+   * @default "GET"
    */
-  onResponse?: (context: ResponseContext<TData$1, TErrorData$1> & PluginExtraOptions<TPluginOptions>) => Awaitable<unknown>;
+  method?: InferSchemaOutput<TSchema$1["method"], InferMethodFromURL<TInitURL$1>>;
+}>;
+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$1 extends CallApiSchema> = MakeSchemaOptionRequiredIfDefined<TSchema$1["headers"], {
   /**
-   * Hook called when an HTTP error response (4xx, 5xx) is received from the API.
-   *
-   * This handles server-side errors where an HTTP response was successfully received
-   * but indicates an error condition. Different from `onRequestError` which handles
-   * network-level failures.
-   *
-   * @param context - Response error context with HTTP error details and response
-   * @returns Promise or void - Hook can be async or sync
+   * Headers to be used in the request.
    */
-  onResponseError?: (context: ResponseErrorContext<TErrorData$1> & PluginExtraOptions<TPluginOptions>) => Awaitable<unknown>;
+  headers?: InferSchemaOutput<TSchema$1["headers"], HeadersOption> | ((context: {
+    baseHeaders: NonNullable<HeadersOption>;
+  }) => InferSchemaOutput<TSchema$1["headers"], HeadersOption>);
+}>;
+type InferRequestOptions<TSchema$1 extends CallApiSchema, TInitURL$1 extends InferInitURL<BaseCallApiSchemaRoutes, CallApiSchemaConfig>> = InferBodyOption<TSchema$1> & InferHeadersOption<TSchema$1> & InferMethodOption<TSchema$1, TInitURL$1>;
+type InferMetaOption<TSchema$1 extends CallApiSchema, TCallApiContext$1 extends CallApiContext> = MakeSchemaOptionRequiredIfDefined<TSchema$1["meta"], {
   /**
-   * Hook called during download stream progress tracking.
+   * - An optional field you can fill with additional information,
+   * to associate with the request, typically used for logging or tracing.
    *
-   * This hook is triggered when downloading data (like file downloads) and provides
-   * progress information about the download. Useful for implementing progress bars
-   * or download status indicators.
+   * - A good use case for this, would be to use the info to handle specific cases in any of the shared interceptors.
    *
-   * @param context - Response stream context with progress event and response
-   * @returns Promise or void - Hook can be async or sync
+   * @example
+   * ```ts
+   * const callMainApi = callApi.create({
+   * 	baseURL: "https://main-api.com",
+   * 	onResponseError: ({ response, options }) => {
+   * 		if (options.meta?.userId) {
+   * 			console.error(`User ${options.meta.userId} made an error`);
+   * 		}
+   * 	},
+   * });
    *
+   * const response = await callMainApi({
+   * 	url: "https://example.com/api/data",
+   * 	meta: { userId: "123" },
+   * });
+   * ```
    */
-  onResponseStream?: (context: ResponseStreamContext & PluginExtraOptions<TPluginOptions>) => Awaitable<unknown>;
+  meta?: InferSchemaOutput<TSchema$1["meta"], TCallApiContext$1["Meta"]>;
+}>;
+type InferQueryOption<TSchema$1 extends CallApiSchema> = MakeSchemaOptionRequiredIfDefined<TSchema$1["query"], {
   /**
-   * Hook called when a request is being retried.
-   *
-   * This hook is triggered before each retry attempt, providing information about
-   * the previous failure and the current retry attempt number. Useful for implementing
-   * custom retry logic, exponential backoff, or retry logging.
-   *
-   * @param context - Retry context with error details and retry attempt count
-   * @returns Promise or void - Hook can be async or sync
-   *
+   * Parameters to be appended to the URL (i.e: /:id)
    */
-  onRetry?: (response: RetryContext<TErrorData$1> & PluginExtraOptions<TPluginOptions>) => Awaitable<unknown>;
+  query?: InferSchemaOutput<TSchema$1["query"], Query>;
+}>;
+type EmptyString = "";
+type EmptyTuple = readonly [];
+type StringTuple = readonly string[];
+type PossibleParamNamePatterns = `${string}:${string}` | `${string}{${string}}${"" | AnyString}`;
+type ExtractRouteParamNames<TCurrentRoute$1, TParamNamesAccumulator extends StringTuple = EmptyTuple> = TCurrentRoute$1 extends PossibleParamNamePatterns ? TCurrentRoute$1 extends `${infer TRoutePrefix}:${infer TParamAndRemainingRoute}` ? TParamAndRemainingRoute extends `${infer TCurrentParam}/${infer TRemainingRoute}` ? TCurrentParam extends EmptyString ? ExtractRouteParamNames<`${TRoutePrefix}/${TRemainingRoute}`, TParamNamesAccumulator> : ExtractRouteParamNames<`${TRoutePrefix}/${TRemainingRoute}`, [...TParamNamesAccumulator, TCurrentParam]> : TParamAndRemainingRoute extends `${infer TCurrentParam}` ? TCurrentParam extends EmptyString ? ExtractRouteParamNames<TRoutePrefix, TParamNamesAccumulator> : ExtractRouteParamNames<TRoutePrefix, [...TParamNamesAccumulator, TCurrentParam]> : ExtractRouteParamNames<TRoutePrefix, TParamNamesAccumulator> : TCurrentRoute$1 extends `${infer TRoutePrefix}{${infer TCurrentParam}}${infer TRemainingRoute}` ? TCurrentParam extends EmptyString ? ExtractRouteParamNames<`${TRoutePrefix}${TRemainingRoute}`, TParamNamesAccumulator> : ExtractRouteParamNames<`${TRoutePrefix}${TRemainingRoute}`, [...TParamNamesAccumulator, TCurrentParam]> : TParamNamesAccumulator : TParamNamesAccumulator;
+type ConvertParamNamesToRecord<TParamNames extends StringTuple> = Prettify<TParamNames extends (readonly [infer TFirstParamName extends string, ...infer TRemainingParamNames extends StringTuple]) ? Record<TFirstParamName, AllowedQueryParamValues> & ConvertParamNamesToRecord<TRemainingParamNames> : NonNullable<unknown>>;
+type ConvertParamNamesToTuple<TParamNames extends StringTuple> = TParamNames extends readonly [string, ...infer TRemainingParamNames extends StringTuple] ? [AllowedQueryParamValues, ...ConvertParamNamesToTuple<TRemainingParamNames>] : [];
+type InferParamsFromRoute<TCurrentRoute$1> = ExtractRouteParamNames<TCurrentRoute$1> extends StringTuple ? ExtractRouteParamNames<TCurrentRoute$1> extends EmptyTuple ? Params : ConvertParamNamesToRecord<ExtractRouteParamNames<TCurrentRoute$1>> | ConvertParamNamesToTuple<ExtractRouteParamNames<TCurrentRoute$1>> : Params;
+type MakeParamsOptionRequired<TParamsSchemaOption extends CallApiSchema["params"], TBaseSchemaRoutes$1 extends BaseCallApiSchemaRoutes, TCurrentRouteSchemaKey$1 extends string, TObject> = MakeSchemaOptionRequiredIfDefined<TParamsSchemaOption, Params extends InferParamsFromRoute<TCurrentRouteSchemaKey$1> ? TObject : TCurrentRouteSchemaKey$1 extends Extract<keyof TBaseSchemaRoutes$1, TCurrentRouteSchemaKey$1> ? undefined extends InferSchemaOutput<TParamsSchemaOption, null> ? TObject : Required<TObject> : TObject>;
+type InferParamsOption<TSchema$1 extends CallApiSchema, TBaseSchemaRoutes$1 extends BaseCallApiSchemaRoutes, TCurrentRouteSchemaKey$1 extends string> = MakeParamsOptionRequired<TSchema$1["params"], TBaseSchemaRoutes$1, TCurrentRouteSchemaKey$1, {
   /**
-   * Hook called when a successful response (2xx status) is received from the API.
-   *
-   * This hook is triggered only for successful responses and provides access to
-   * the parsed response data. Ideal for success logging, caching, or post-processing
-   * of successful API responses.
-   *
-   * @param context - Success context with parsed response data and response object
-   * @returns Promise or void - Hook can be async or sync
-   *
+   * Parameters to be appended to the URL (i.e: /:id)
    */
-  onSuccess?: (context: SuccessContext<TData$1> & PluginExtraOptions<TPluginOptions>) => Awaitable<unknown>;
+  params?: InferSchemaOutput<TSchema$1["params"], InferParamsFromRoute<TCurrentRouteSchemaKey$1>>;
+}>;
+type InferExtraOptions<TSchema$1 extends CallApiSchema, TBaseSchemaRoutes$1 extends BaseCallApiSchemaRoutes, TCurrentRouteSchemaKey$1 extends string, TCallApiContext$1 extends CallApiContext> = InferMetaOption<TSchema$1, TCallApiContext$1> & InferParamsOption<TSchema$1, TBaseSchemaRoutes$1, TCurrentRouteSchemaKey$1> & InferQueryOption<TSchema$1>;
+type InferPluginOptions<TPluginArray$1 extends CallApiPlugin[]> = UnionToIntersection<TPluginArray$1 extends Array<infer TPlugin> ? TPlugin extends CallApiPlugin ? TPlugin["defineExtraOptions"] extends AnyFunction$1<infer TReturnedSchema> ? InferSchemaOutput<TReturnedSchema> : never : never : never>;
+type ResultModeOption<TErrorData$1, TResultMode$1 extends ResultModeType> = TErrorData$1 extends false ? {
+  resultMode: "onlyData";
+} : TErrorData$1 extends false | undefined ? {
+  resultMode?: "onlyData";
+} : {
+  resultMode?: TResultMode$1;
+};
+type ThrowOnErrorUnion = boolean;
+type ThrowOnErrorType<TErrorData$1, TThrowOnError$1 extends ThrowOnErrorUnion> = TThrowOnError$1 | ((context: ErrorContext<{
+  ErrorData: TErrorData$1;
+}>) => TThrowOnError$1);
+type ThrowOnErrorOption<TErrorData$1, TThrowOnError$1 extends ThrowOnErrorUnion> = TErrorData$1 extends false ? {
+  throwOnError: true;
+} : TErrorData$1 extends false | undefined ? {
+  throwOnError?: true;
+} : {
+  throwOnError?: ThrowOnErrorType<TErrorData$1, TThrowOnError$1>;
+};
+//#endregion
+//#region src/types/standard-schema.d.ts
+/**
+ * The Standard Schema interface.
+ * @see https://github.com/standard-schema/standard-schema
+ */
+interface StandardSchemaV1<Input$1 = unknown, Output$1 = Input$1> {
   /**
-   * Hook called when a validation error occurs.
-   *
-   * This hook is triggered when request or response data fails validation against
-   * a defined schema. It provides access to the validation error details and can
-   * be used for custom error handling, logging, or fallback behavior.
-   *
-   * @param context - Validation error context with error details and response (if available)
-   * @returns Promise or void - Hook can be async or sync
-   *
+   * The Standard Schema properties.
    */
-  onValidationError?: (context: ValidationErrorContext & PluginExtraOptions<TPluginOptions>) => Awaitable<unknown>;
+  readonly "~standard": StandardSchemaV1.Props<Input$1, Output$1>;
 }
-type HooksOrHooksArray<TData$1 = DefaultDataType, TErrorData$1 = DefaultDataType, TMoreOptions = unknown> = { [Key in keyof Hooks<TData$1, TErrorData$1, TMoreOptions>]: Hooks<TData$1, TErrorData$1, TMoreOptions>[Key] | Array<Hooks<TData$1, TErrorData$1, TMoreOptions>[Key]> };
-interface HookConfigOptions {
+declare namespace StandardSchemaV1 {
   /**
-   * Controls the execution mode of all composed hooks (main + plugin hooks).
-   *
-   * - **"parallel"**: All hooks execute simultaneously via Promise.all() for better performance
-   * - **"sequential"**: All hooks execute one by one in registration order via await in a loop
-   *
-   * This affects how ALL hooks execute together, regardless of their source (main or plugin).
-   *
-   * @default "parallel"
-   *
-   * @example
-   * ```ts
-   * // Parallel execution (default) - all hooks run simultaneously
-   * hooksExecutionMode: "parallel"
-   *
-   * // Sequential execution - hooks run one after another
-   * hooksExecutionMode: "sequential"
-   *
-   * // Use case: Hooks have dependencies and must run in order
-   * const client = callApi.create({
-   *   hooksExecutionMode: "sequential",
-   *   plugins: [transformPlugin],
-   *   onRequest: (ctx) => {
-   *     // This runs first, then transform plugin runs
-   *     ctx.request.headers["x-request-id"] = generateId();
-   *   }
-   * });
-   *
-   * // Use case: Independent operations can run in parallel for speed
-   * const client = callApi.create({
-   *   hooksExecutionMode: "parallel", // Default
-   *   plugins: [metricsPlugin, cachePlugin, loggingPlugin],
-   *   onRequest: (ctx) => {
-   *     // All hooks (main + plugins) run simultaneously
-   *     addRequestTimestamp(ctx.request);
-   *   }
-   * });
-   *
-   * // Use case: Error handling hooks that need sequential processing
-   * const client = callApi.create({
-   *   hooksExecutionMode: "sequential",
-   *   onError: [
-   *     (ctx) => logError(ctx.error),      // Log first
-   *     (ctx) => reportError(ctx.error),   // Then report
-   *     (ctx) => cleanupResources(ctx)     // Finally cleanup
-   *   ]
-   * });
-   * ```
+   * The Standard Schema properties interface.
    */
-  hooksExecutionMode?: "parallel" | "sequential";
-}
-type RequestContext = {
+  interface Props<Input = unknown, Output = Input> {
+    /**
+     * Inferred types associated with the schema.
+     */
+    readonly types?: Types<Input, Output> | undefined;
+    /**
+     * Validates unknown input values.
+     */
+    readonly validate: (value: unknown) => Promise<Result<Output>> | Result<Output>;
+    /**
+     * The vendor name of the schema library.
+     */
+    readonly vendor: string;
+    /**
+     * The version number of the standard.
+     */
+    readonly version: 1;
+  }
   /**
-   * Base configuration object passed to createFetchClient.
-   *
-   * Contains the foundational configuration that applies to all requests
-   * made by this client instance, such as baseURL, default headers, and
-   * global options.
+   * The result interface of the validate function.
    */
-  baseConfig: Exclude<BaseCallApiConfig, AnyFunction$1>;
+  type Result<Output> = FailureResult | SuccessResult<Output>;
   /**
-   * Instance-specific configuration object passed to the callApi instance.
-   *
-   * Contains configuration specific to this particular API call, which
-   * can override or extend the base configuration.
+   * The result interface if validation succeeds.
    */
-  config: CallApiConfig;
+  interface SuccessResult<Output> {
+    /**
+     * The non-existent issues.
+     */
+    readonly issues?: undefined;
+    /**
+     * The typed output value.
+     */
+    readonly value: Output;
+  }
   /**
-   * Merged options combining base config, instance config, and default options.
-   *
-   * This is the final resolved configuration that will be used for the request,
-   * with proper precedence applied (instance > base > defaults).
+   * The result interface if validation fails.
    */
-  options: CallApiExtraOptionsForHooks;
+  interface FailureResult {
+    /**
+     * The issues of failed validation.
+     */
+    readonly issues: readonly Issue[];
+  }
   /**
-   * Merged request object ready to be sent.
-   *
-   * Contains the final request configuration including URL, method, headers,
-   * body, and other fetch options. This object can be modified in onRequest
-   * hooks to customize the outgoing request.
+   * The issue interface of the failure output.
    */
-  request: CallApiRequestOptionsForHooks;
-};
-type ValidationErrorContext = UnmaskType<RequestContext & {
-  /** Validation error containing details about what failed validation */
-  error: PossibleValidationError;
-  /** HTTP response object if validation failed on response, null if on request */
-  response: Response | null;
-}>;
-type SuccessContext<TData$1> = UnmaskType<RequestContext & {
-  /** Parsed response data with the expected success type */
-  data: TData$1;
-  /** HTTP response object for the successful request */
-  response: Response;
-}>;
-type ResponseContext<TData$1, TErrorData$1> = UnmaskType<RequestContext & (Prettify<CallApiResultSuccessVariant<TData$1>> | Prettify<Extract<CallApiResultErrorVariant<TErrorData$1>, {
-  error: PossibleHTTPError<TErrorData$1>;
-}>>)>;
-type RequestErrorContext = RequestContext & {
-  /** Error that occurred during the request (network, timeout, etc.) */
-  error: PossibleJavaScriptError;
-  /** Always null for request errors since no response was received */
-  response: null;
-};
-type ErrorContext<TErrorData$1> = UnmaskType<RequestContext & ({
-  /** HTTP error with response data */
-  error: PossibleHTTPError<TErrorData$1>;
-  /** HTTP response object containing error status */
-  response: Response;
-} | {
-  /** Request-level error (network, timeout, validation, etc.) */
-  error: PossibleJavaScriptOrValidationError;
-  /** Response object if available, null for request errors */
-  response: Response | null;
-})>;
-type ResponseErrorContext<TErrorData$1> = UnmaskType<Extract<ErrorContext<TErrorData$1>, {
-  error: PossibleHTTPError<TErrorData$1>;
-}> & RequestContext>;
-type RetryContext<TErrorData$1> = UnmaskType<ErrorContext<TErrorData$1> & {
-  /** Current retry attempt number (1-based, so 1 = first retry) */
-  retryAttemptCount: number;
-}>;
-type RequestStreamContext = UnmaskType<RequestContext & {
-  /** Progress event containing loaded/total bytes information */
-  event: StreamProgressEvent;
-  /** The actual Request instance being uploaded */
-  requestInstance: Request;
-}>;
-type ResponseStreamContext = UnmaskType<RequestContext & {
-  /** Progress event containing loaded/total bytes information */
-  event: StreamProgressEvent;
-  /** HTTP response object being downloaded */
-  response: Response;
-}>;
-//#endregion
-//#region src/dedupe.d.ts
-type DedupeStrategyUnion = UnmaskType<"cancel" | "defer" | "none">;
-type DedupeOptionKeys = Exclude<keyof DedupeOptions, "dedupe">;
-type InnerDedupeOptions = { [Key in DedupeOptionKeys as RemovePrefix<"dedupe", Key>]?: DedupeOptions[Key] };
-type DedupeOptions = {
+  interface Issue {
+    /**
+     * The error message of the issue.
+     */
+    readonly message: string;
+    /**
+     * The path of the issue, if any.
+     */
+    readonly path?: ReadonlyArray<PathSegment | PropertyKey> | undefined;
+  }
   /**
-   * All dedupe options in a single object instead of separate properties
+   * The path segment interface of the issue.
    */
-  dedupe?: InnerDedupeOptions;
+  interface PathSegment {
+    /**
+     * The key representing a path segment.
+     */
+    readonly key: PropertyKey;
+  }
   /**
-   * Controls the scope of request deduplication caching.
-   *
-   * - `"global"`: Shares deduplication cache across all `createFetchClient` instances with the same `dedupeCacheScopeKey`.
-   *   Useful for applications with multiple API clients that should share deduplication state.
-   * - `"local"`: Limits deduplication to requests within the same `createFetchClient` instance.
-   *   Provides better isolation and is recommended for most use cases.
-   *
-   *
-   * **Real-world Scenarios:**
-   * - Use `"global"` when you have multiple API clients (user service, auth service, etc.) that might make overlapping requests
-   * - Use `"local"` (default) for single-purpose clients or when you want strict isolation between different parts of your app
-   *
-   * @example
-   * ```ts
-   * // Local scope - each client has its own deduplication cache
-   * const userClient = createFetchClient({ baseURL: "/api/users" });
-   * const postClient = createFetchClient({ baseURL: "/api/posts" });
-   * // These clients won't share deduplication state
-   *
-   * // Global scope - share cache across related clients
-   * const userClient = createFetchClient({
-   *   baseURL: "/api/users",
-   *   dedupeCacheScope: "global",
-   * });
-   * const postClient = createFetchClient({
-   *   baseURL: "/api/posts",
-   *   dedupeCacheScope: "global",
-   * });
-   * // These clients will share deduplication state
-   * ```
-   *
-   * @default "local"
+   * The Standard Schema types interface.
    */
-  dedupeCacheScope?: "global" | "local";
+  interface Types<Input = unknown, Output = Input> {
+    /** The input type of the schema. */
+    readonly input: Input;
+    /** The output type of the schema. */
+    readonly output: Output;
+  }
   /**
-   * Unique namespace for the global deduplication cache when using `dedupeCacheScope: "global"`.
-   *
-   * This creates logical groupings of deduplication caches. All instances with the same key
-   * will share the same cache namespace, allowing fine-grained control over which clients
-   * share deduplication state.
-   *
-   * **Best Practices:**
-   * - Use descriptive names that reflect the logical grouping (e.g., "user-service", "analytics-api")
-   * - Keep scope keys consistent across related API clients
-   * - Consider using different scope keys for different environments (dev, staging, prod)
-   * - Avoid overly broad scope keys that might cause unintended cache sharing
-   *
-   * **Cache Management:**
-   * - Each scope key maintains its own independent cache
-   * - Caches are automatically cleaned up when no references remain
-   * - Consider the memory implications of multiple global scopes
-   *
-   * @example
-   * ```ts
-   * // Group related API clients together
-   * const userClient = createFetchClient({
-   *   baseURL: "/api/users",
-   *   dedupeCacheScope: "global",
-   *   dedupeCacheScopeKey: "user-service"
-   * });
-   * const profileClient = createFetchClient({
-   *   baseURL: "/api/profiles",
-   *   dedupeCacheScope: "global",
-   *   dedupeCacheScopeKey: "user-service" // Same scope - will share cache
-   * });
-   *
-   * // Separate analytics client with its own cache
-   * const analyticsClient = createFetchClient({
-   *   baseURL: "/api/analytics",
-   *   dedupeCacheScope: "global",
-   *   dedupeCacheScopeKey: "analytics-service" // Different scope
-   * });
-   *
-   * // Environment-specific scoping
-   * const apiClient = createFetchClient({
-   *   dedupeCacheScope: "global",
-   *   dedupeCacheScopeKey: `api-${process.env.NODE_ENV}` // "api-development", "api-production", etc.
-   * });
-   * ```
-   *
-   * @default "default"
+   * Infers the input type of a Standard Schema.
+   */
+  type InferInput<Schema extends StandardSchemaV1> = NonNullable<Schema["~standard"]["types"]>["input"];
+  /**
+   * Infers the output type of a Standard Schema.
+   */
+  type InferOutput<Schema extends StandardSchemaV1> = NonNullable<Schema["~standard"]["types"]>["output"];
+}
+//#endregion
+//#region src/utils/external/error.d.ts
+type HTTPErrorDetails<TErrorData$1> = Pick<CallApiExtraOptions, "defaultHTTPErrorMessage"> & {
+  errorData: TErrorData$1;
+  response: Response;
+};
+declare class HTTPError<TErrorData$1 = Record<string, unknown>> extends Error {
+  errorData: HTTPErrorDetails<TErrorData$1>["errorData"];
+  readonly httpErrorSymbol: symbol;
+  name: "HTTPError";
+  response: HTTPErrorDetails<TErrorData$1>["response"];
+  constructor(errorDetails: HTTPErrorDetails<TErrorData$1>, 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
    */
-  dedupeCacheScopeKey?: "default" | AnyString | ((context: RequestContext) => string | undefined);
+  static isError<TErrorData>(error: unknown): error is HTTPError<TErrorData$1>;
+}
+type SafeExtract<TUnion, TKey extends TUnion> = Extract<TUnion, TKey>;
+type ValidationErrorDetails = {
   /**
-   * Custom key generator for request deduplication.
-   *
-   * Override the default key generation strategy to control exactly which requests
-   * are considered duplicates. The default key combines URL, method, body, and
-   * relevant headers (excluding volatile ones like 'Date', 'Authorization', etc.).
-   *
-   * **Default Key Generation:**
-   * The auto-generated key includes:
-   * - Full request URL (including query parameters)
-   * - HTTP method (GET, POST, etc.)
-   * - Request body (for POST/PUT/PATCH requests)
-   * - Stable headers (excludes Date, Authorization, User-Agent, etc.)
-   *
-   * **Custom Key Best Practices:**
-   * - Include only the parts of the request that should affect deduplication
-   * - Avoid including volatile data (timestamps, random IDs, etc.)
-   * - Consider performance - simpler keys are faster to compute and compare
-   * - Ensure keys are deterministic for the same logical request
-   * - Use consistent key formats across your application
-   *
-   * **Performance Considerations:**
-   * - Function-based keys are computed on every request - keep them lightweight
-   * - String keys are fastest but least flexible
-   * - Consider caching expensive key computations if needed
-   *
-   * @example
-   * ```ts
-   * import { callApi } from "@zayne-labs/callapi";
-   *
-   * // Simple static key - useful for singleton requests
-   * const config = callApi("/api/config", {
-   *   dedupeKey: "app-config",
-   *   dedupeStrategy: "defer" // Share the same config across all requests
-   * });
-   *
-   * // URL and method only - ignore headers and body
-   * const userData = callApi("/api/user/123", {
-   *   dedupeKey: (context) => `${context.options.method}:${context.options.fullURL}`
-   * });
-   *
-   * // Include specific headers in deduplication
-   * const apiCall = callApi("/api/data", {
-   *   dedupeKey: (context) => {
-   *     const authHeader = context.request.headers.get("Authorization");
-   *     return `${context.options.fullURL}-${authHeader}`;
-   *   }
-   * });
-   *
-   * // User-specific deduplication
-   * const userSpecificCall = callApi("/api/dashboard", {
-   *   dedupeKey: (context) => {
-   *     const userId = context.options.fullURL.match(/user\/(\d+)/)?.[1];
-   *     return `dashboard-${userId}`;
-   *   }
-   * });
-   *
-   * // Ignore certain query parameters
-   * const searchCall = callApi("/api/search?q=test&timestamp=123456", {
-   *   dedupeKey: (context) => {
-   *     const url = new URL(context.options.fullURL);
-   *     url.searchParams.delete("timestamp"); // Remove volatile param
-   *     return `search:${url.toString()}`;
-   *   }
-   * });
-   * ```
+   * The cause of the validation error.
    *
-   * @default Auto-generated from request details
+   * It's either the name the schema for which validation failed, or the name of the schema config option that led to the validation error.
    */
-  dedupeKey?: string | ((context: RequestContext) => string | undefined);
+  issueCause: "unknown" | `schemaConfig-(${SafeExtract<keyof CallApiSchemaConfig, "strict">})` | keyof CallApiSchema;
   /**
-   * Strategy for handling duplicate requests. Can be a static string or callback function.
-   *
-   * **Available Strategies:**
-   * - `"cancel"`: Cancel previous request when new one starts (good for search)
-   * - `"defer"`: Share response between duplicate requests (good for config loading)
-   * - `"none"`: No deduplication, all requests execute independently
-   *
-   * @example
-   * ```ts
-   * // Static strategies
-   * const searchClient = createFetchClient({
-   *   dedupeStrategy: "cancel" // Cancel previous searches
-   * });
-   *
-   * const configClient = createFetchClient({
-   *   dedupeStrategy: "defer" // Share config across components
-   * });
-   *
-   * // Dynamic strategy based on request
-   * const smartClient = createFetchClient({
-   *   dedupeStrategy: (context) => {
-   *     return context.options.method === "GET" ? "defer" : "cancel";
-   *   }
-   * });
-   *
-   * // Search-as-you-type with cancel strategy
-   * const handleSearch = async (query: string) => {
-   *   try {
-   *     const { data } = await callApi("/api/search", {
-   *       method: "POST",
-   *       body: { query },
-   *       dedupeStrategy: "cancel",
-   *       dedupeKey: "search" // Cancel previous searches, only latest one goes through
-   *     });
-   *
-   *     updateSearchResults(data);
-   *   } catch (error) {
-   *     if (error.name === "AbortError") {
-   *       // Previous search cancelled - (expected behavior)
-   *       return;
-   *     }
-   *     console.error("Search failed:", error);
-   *   }
-   * };
-   *
-   * ```
-   *
-   * @default "cancel"
+   * The issues that caused the validation error.
    */
-  dedupeStrategy?: DedupeStrategyUnion | ((context: RequestContext) => DedupeStrategyUnion);
+  issues: readonly StandardSchemaV1.Issue[];
+  /**
+   * The response from server, if any.
+   */
+  response: Response | null;
+};
+declare class ValidationError extends Error {
+  errorData: ValidationErrorDetails["issues"];
+  issueCause: ValidationErrorDetails["issueCause"];
+  name: "ValidationError";
+  response: ValidationErrorDetails["response"];
+  readonly validationErrorSymbol: symbol;
+  constructor(details: ValidationErrorDetails, errorOptions?: ErrorOptions);
+  /**
+   * @description Checks if the given error is an instance of ValidationError
+   * @param error - The error to check
+   * @returns true if the error is an instance of ValidationError, false otherwise
+   */
+  static isError(error: unknown): error is ValidationError;
+}
+//#endregion
+//#region src/result.d.ts
+type Parser<TData$1> = (responseString: string) => Awaitable<TData$1>;
+declare const getResponseType: <TResponse>(response: Response, parser: Parser<TResponse>) => {
+  arrayBuffer: () => Promise<ArrayBuffer>;
+  blob: () => Promise<Blob>;
+  formData: () => Promise<FormData>;
+  json: () => Promise<TResponse>;
+  stream: () => ReadableStream<Uint8Array<ArrayBuffer>> | null;
+  text: () => Promise<string>;
+};
+type InitResponseTypeMap<TResponse$1 = unknown> = ReturnType<typeof getResponseType<TResponse$1>>;
+type ResponseTypeUnion = keyof InitResponseTypeMap;
+type ResponseTypePlaceholder = null;
+type ResponseTypeType = ResponseTypePlaceholder | ResponseTypeUnion;
+type ResponseTypeMap<TResponse$1> = { [Key in keyof InitResponseTypeMap<TResponse$1>]: Awaited<ReturnType<InitResponseTypeMap<TResponse$1>[Key]>> };
+type GetResponseType<TResponse$1, TResponseType$1 extends ResponseTypeType, TComputedResponseTypeMap extends ResponseTypeMap<TResponse$1> = ResponseTypeMap<TResponse$1>> = null extends TResponseType$1 ? TComputedResponseTypeMap["json"] : TResponseType$1 extends NonNullable<ResponseTypeType> ? TComputedResponseTypeMap[TResponseType$1] : never;
+type CallApiResultSuccessVariant<TData$1> = {
+  data: NoInfer<TData$1>;
+  error: null;
+  response: Response;
+};
+type PossibleJavaScriptError = UnmaskType<{
+  errorData: false;
+  message: string;
+  name: "AbortError" | "Error" | "SyntaxError" | "TimeoutError" | "TypeError" | AnyString;
+  originalError: DOMException | Error | SyntaxError | TypeError;
+}>;
+type PossibleHTTPError<TErrorData$1> = UnmaskType<{
+  errorData: NoInfer<TErrorData$1>;
+  message: string;
+  name: "HTTPError";
+  originalError: HTTPError;
+}>;
+type PossibleValidationError = UnmaskType<{
+  errorData: ValidationError["errorData"];
+  issueCause: ValidationError["issueCause"];
+  message: string;
+  name: "ValidationError";
+  originalError: ValidationError;
+}>;
+type PossibleJavaScriptOrValidationError = UnmaskType<PossibleJavaScriptError | PossibleValidationError>;
+type CallApiResultErrorVariant<TErrorData$1> = {
+  data: null;
+  error: PossibleHTTPError<TErrorData$1>;
+  response: Response;
+} | {
+  data: null;
+  error: PossibleJavaScriptOrValidationError;
+  response: Response | null;
+};
+type CallApiSuccessOrErrorVariant<TData$1, TError> = CallApiResultErrorVariant<TError> | CallApiResultSuccessVariant<TData$1>;
+type ResultModeMapWithoutException<TData$1, TErrorData$1, TResponseType$1 extends ResponseTypeType, TComputedData = GetResponseType<TData$1, TResponseType$1>, TComputedErrorData = GetResponseType<TErrorData$1, TResponseType$1>, TComputedResult$1 extends CallApiSuccessOrErrorVariant<TComputedData, TComputedErrorData> = CallApiSuccessOrErrorVariant<TComputedData, TComputedErrorData>> = UnmaskType<{
+  all: TComputedResult$1;
+  onlyData: TComputedResult$1["data"];
+  onlyResponse: TComputedResult$1["response"];
+  withoutResponse: DistributiveOmit<TComputedResult$1, "response">;
+}>;
+type ResultModeMapWithException<TData$1, TResponseType$1 extends ResponseTypeType, TComputedData = GetResponseType<TData$1, TResponseType$1>, TComputedResult$1 extends CallApiResultSuccessVariant<TComputedData> = CallApiResultSuccessVariant<TComputedData>> = {
+  all: TComputedResult$1;
+  onlyData: TComputedResult$1["data"];
+  onlyResponse: TComputedResult$1["response"];
+  withoutResponse: DistributiveOmit<TComputedResult$1, "response">;
 };
+type ResultModeMap<TData$1 = DefaultDataType, TErrorData$1 = DefaultDataType, TResponseType$1 extends ResponseTypeType = ResponseTypeType, TThrowOnError$1 extends ThrowOnErrorUnion = DefaultThrowOnError> = TThrowOnError$1 extends true ? ResultModeMapWithException<TData$1, TResponseType$1> : ResultModeMapWithoutException<TData$1, TErrorData$1, TResponseType$1>;
+type ResultModePlaceholder = null;
+type ResultModeUnion = keyof ResultModeMap;
+type ResultModeType = ResultModePlaceholder | ResultModeUnion;
 //#endregion
 //#region src/retry.d.ts
 declare const defaultRetryStatusCodesLookup: () => Readonly<{
@@ -1030,7 +790,9 @@ declare const defaultRetryStatusCodesLookup: () => Readonly<{
   504: "Gateway Timeout";
 }>;
 type RetryStatusCodes = UnmaskType<AnyNumber | keyof ReturnType<typeof defaultRetryStatusCodesLookup>>;
-type RetryCondition<TErrorData$1> = (context: ErrorContext<TErrorData$1>) => Awaitable<boolean>;
+type RetryCondition<TErrorData$1> = (context: ErrorContext<{
+  ErrorData: TErrorData$1;
+}>) => Awaitable<boolean>;
 type RetryOptionKeys<TErrorData$1> = Exclude<keyof RetryOptions<TErrorData$1>, "~retryAttemptCount" | "retry">;
 type InnerRetryOptions<TErrorData$1> = { [Key in RetryOptionKeys<TErrorData$1> as RemovePrefix<"retry", Key>]?: RetryOptions<TErrorData$1>[Key] };
 interface RetryOptions<TErrorData$1> {
@@ -1060,141 +822,36 @@ interface RetryOptions<TErrorData$1> {
   retryDelay?: number | ((currentAttemptCount: number) => number);
   /**
    * Maximum delay in milliseconds. Only applies to exponential strategy
-   * @default 10000
-   */
-  retryMaxDelay?: number;
-  /**
-   * HTTP methods that are allowed to retry
-   * @default ["GET", "POST"]
-   */
-  retryMethods?: MethodUnion[];
-  /**
-   * HTTP status codes that trigger a retry
-   */
-  retryStatusCodes?: RetryStatusCodes[];
-  /**
-   * Strategy to use when retrying
-   * @default "linear"
-   */
-  retryStrategy?: "exponential" | "linear";
-}
-//#endregion
-//#region src/types/conditional-types.d.ts
-/**
- * @description Makes a type partial if the output type of TSchema is not provided or has undefined in the union, otherwise makes it required
- */
-type MakeSchemaOptionRequiredIfDefined<TSchemaOption extends CallApiSchema[keyof CallApiSchema], TObject> = undefined extends InferSchemaOutput<TSchemaOption, undefined> ? TObject : Required<TObject>;
-type ApplyURLBasedConfig<TSchemaConfig$1 extends CallApiSchemaConfig, TSchemaRouteKeys extends string> = TSchemaConfig$1["prefix"] extends string ? `${TSchemaConfig$1["prefix"]}${TSchemaRouteKeys}` : TSchemaConfig$1["baseURL"] extends string ? `${TSchemaConfig$1["baseURL"]}${TSchemaRouteKeys}` : TSchemaRouteKeys;
-type ApplyStrictConfig<TSchemaConfig$1 extends CallApiSchemaConfig, TSchemaRouteKeys extends string> = TSchemaConfig$1["strict"] extends true ? TSchemaRouteKeys :
-// eslint-disable-next-line perfectionist/sort-union-types -- Don't sort union types
-TSchemaRouteKeys | Exclude<InitURLOrURLObject, RouteKeyMethodsURLUnion>;
-type ApplySchemaConfiguration<TSchemaConfig$1 extends CallApiSchemaConfig, TSchemaRouteKeys extends string> = ApplyStrictConfig<TSchemaConfig$1, ApplyURLBasedConfig<TSchemaConfig$1, TSchemaRouteKeys>>;
-type InferAllRouteKeys<TBaseSchemaRoutes$1 extends BaseCallApiSchemaRoutes, TSchemaConfig$1 extends CallApiSchemaConfig> = ApplySchemaConfiguration<TSchemaConfig$1, Exclude<Extract<keyof TBaseSchemaRoutes$1, string>, FallBackRouteSchemaKey>>;
-type InferInitURL<TBaseSchemaRoutes$1 extends BaseCallApiSchemaRoutes, TSchemaConfig$1 extends CallApiSchemaConfig> = keyof TBaseSchemaRoutes$1 extends never ? InitURLOrURLObject : InferAllRouteKeys<TBaseSchemaRoutes$1, TSchemaConfig$1>;
-type GetCurrentRouteSchema<TBaseSchemaRoutes$1 extends BaseCallApiSchemaRoutes, TCurrentRouteSchemaKey extends string, TComputedFallBackRouteSchema = TBaseSchemaRoutes$1[FallBackRouteSchemaKey], TComputedCurrentRouteSchema = TBaseSchemaRoutes$1[TCurrentRouteSchemaKey], TComputedRouteSchema extends CallApiSchema = NonNullable<Omit<TComputedFallBackRouteSchema, keyof TComputedCurrentRouteSchema> & TComputedCurrentRouteSchema>> = TComputedRouteSchema extends CallApiSchema ? Writeable<TComputedRouteSchema, "deep"> : CallApiSchema;
-type JsonPrimitive = boolean | number | string | null | undefined;
-type SerializableObject = Record<PropertyKey, unknown>;
-type SerializableArray = Array<JsonPrimitive | SerializableObject> | ReadonlyArray<JsonPrimitive | SerializableObject>;
-type Body = UnmaskType<Exclude<RequestInit["body"], undefined> | SerializableArray | SerializableObject>;
-type InferBodyOption<TSchema$1 extends CallApiSchema> = MakeSchemaOptionRequiredIfDefined<TSchema$1["body"], {
-  /**
-   * Body of the request, can be a object or any other supported body type.
-   */
-  body?: InferSchemaOutput<TSchema$1["body"], Body>;
-}>;
-type MethodUnion = UnmaskType<"CONNECT" | "DELETE" | "GET" | "HEAD" | "OPTIONS" | "PATCH" | "POST" | "PUT" | "TRACE" | AnyString>;
-type InferMethodFromURL<TInitURL> = string extends TInitURL ? MethodUnion : TInitURL extends `@${infer TMethod extends RouteKeyMethods}/${string}` ? Uppercase<TMethod> : MethodUnion;
-type InferMethodOption<TSchema$1 extends CallApiSchema, TInitURL> = MakeSchemaOptionRequiredIfDefined<TSchema$1["method"], {
-  /**
-   * HTTP method for the request.
-   * @default "GET"
-   */
-  method?: InferSchemaOutput<TSchema$1["method"], InferMethodFromURL<TInitURL>>;
-}>;
-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$1 extends CallApiSchema> = MakeSchemaOptionRequiredIfDefined<TSchema$1["headers"], {
-  /**
-   * Headers to be used in the request.
+   * @default 10000
    */
-  headers?: InferSchemaOutput<TSchema$1["headers"], HeadersOption> | ((context: {
-    baseHeaders: NonNullable<HeadersOption>;
-  }) => InferSchemaOutput<TSchema$1["headers"], HeadersOption>);
-}>;
-type InferRequestOptions<TSchema$1 extends CallApiSchema, TInitURL extends InferInitURL<BaseCallApiSchemaRoutes, CallApiSchemaConfig>> = InferBodyOption<TSchema$1> & InferHeadersOption<TSchema$1> & InferMethodOption<TSchema$1, TInitURL>;
-type InferMetaOption<TSchema$1 extends CallApiSchema, TCallApiContext extends CallApiContext> = MakeSchemaOptionRequiredIfDefined<TSchema$1["meta"], {
+  retryMaxDelay?: number;
   /**
-   * - An optional field you can fill with additional information,
-   * to associate with the request, typically used for logging or tracing.
-   *
-   * - A good use case for this, would be to use the info to handle specific cases in any of the shared interceptors.
-   *
-   * @example
-   * ```ts
-   * const callMainApi = callApi.create({
-   * 	baseURL: "https://main-api.com",
-   * 	onResponseError: ({ response, options }) => {
-   * 		if (options.meta?.userId) {
-   * 			console.error(`User ${options.meta.userId} made an error`);
-   * 		}
-   * 	},
-   * });
-   *
-   * const response = await callMainApi({
-   * 	url: "https://example.com/api/data",
-   * 	meta: { userId: "123" },
-   * });
-   * ```
+   * HTTP methods that are allowed to retry
+   * @default ["GET", "POST"]
    */
-  meta?: InferSchemaOutput<TSchema$1["meta"], TCallApiContext["Meta"]>;
-}>;
-type InferQueryOption<TSchema$1 extends CallApiSchema> = MakeSchemaOptionRequiredIfDefined<TSchema$1["query"], {
+  retryMethods?: MethodUnion[];
   /**
-   * Parameters to be appended to the URL (i.e: /:id)
+   * HTTP status codes that trigger a retry
    */
-  query?: InferSchemaOutput<TSchema$1["query"], Query>;
-}>;
-type EmptyString = "";
-type EmptyTuple = readonly [];
-type StringTuple = readonly string[];
-type PossibleParamNamePatterns = `${string}:${string}` | `${string}{${string}}${"" | AnyString}`;
-type ExtractRouteParamNames<TCurrentRoute$1, TParamNamesAccumulator extends StringTuple = EmptyTuple> = TCurrentRoute$1 extends PossibleParamNamePatterns ? TCurrentRoute$1 extends `${infer TRoutePrefix}:${infer TParamAndRemainingRoute}` ? TParamAndRemainingRoute extends `${infer TCurrentParam}/${infer TRemainingRoute}` ? TCurrentParam extends EmptyString ? ExtractRouteParamNames<`${TRoutePrefix}/${TRemainingRoute}`, TParamNamesAccumulator> : ExtractRouteParamNames<`${TRoutePrefix}/${TRemainingRoute}`, [...TParamNamesAccumulator, TCurrentParam]> : TParamAndRemainingRoute extends `${infer TCurrentParam}` ? TCurrentParam extends EmptyString ? ExtractRouteParamNames<TRoutePrefix, TParamNamesAccumulator> : ExtractRouteParamNames<TRoutePrefix, [...TParamNamesAccumulator, TCurrentParam]> : ExtractRouteParamNames<TRoutePrefix, TParamNamesAccumulator> : TCurrentRoute$1 extends `${infer TRoutePrefix}{${infer TCurrentParam}}${infer TRemainingRoute}` ? TCurrentParam extends EmptyString ? ExtractRouteParamNames<`${TRoutePrefix}${TRemainingRoute}`, TParamNamesAccumulator> : ExtractRouteParamNames<`${TRoutePrefix}${TRemainingRoute}`, [...TParamNamesAccumulator, TCurrentParam]> : TParamNamesAccumulator : TParamNamesAccumulator;
-type ConvertParamNamesToRecord<TParamNames extends StringTuple> = Prettify<TParamNames extends (readonly [infer TFirstParamName extends string, ...infer TRemainingParamNames extends StringTuple]) ? Record<TFirstParamName, AllowedQueryParamValues> & ConvertParamNamesToRecord<TRemainingParamNames> : NonNullable<unknown>>;
-type ConvertParamNamesToTuple<TParamNames extends StringTuple> = TParamNames extends readonly [string, ...infer TRemainingParamNames extends StringTuple] ? [AllowedQueryParamValues, ...ConvertParamNamesToTuple<TRemainingParamNames>] : [];
-type InferParamsFromRoute<TCurrentRoute$1> = ExtractRouteParamNames<TCurrentRoute$1> extends StringTuple ? ExtractRouteParamNames<TCurrentRoute$1> extends EmptyTuple ? Params : ConvertParamNamesToRecord<ExtractRouteParamNames<TCurrentRoute$1>> | ConvertParamNamesToTuple<ExtractRouteParamNames<TCurrentRoute$1>> : Params;
-type MakeParamsOptionRequired<TParamsSchemaOption extends CallApiSchema["params"], TBaseSchemaRoutes$1 extends BaseCallApiSchemaRoutes, TCurrentRouteSchemaKey extends string, TObject> = MakeSchemaOptionRequiredIfDefined<TParamsSchemaOption, Params extends InferParamsFromRoute<TCurrentRouteSchemaKey> ? TObject : TCurrentRouteSchemaKey extends Extract<keyof TBaseSchemaRoutes$1, TCurrentRouteSchemaKey> ? undefined extends InferSchemaOutput<TParamsSchemaOption, null> ? TObject : Required<TObject> : TObject>;
-type InferParamsOption<TSchema$1 extends CallApiSchema, TBaseSchemaRoutes$1 extends BaseCallApiSchemaRoutes, TCurrentRouteSchemaKey extends string> = MakeParamsOptionRequired<TSchema$1["params"], TBaseSchemaRoutes$1, TCurrentRouteSchemaKey, {
+  retryStatusCodes?: RetryStatusCodes[];
   /**
-   * Parameters to be appended to the URL (i.e: /:id)
+   * Strategy to use when retrying
+   * @default "linear"
    */
-  params?: InferSchemaOutput<TSchema$1["params"], InferParamsFromRoute<TCurrentRouteSchemaKey>>;
-}>;
-type InferExtraOptions<TSchema$1 extends CallApiSchema, TBaseSchemaRoutes$1 extends BaseCallApiSchemaRoutes, TCurrentRouteSchemaKey extends string, TCallApiContext extends CallApiContext> = InferMetaOption<TSchema$1, TCallApiContext> & InferParamsOption<TSchema$1, TBaseSchemaRoutes$1, TCurrentRouteSchemaKey> & InferQueryOption<TSchema$1>;
-type InferPluginOptions<TPluginArray extends CallApiPlugin[]> = UnionToIntersection<TPluginArray extends Array<infer TPlugin> ? TPlugin extends CallApiPlugin ? TPlugin["defineExtraOptions"] extends AnyFunction$1<infer TReturnedSchema> ? InferSchemaOutput<TReturnedSchema> : never : never : never>;
-type ResultModeOption<TErrorData$1, TResultMode extends ResultModeType> = TErrorData$1 extends false ? {
-  resultMode: "onlyData";
-} : TErrorData$1 extends false | undefined ? {
-  resultMode?: "onlyData";
-} : {
-  resultMode?: TResultMode;
-};
-type ThrowOnErrorUnion = boolean;
-type ThrowOnErrorType<TErrorData$1, TThrowOnError extends ThrowOnErrorUnion> = TThrowOnError | ((context: ErrorContext<TErrorData$1>) => TThrowOnError);
-type ThrowOnErrorOption<TErrorData$1, TThrowOnError extends ThrowOnErrorUnion> = TErrorData$1 extends false ? {
-  throwOnError: true;
-} : TErrorData$1 extends false | undefined ? {
-  throwOnError?: true;
-} : {
-  throwOnError?: ThrowOnErrorType<TErrorData$1, TThrowOnError>;
-};
+  retryStrategy?: "exponential" | "linear";
+}
 //#endregion
 //#region src/types/common.d.ts
 interface Register {}
-type MetaObjectType = Record<string, unknown>;
 type GlobalMeta = Register extends {
-  meta?: infer TMeta extends MetaObjectType;
-} ? TMeta : never;
+  meta?: infer TMeta extends DefaultMetaObject;
+} ? TMeta : DefaultMetaObject;
 type CallApiContext = {
-  Meta?: MetaObjectType;
+  Data?: DefaultDataType;
+  ErrorData?: DefaultDataType;
+  InferredPluginOptions?: unknown;
+  Meta?: DefaultMetaObject;
+  ResultMode?: ResultModeType;
 };
 type FetchSpecificKeysUnion = Exclude<(typeof fetchSpecificKeys)[number], "body" | "headers" | "method">;
 type ModifiedRequestInit = RequestInit & {
@@ -1218,7 +875,9 @@ type CallApiRequestOptions = Prettify<{
 type CallApiRequestOptionsForHooks = Omit<CallApiRequestOptions, "headers"> & {
   headers: Record<string, string | undefined>;
 };
-type SharedExtraOptions<TCallApiContext extends CallApiContext = CallApiContext, TData$1 = DefaultDataType, TErrorData$1 = DefaultDataType, TResultMode extends ResultModeType = ResultModeType, TThrowOnError extends ThrowOnErrorUnion = DefaultThrowOnError, TResponseType extends ResponseTypeType = ResponseTypeType, TPluginArray extends CallApiPlugin[] = DefaultPluginArray> = DedupeOptions & HookConfigOptions & HooksOrHooksArray<TData$1, TErrorData$1, Partial<InferPluginOptions<TPluginArray>>> & Middlewares & Partial<InferPluginOptions<TPluginArray>> & ResultModeOption<TErrorData$1, TResultMode> & RetryOptions<TErrorData$1> & ThrowOnErrorOption<TErrorData$1, TThrowOnError> & URLOptions & {
+type SharedExtraOptions<TCallApiContext$1 extends CallApiContext = DefaultCallApiContext, TData$1 = DefaultDataType, TErrorData$1 = DefaultDataType, TResultMode$1 extends ResultModeType = ResultModeType, TThrowOnError$1 extends ThrowOnErrorUnion = DefaultThrowOnError, TResponseType$1 extends ResponseTypeType = ResponseTypeType, TPluginArray$1 extends CallApiPlugin[] = DefaultPluginArray, TComputedPluginOptions = InferPluginOptions<TPluginArray$1> & TCallApiContext$1["InferredPluginOptions"], TComputedInferredPluginOptions extends Pick<Required<CallApiContext>, "InferredPluginOptions"> = {
+  InferredPluginOptions: TComputedPluginOptions;
+}> = DedupeOptions & HookConfigOptions & HooksOrHooksArray<TComputedInferredPluginOptions, TData$1, TErrorData$1> & Middlewares & Partial<TComputedInferredPluginOptions["InferredPluginOptions"]> & ResultModeOption<TErrorData$1, TResultMode$1> & RetryOptions<TErrorData$1> & ThrowOnErrorOption<TErrorData$1, TThrowOnError$1> & URLOptions & {
   /**
    * Automatically add an Authorization header value.
    *
@@ -1396,7 +1055,7 @@ type SharedExtraOptions<TCallApiContext extends CallApiContext = CallApiContext,
    * });
    * ```
    */
-  meta?: TCallApiContext["Meta"];
+  meta?: TCallApiContext$1["Meta"] extends DefaultMetaObject ? TCallApiContext$1["Meta"] : DefaultCallApiContext["Meta"];
   /**
    * Custom function to parse response strings into actual value instead of the default response.json().
    *
@@ -1466,7 +1125,7 @@ type SharedExtraOptions<TCallApiContext extends CallApiContext = CallApiContext,
    * // Usage: const stream = await callApi("/large-dataset", { responseType: "stream" });
    * ```
    */
-  responseType?: TResponseType;
+  responseType?: TResponseType$1;
   /**
    * Controls what data is included in the returned result object.
    *
@@ -1521,7 +1180,7 @@ type SharedExtraOptions<TCallApiContext extends CallApiContext = CallApiContext,
    * }
    * ```
    */
-  resultMode?: TResultMode;
+  resultMode?: TResultMode$1;
   /**
    * Controls whether errors are thrown as exceptions or returned in the result.
    *
@@ -1566,7 +1225,7 @@ type SharedExtraOptions<TCallApiContext extends CallApiContext = CallApiContext,
    * }
    * ```
    */
-  throwOnError?: ThrowOnErrorType<TErrorData$1, TThrowOnError>;
+  throwOnError?: ThrowOnErrorType<TErrorData$1, TThrowOnError$1>;
   /**
    * Request timeout in milliseconds. Request will be aborted if it takes longer.
    *
@@ -1590,154 +1249,444 @@ type SharedExtraOptions<TCallApiContext extends CallApiContext = CallApiContext,
    * timeout: 0
    * ```
    */
-  timeout?: number;
-};
-type BaseCallApiExtraOptions<TBaseCallApiContext extends CallApiContext = CallApiContext, TBaseData = DefaultDataType, TBaseErrorData = DefaultDataType, TBaseResultMode extends ResultModeType = ResultModeType, TBaseThrowOnError extends ThrowOnErrorUnion = DefaultThrowOnError, TBaseResponseType extends ResponseTypeType = ResponseTypeType, TBasePluginArray extends CallApiPlugin[] = DefaultPluginArray, TBaseSchemaAndConfig extends BaseCallApiSchemaAndConfig = BaseCallApiSchemaAndConfig> = SharedExtraOptions<TBaseCallApiContext, TBaseData, TBaseErrorData, TBaseResultMode, TBaseThrowOnError, TBaseResponseType, TBasePluginArray> & {
+  timeout?: number;
+};
+type BaseCallApiExtraOptions<TBaseCallApiContext$1 extends CallApiContext = DefaultCallApiContext, TBaseData$1 = DefaultDataType, TBaseErrorData$1 = DefaultDataType, TBaseResultMode$1 extends ResultModeType = ResultModeType, TBaseThrowOnError$1 extends ThrowOnErrorUnion = DefaultThrowOnError, TBaseResponseType$1 extends ResponseTypeType = ResponseTypeType, TBasePluginArray$1 extends CallApiPlugin[] = DefaultPluginArray, TBaseSchemaAndConfig$1 extends BaseCallApiSchemaAndConfig = BaseCallApiSchemaAndConfig> = SharedExtraOptions<TBaseCallApiContext$1, TBaseData$1, TBaseErrorData$1, TBaseResultMode$1, TBaseThrowOnError$1, TBaseResponseType$1, TBasePluginArray$1> & {
+  /**
+   * Array of base CallApi plugins to extend library functionality.
+   *
+   * Base plugins are applied to all instances created from this base configuration
+   * and provide foundational functionality like authentication, logging, or caching.
+   *
+   * @example
+   * ```ts
+   * // Add logging plugin
+   *
+   * // Create base client with common plugins
+   * const callApi = createFetchClient({
+   *   baseURL: "https://api.example.com",
+   *   plugins: [loggerPlugin({ enabled: true })]
+   * });
+   *
+   * // All requests inherit base plugins
+   * await callApi("/users");
+   * await callApi("/posts");
+   *
+   * ```
+   */
+  plugins?: TBasePluginArray$1;
+  /**
+   * Base validation schemas for the client configuration.
+   *
+   * Defines validation rules for requests and responses that apply to all
+   * instances created from this base configuration. Provides type safety
+   * and runtime validation for API interactions.
+   */
+  schema?: TBaseSchemaAndConfig$1;
+  /**
+   * Controls which configuration parts skip automatic merging between base and instance configs.
+   *
+   * By default, CallApi automatically merges base configuration with instance configuration.
+   * This option allows you to disable automatic merging for specific parts when you need
+   * manual control over how configurations are combined.
+   *
+   * @enum
+   * - **"all"**: Disables automatic merging for both request options and extra options
+   * - **"options"**: Disables automatic merging of extra options only (hooks, plugins, etc.)
+   * - **"request"**: Disables automatic merging of request options only (headers, body, etc.)
+   *
+   * @example
+   * ```ts
+   * // Skip all automatic merging - full manual control
+   * const client = callApi.create((ctx) => ({
+   *   skipAutoMergeFor: "all",
+   *
+   *   // Manually decide what to merge
+   *   baseURL: ctx.options.baseURL, // Keep base URL
+   *   timeout: 5000, // Override timeout
+   *   headers: {
+   *     ...ctx.request.headers, // Merge headers manually
+   *     "X-Custom": "value" // Add custom header
+   *   }
+   * }));
+   *
+   * // Skip options merging - manual plugin/hook control
+   * const client = callApi.create((ctx) => ({
+   *   skipAutoMergeFor: "options",
+   *
+   *   // Manually control which plugins to use
+   *   plugins: [
+   *     ...ctx.options.plugins?.filter(p => p.name !== "unwanted") || [],
+   *     customPlugin
+   *   ],
+   *
+   *   // Request options still auto-merge
+   *   method: "POST"
+   * }));
+   *
+   * // Skip request merging - manual request control
+   * const client = callApi.create((ctx) => ({
+   *   skipAutoMergeFor: "request",
+   *
+   *   // Extra options still auto-merge (plugins, hooks, etc.)
+   *
+   *   // Manually control request options
+   *   headers: {
+   *     "Content-Type": "application/json",
+   *     // Don't merge base headers
+   *   },
+   *   method: ctx.request.method || "GET"
+   * }));
+   *
+   * // Use case: Conditional merging based on request
+   * const client = createFetchClient((ctx) => ({
+   *   skipAutoMergeFor: "options",
+   *
+   *   // Only use auth plugin for protected routes
+   *   plugins: ctx.initURL.includes("/protected/")
+   *     ? [...(ctx.options.plugins || []), authPlugin]
+   *     : ctx.options.plugins?.filter(p => p.name !== "auth") || []
+   * }));
+   * ```
+   */
+  skipAutoMergeFor?: "all" | "options" | "request";
+};
+type InferExtendSchemaContext<TBaseSchemaRoutes$1 extends BaseCallApiSchemaRoutes, TCurrentRouteSchemaKey$1 extends string> = {
+  baseSchemaRoutes: TBaseSchemaRoutes$1;
+  currentRouteSchema: GetCurrentRouteSchema<TBaseSchemaRoutes$1, TCurrentRouteSchemaKey$1>;
+};
+type GetExtendSchemaConfigContext<TBaseSchemaConfig extends CallApiSchemaConfig> = {
+  baseSchemaConfig: TBaseSchemaConfig;
+};
+type InferExtendPluginContext<TBasePluginArray$1 extends CallApiPlugin[]> = {
+  basePlugins: TBasePluginArray$1;
+};
+type CallApiExtraOptions<TCallApiContext$1 extends CallApiContext = DefaultCallApiContext, TData$1 = DefaultDataType, TErrorData$1 = DefaultDataType, TResultMode$1 extends ResultModeType = ResultModeType, TThrowOnError$1 extends ThrowOnErrorUnion = DefaultThrowOnError, TResponseType$1 extends ResponseTypeType = ResponseTypeType, TBasePluginArray$1 extends CallApiPlugin[] = DefaultPluginArray, TPluginArray$1 extends CallApiPlugin[] = DefaultPluginArray, TBaseSchemaRoutes$1 extends BaseCallApiSchemaRoutes = BaseCallApiSchemaRoutes, TSchema$1 extends CallApiSchema = CallApiSchema, TBaseSchemaConfig extends CallApiSchemaConfig = CallApiSchemaConfig, TSchemaConfig$1 extends CallApiSchemaConfig = CallApiSchemaConfig, TCurrentRouteSchemaKey$1 extends string = string, TComputedPluginContext = InferExtendPluginContext<TBasePluginArray$1>, TComputedSchemaContext = InferExtendSchemaContext<TBaseSchemaRoutes$1, TCurrentRouteSchemaKey$1>, TComputedSchemaConfigContext = GetExtendSchemaConfigContext<TBaseSchemaConfig>> = SharedExtraOptions<TCallApiContext$1, TData$1, TErrorData$1, TResultMode$1, TThrowOnError$1, TResponseType$1, TPluginArray$1> & {
+  /**
+   * Array of instance-specific CallApi plugins or a function to configure plugins.
+   *
+   * Instance plugins are added to the base plugins and provide functionality
+   * specific to this particular API instance. Can be a static array or a function
+   * that receives base plugins and returns the instance plugins.
+   *
+   */
+  plugins?: TPluginArray$1 | ((context: TComputedPluginContext) => TPluginArray$1);
+  /**
+   * For instance-specific validation schemas
+   *
+   * Defines validation rules specific to this API instance, extending or overriding the base schema.
+   *
+   * Can be a static schema object or a function that receives base schema context and returns instance schemas.
+   *
+   */
+  schema?: TSchema$1 | ((context: TComputedSchemaContext) => TSchema$1);
+  /**
+   * Instance-specific schema configuration or a function to configure schema behavior.
+   *
+   * Controls how validation schemas are applied and behave for this specific API instance.
+   * Can override base schema configuration or extend it with instance-specific validation rules.
+   *
+   */
+  schemaConfig?: TSchemaConfig$1 | ((context: TComputedSchemaConfigContext) => TSchemaConfig$1);
+};
+type CallApiExtraOptionsForHooks<TCallApiContext$1 extends CallApiContext = DefaultCallApiContext> = Hooks & Omit<CallApiExtraOptions<TCallApiContext$1>, keyof Hooks>;
+type InstanceContext = {
+  initURL: string;
+  options: CallApiExtraOptions;
+  request: CallApiRequestOptions;
+};
+type BaseCallApiConfig<TBaseCallApiContext$1 extends CallApiContext = DefaultCallApiContext, TBaseData$1 = DefaultDataType, TBaseErrorData$1 = DefaultDataType, TBaseResultMode$1 extends ResultModeType = ResultModeType, TBaseThrowOnError$1 extends ThrowOnErrorUnion = DefaultThrowOnError, TBaseResponseType$1 extends ResponseTypeType = ResponseTypeType, TBaseSchemaAndConfig$1 extends BaseCallApiSchemaAndConfig = BaseCallApiSchemaAndConfig, TBasePluginArray$1 extends CallApiPlugin[] = DefaultPluginArray, TComputedBaseConfig = BaseCallApiExtraOptions<TBaseCallApiContext$1, TBaseData$1, TBaseErrorData$1, TBaseResultMode$1, TBaseThrowOnError$1, TBaseResponseType$1, TBasePluginArray$1, TBaseSchemaAndConfig$1>> = (CallApiRequestOptions & TComputedBaseConfig) | ((context: InstanceContext) => CallApiRequestOptions & TComputedBaseConfig);
+type CallApiConfig<TCallApiContext$1 extends CallApiContext = DefaultCallApiContext, TData$1 = DefaultDataType, TErrorData$1 = DefaultDataType, TResultMode$1 extends ResultModeType = ResultModeType, TThrowOnError$1 extends ThrowOnErrorUnion = DefaultThrowOnError, TResponseType$1 extends ResponseTypeType = ResponseTypeType, TBaseSchemaRoutes$1 extends BaseCallApiSchemaRoutes = BaseCallApiSchemaRoutes, TSchema$1 extends CallApiSchema = CallApiSchema, TBaseSchemaConfig extends CallApiSchemaConfig = CallApiSchemaConfig, TSchemaConfig$1 extends CallApiSchemaConfig = CallApiSchemaConfig, TInitURL$1 extends InitURLOrURLObject = InitURLOrURLObject, TCurrentRouteSchemaKey$1 extends string = string, TBasePluginArray$1 extends CallApiPlugin[] = DefaultPluginArray, TPluginArray$1 extends CallApiPlugin[] = DefaultPluginArray> = InferExtraOptions<TSchema$1, TBaseSchemaRoutes$1, TCurrentRouteSchemaKey$1, TCallApiContext$1> & InferRequestOptions<TSchema$1, TInitURL$1> & Omit<CallApiExtraOptions<TCallApiContext$1, TData$1, TErrorData$1, TResultMode$1, TThrowOnError$1, TResponseType$1, TBasePluginArray$1, TPluginArray$1, TBaseSchemaRoutes$1, TSchema$1, TBaseSchemaConfig, TSchemaConfig$1, TCurrentRouteSchemaKey$1>, keyof InferExtraOptions<CallApiSchema, BaseCallApiSchemaRoutes, string, CallApiContext>> & Omit<CallApiRequestOptions, keyof InferRequestOptions<CallApiSchema, string>>;
+//#endregion
+//#region src/stream.d.ts
+type StreamProgressEvent = {
+  /**
+   * Current chunk of data being streamed
+   */
+  chunk: Uint8Array;
+  /**
+   * Progress in percentage
+   */
+  progress: number;
+  /**
+   * Total size of data in bytes
+   */
+  totalBytes: number;
+  /**
+   * Amount of data transferred so far
+   */
+  transferredBytes: number;
+};
+declare global {
+  interface ReadableStream<R> {
+    [Symbol.asyncIterator]: () => AsyncIterableIterator<R>;
+  }
+}
+//#endregion
+//#region src/hooks.d.ts
+interface Hooks<TCallApiContext$1 extends Pick<CallApiContext, "Data" | "ErrorData" | "InferredPluginOptions" | "Meta"> = DefaultCallApiContext, TData$1 = TCallApiContext$1["Data"], TErrorData$1 = TCallApiContext$1["ErrorData"]> {
+  /**
+   * Hook called when any error occurs within the request/response lifecycle.
+   *
+   * This is a unified error handler that catches both request errors (network failures,
+   * timeouts, etc.) and response errors (HTTP error status codes). It's essentially
+   * a combination of `onRequestError` and `onResponseError` hooks.
+   *
+   * @param context - Error context containing error details, request info, and response (if available)
+   * @returns Promise or void - Hook can be async or sync
+   */
+  onError?: (context: ErrorContext<TCallApiContext$1, TErrorData$1>) => Awaitable<unknown>;
+  /**
+   * Hook called before the HTTP request is sent and before any internal processing of the request object begins.
+   *
+   * This is the ideal place to modify request headers, add authentication,
+   * implement request logging, or perform any setup before the network call.
+   *
+   * @param context - Request context with mutable request object and configuration
+   * @returns Promise or void - Hook can be async or sync
+   *
+   */
+  onRequest?: (context: RequestContext<TCallApiContext$1>) => Awaitable<unknown>;
+  /**
+   * Hook called when an error occurs during the fetch request itself.
+   *
+   * This handles network-level errors like connection failures, timeouts,
+   * DNS resolution errors, or other issues that prevent getting an HTTP response.
+   * Note that HTTP error status codes (4xx, 5xx) are handled by `onResponseError`.
+   *
+   * @param context - Request error context with error details and null response
+   * @returns Promise or void - Hook can be async or sync
+   */
+  onRequestError?: (context: RequestErrorContext<TCallApiContext$1>) => Awaitable<unknown>;
+  /**
+   * Hook called just before the HTTP request is sent and after the request has been processed.
+   *
+   * @param context - Request context with mutable request object and configuration
+   */
+  onRequestReady?: (context: RequestContext<TCallApiContext$1>) => Awaitable<unknown>;
   /**
-   * Array of base CallApi plugins to extend library functionality.
+   * Hook called during upload stream progress tracking.
    *
-   * Base plugins are applied to all instances created from this base configuration
-   * and provide foundational functionality like authentication, logging, or caching.
+   * This hook is triggered when uploading data (like file uploads) and provides
+   * progress information about the upload. Useful for implementing progress bars
+   * or upload status indicators.
    *
-   * @example
-   * ```ts
-   * // Add logging plugin
+   * @param context - Request stream context with progress event and request instance
+   * @returns Promise or void - Hook can be async or sync
    *
-   * // Create base client with common plugins
-   * const callApi = createFetchClient({
-   *   baseURL: "https://api.example.com",
-   *   plugins: [loggerPlugin({ enabled: true })]
-   * });
+   */
+  onRequestStream?: (context: RequestStreamContext<TCallApiContext$1>) => Awaitable<unknown>;
+  /**
+   * Hook called when any HTTP response is received from the API.
    *
-   * // All requests inherit base plugins
-   * await callApi("/users");
-   * await callApi("/posts");
+   * This hook is triggered for both successful (2xx) and error (4xx, 5xx) responses.
+   * It's useful for response logging, metrics collection, or any processing that
+   * should happen regardless of response status.
+   *
+   * @param context - Response context with either success data or error information
+   * @returns Promise or void - Hook can be async or sync
    *
-   * ```
    */
-  plugins?: TBasePluginArray;
+  onResponse?: (context: ResponseContext<TCallApiContext$1, TData$1, TErrorData$1>) => Awaitable<unknown>;
   /**
-   * Base validation schemas for the client configuration.
+   * Hook called when an HTTP error response (4xx, 5xx) is received from the API.
    *
-   * Defines validation rules for requests and responses that apply to all
-   * instances created from this base configuration. Provides type safety
-   * and runtime validation for API interactions.
+   * This handles server-side errors where an HTTP response was successfully received
+   * but indicates an error condition. Different from `onRequestError` which handles
+   * network-level failures.
+   *
+   * @param context - Response error context with HTTP error details and response
+   * @returns Promise or void - Hook can be async or sync
    */
-  schema?: TBaseSchemaAndConfig;
+  onResponseError?: (context: ResponseErrorContext<TCallApiContext$1, TErrorData$1>) => Awaitable<unknown>;
   /**
-   * Controls which configuration parts skip automatic merging between base and instance configs.
+   * Hook called during download stream progress tracking.
    *
-   * By default, CallApi automatically merges base configuration with instance configuration.
-   * This option allows you to disable automatic merging for specific parts when you need
-   * manual control over how configurations are combined.
+   * This hook is triggered when downloading data (like file downloads) and provides
+   * progress information about the download. Useful for implementing progress bars
+   * or download status indicators.
    *
-   * @enum
-   * - **"all"**: Disables automatic merging for both request options and extra options
-   * - **"options"**: Disables automatic merging of extra options only (hooks, plugins, etc.)
-   * - **"request"**: Disables automatic merging of request options only (headers, body, etc.)
+   * @param context - Response stream context with progress event and response
+   * @returns Promise or void - Hook can be async or sync
    *
-   * @example
-   * ```ts
-   * // Skip all automatic merging - full manual control
-   * const client = callApi.create((ctx) => ({
-   *   skipAutoMergeFor: "all",
+   */
+  onResponseStream?: (context: ResponseStreamContext<TCallApiContext$1>) => Awaitable<unknown>;
+  /**
+   * Hook called when a request is being retried.
    *
-   *   // Manually decide what to merge
-   *   baseURL: ctx.options.baseURL, // Keep base URL
-   *   timeout: 5000, // Override timeout
-   *   headers: {
-   *     ...ctx.request.headers, // Merge headers manually
-   *     "X-Custom": "value" // Add custom header
-   *   }
-   * }));
+   * This hook is triggered before each retry attempt, providing information about
+   * the previous failure and the current retry attempt number. Useful for implementing
+   * custom retry logic, exponential backoff, or retry logging.
    *
-   * // Skip options merging - manual plugin/hook control
-   * const client = callApi.create((ctx) => ({
-   *   skipAutoMergeFor: "options",
+   * @param context - Retry context with error details and retry attempt count
+   * @returns Promise or void - Hook can be async or sync
    *
-   *   // Manually control which plugins to use
-   *   plugins: [
-   *     ...ctx.options.plugins?.filter(p => p.name !== "unwanted") || [],
-   *     customPlugin
-   *   ],
+   */
+  onRetry?: (response: RetryContext<TCallApiContext$1, TErrorData$1>) => Awaitable<unknown>;
+  /**
+   * Hook called when a successful response (2xx status) is received from the API.
    *
-   *   // Request options still auto-merge
-   *   method: "POST"
-   * }));
+   * This hook is triggered only for successful responses and provides access to
+   * the parsed response data. Ideal for success logging, caching, or post-processing
+   * of successful API responses.
    *
-   * // Skip request merging - manual request control
-   * const client = callApi.create((ctx) => ({
-   *   skipAutoMergeFor: "request",
+   * @param context - Success context with parsed response data and response object
+   * @returns Promise or void - Hook can be async or sync
    *
-   *   // Extra options still auto-merge (plugins, hooks, etc.)
+   */
+  onSuccess?: (context: SuccessContext<TCallApiContext$1, TData$1>) => Awaitable<unknown>;
+  /**
+   * Hook called when a validation error occurs.
    *
-   *   // Manually control request options
-   *   headers: {
-   *     "Content-Type": "application/json",
-   *     // Don't merge base headers
-   *   },
-   *   method: ctx.request.method || "GET"
-   * }));
+   * This hook is triggered when request or response data fails validation against
+   * a defined schema. It provides access to the validation error details and can
+   * be used for custom error handling, logging, or fallback behavior.
    *
-   * // Use case: Conditional merging based on request
-   * const client = createFetchClient((ctx) => ({
-   *   skipAutoMergeFor: "options",
+   * @param context - Validation error context with error details and response (if available)
+   * @returns Promise or void - Hook can be async or sync
    *
-   *   // Only use auth plugin for protected routes
-   *   plugins: ctx.initURL.includes("/protected/")
-   *     ? [...(ctx.options.plugins || []), authPlugin]
-   *     : ctx.options.plugins?.filter(p => p.name !== "auth") || []
-   * }));
-   * ```
    */
-  skipAutoMergeFor?: "all" | "options" | "request";
-};
-type InferExtendSchemaContext<TBaseSchemaRoutes$1 extends BaseCallApiSchemaRoutes, TCurrentRouteSchemaKey extends string> = {
-  baseSchemaRoutes: TBaseSchemaRoutes$1;
-  currentRouteSchema: GetCurrentRouteSchema<TBaseSchemaRoutes$1, TCurrentRouteSchemaKey>;
-};
-type InferExtendSchemaConfigContext<TBaseSchemaConfig extends CallApiSchemaConfig> = {
-  baseSchemaConfig: TBaseSchemaConfig;
-};
-type InferExtendPluginContext<TBasePluginArray extends CallApiPlugin[]> = {
-  basePlugins: TBasePluginArray;
-};
-type CallApiExtraOptions<TCallApiContext extends CallApiContext = CallApiContext, TData$1 = DefaultDataType, TErrorData$1 = DefaultDataType, TResultMode extends ResultModeType = ResultModeType, TThrowOnError extends ThrowOnErrorUnion = DefaultThrowOnError, TResponseType extends ResponseTypeType = ResponseTypeType, TBasePluginArray extends CallApiPlugin[] = DefaultPluginArray, TPluginArray extends CallApiPlugin[] = DefaultPluginArray, TBaseSchemaRoutes$1 extends BaseCallApiSchemaRoutes = BaseCallApiSchemaRoutes, TSchema$1 extends CallApiSchema = CallApiSchema, TBaseSchemaConfig extends CallApiSchemaConfig = CallApiSchemaConfig, TSchemaConfig$1 extends CallApiSchemaConfig = CallApiSchemaConfig, TCurrentRouteSchemaKey extends string = string, TComputedPluginContext = InferExtendPluginContext<TBasePluginArray>, TComputedSchemaContext = InferExtendSchemaContext<TBaseSchemaRoutes$1, TCurrentRouteSchemaKey>, TComputedSchemaConfigContext = InferExtendSchemaConfigContext<TBaseSchemaConfig>> = SharedExtraOptions<TCallApiContext, TData$1, TErrorData$1, TResultMode, TThrowOnError, TResponseType, TPluginArray> & {
+  onValidationError?: (context: ValidationErrorContext<TCallApiContext$1>) => Awaitable<unknown>;
+}
+type HooksOrHooksArray<TCallApiContext$1 extends CallApiContext = DefaultCallApiContext, TData$1 = TCallApiContext$1["Data"], TErrorData$1 = TCallApiContext$1["ErrorData"]> = { [Key in keyof Hooks<TCallApiContext$1, TData$1, TErrorData$1>]: Hooks<TCallApiContext$1, TData$1, TErrorData$1>[Key] | Array<Hooks<TCallApiContext$1, TData$1, TErrorData$1>[Key]> };
+interface HookConfigOptions {
   /**
-   * Array of instance-specific CallApi plugins or a function to configure plugins.
+   * Controls the execution mode of all composed hooks (main + plugin hooks).
    *
-   * Instance plugins are added to the base plugins and provide functionality
-   * specific to this particular API instance. Can be a static array or a function
-   * that receives base plugins and returns the instance plugins.
+   * - **"parallel"**: All hooks execute simultaneously via Promise.all() for better performance
+   * - **"sequential"**: All hooks execute one by one in registration order via await in a loop
    *
+   * This affects how ALL hooks execute together, regardless of their source (main or plugin).
+   *
+   * @default "parallel"
    */
-  plugins?: TPluginArray | ((context: TComputedPluginContext) => TPluginArray);
+  hooksExecutionMode?: "parallel" | "sequential";
+}
+type RequestContext<TCallApiContext$1 extends Pick<CallApiContext, "InferredPluginOptions" | "Meta"> = DefaultCallApiContext> = {
   /**
-   * For instance-specific validation schemas
-   *
-   * Defines validation rules specific to this API instance, extending or overriding the base schema.
+   * Base configuration object passed to createFetchClient.
    *
-   * Can be a static schema object or a function that receives base schema context and returns instance schemas.
+   * Contains the foundational configuration that applies to all requests
+   * made by this client instance, such as baseURL, default headers, and
+   * global options.
+   */
+  baseConfig: Exclude<BaseCallApiConfig, AnyFunction$1>;
+  /**
+   * Instance-specific configuration object passed to the callApi instance.
    *
+   * Contains configuration specific to this particular API call, which
+   * can override or extend the base configuration.
    */
-  schema?: TSchema$1 | ((context: TComputedSchemaContext) => TSchema$1);
+  config: CallApiConfig;
   /**
-   * Instance-specific schema configuration or a function to configure schema behavior.
+   * Merged options combining base config, instance config, and default options.
    *
-   * Controls how validation schemas are applied and behave for this specific API instance.
-   * Can override base schema configuration or extend it with instance-specific validation rules.
+   * This is the final resolved configuration that will be used for the request,
+   * with proper precedence applied (instance > base > defaults).
+   */
+  options: CallApiExtraOptionsForHooks<TCallApiContext$1>;
+  /**
+   * Merged request object ready to be sent.
    *
+   * Contains the final request configuration including URL, method, headers,
+   * body, and other fetch options. This object can be modified in onRequest
+   * hooks to customize the outgoing request.
    */
-  schemaConfig?: TSchemaConfig$1 | ((context: TComputedSchemaConfigContext) => TSchemaConfig$1);
+  request: CallApiRequestOptionsForHooks;
 };
-type CallApiExtraOptionsForHooks<TCallApiContext extends CallApiContext = CallApiContext> = Hooks & Omit<CallApiExtraOptions<TCallApiContext>, keyof Hooks>;
-type InstanceContext = {
+type ValidationErrorContext<TCallApiContext$1 extends Pick<CallApiContext, "InferredPluginOptions" | "Meta"> = DefaultCallApiContext> = UnmaskType<RequestContext<TCallApiContext$1> & {
+  error: PossibleValidationError;
+  response: Response | null;
+}>;
+type SuccessContext<TCallApiContext$1 extends Pick<CallApiContext, "Data" | "InferredPluginOptions" | "Meta"> = DefaultCallApiContext, TData$1 = TCallApiContext$1["Data"]> = UnmaskType<RequestContext<TCallApiContext$1> & {
+  data: NoInfer<TData$1>;
+  response: Response;
+}>;
+type ResponseContext<TCallApiContext$1 extends Pick<CallApiContext, "Data" | "ErrorData" | "InferredPluginOptions" | "Meta"> = DefaultCallApiContext, TData$1 = TCallApiContext$1["Data"], TErrorData$1 = TCallApiContext$1["ErrorData"]> = UnmaskType<RequestContext<TCallApiContext$1> & (Prettify<CallApiResultSuccessVariant<TData$1>> | Prettify<Extract<CallApiResultErrorVariant<TErrorData$1>, {
+  error: PossibleHTTPError<TErrorData$1>;
+}>>)>;
+type RequestErrorContext<TCallApiContext$1 extends Pick<CallApiContext, "InferredPluginOptions" | "Meta"> = DefaultCallApiContext> = RequestContext<TCallApiContext$1> & {
+  error: PossibleJavaScriptError;
+  response: null;
+};
+type ErrorContext<TCallApiContext$1 extends Pick<CallApiContext, "ErrorData" | "InferredPluginOptions" | "Meta"> = DefaultCallApiContext, TErrorData$1 = TCallApiContext$1["ErrorData"]> = UnmaskType<RequestContext<TCallApiContext$1> & ({
+  error: PossibleHTTPError<TErrorData$1>;
+  response: Response;
+} | {
+  error: PossibleJavaScriptOrValidationError;
+  response: Response | null;
+})>;
+type ResponseErrorContext<TCallApiContext$1 extends Pick<CallApiContext, "ErrorData" | "InferredPluginOptions" | "Meta"> = DefaultCallApiContext, TErrorData$1 = TCallApiContext$1["ErrorData"]> = UnmaskType<Extract<ErrorContext<TCallApiContext$1, TErrorData$1>, {
+  error: PossibleHTTPError<TErrorData$1>;
+}> & RequestContext<TCallApiContext$1>>;
+type RetryContext<TCallApiContext$1 extends Pick<CallApiContext, "ErrorData" | "InferredPluginOptions" | "Meta"> = DefaultCallApiContext, TErrorData$1 = TCallApiContext$1["ErrorData"]> = UnmaskType<ErrorContext<TCallApiContext$1, TErrorData$1> & {
+  retryAttemptCount: number;
+}>;
+type RequestStreamContext<TCallApiContext$1 extends Pick<CallApiContext, "InferredPluginOptions" | "Meta"> = DefaultCallApiContext> = UnmaskType<RequestContext<TCallApiContext$1> & {
+  event: StreamProgressEvent;
+  requestInstance: Request;
+}>;
+type ResponseStreamContext<TCallApiContext$1 extends Pick<CallApiContext, "InferredPluginOptions" | "Meta"> = DefaultCallApiContext> = UnmaskType<RequestContext<TCallApiContext$1> & {
+  event: StreamProgressEvent;
+  response: Response;
+}>;
+//#endregion
+//#region src/plugins.d.ts
+type PluginSetupContext<TCallApiContext$1 extends CallApiContext = DefaultCallApiContext> = RequestContext<TCallApiContext$1> & {
   initURL: string;
-  options: CallApiExtraOptions;
+};
+type PluginInitResult = Partial<Omit<PluginSetupContext, "initURL" | "request"> & {
+  initURL: InitURLOrURLObject;
   request: CallApiRequestOptions;
+}>;
+type PluginHooks<TCallApiContext$1 extends CallApiContext = DefaultCallApiContext, TData$1 = (unknown extends TCallApiContext$1["Data"] ? never : TCallApiContext$1["Data"]), TErrorData$1 = (unknown extends TCallApiContext$1["ErrorData"] ? never : TCallApiContext$1["ErrorData"])> = HooksOrHooksArray<TCallApiContext$1, TData$1, TErrorData$1>;
+interface CallApiPlugin {
+  /**
+   * Defines additional options that can be passed to callApi
+   */
+  defineExtraOptions?: (...params: never[]) => unknown;
+  /**
+   * A description for the plugin
+   */
+  description?: string;
+  /**
+   * Hooks for the plugin
+   */
+  hooks?: PluginHooks | ((context: PluginSetupContext) => Awaitable<PluginHooks>);
+  /**
+   *  A unique id for the plugin
+   */
+  id: string;
+  /**
+   * Middlewares that for the plugin
+   */
+  middlewares?: Middlewares | ((context: PluginSetupContext) => Awaitable<Middlewares>);
+  /**
+   * A name for the plugin
+   */
+  name: string;
+  /**
+   * Base schema for the client.
+   */
+  schema?: BaseCallApiSchemaAndConfig;
+  /**
+   * A function that will be called when the plugin is initialized. This will be called before the any of the other internal functions.
+   */
+  setup?: (context: PluginSetupContext) => Awaitable<PluginInitResult> | Awaitable<void>;
+  /**
+   *  A version for the plugin
+   */
+  version?: string;
+}
+//#endregion
+//#region src/types/default-types.d.ts
+type DefaultDataType = unknown;
+type DefaultPluginArray = CallApiPlugin[];
+type DefaultThrowOnError = boolean;
+type DefaultMetaObject = Record<string, unknown>;
+type DefaultCallApiContext = Omit<Required<CallApiContext>, "Meta"> & {
+  Meta: GlobalMeta;
 };
-type BaseCallApiConfig<TBaseCallApiContext extends CallApiContext = CallApiContext, TBaseData = DefaultDataType, TBaseErrorData = DefaultDataType, TBaseResultMode extends ResultModeType = ResultModeType, TBaseThrowOnError extends ThrowOnErrorUnion = DefaultThrowOnError, TBaseResponseType extends ResponseTypeType = ResponseTypeType, TBaseSchemaAndConfig extends BaseCallApiSchemaAndConfig = BaseCallApiSchemaAndConfig, TBasePluginArray extends CallApiPlugin[] = DefaultPluginArray, TComputedBaseConfig = BaseCallApiExtraOptions<TBaseCallApiContext, TBaseData, TBaseErrorData, TBaseResultMode, TBaseThrowOnError, TBaseResponseType, TBasePluginArray, TBaseSchemaAndConfig>> = (CallApiRequestOptions & TComputedBaseConfig) | ((context: InstanceContext) => CallApiRequestOptions & TComputedBaseConfig);
-type CallApiConfig<TCallApiContext extends CallApiContext = CallApiContext, TData$1 = DefaultDataType, TErrorData$1 = DefaultDataType, TResultMode extends ResultModeType = ResultModeType, TThrowOnError extends ThrowOnErrorUnion = DefaultThrowOnError, TResponseType extends ResponseTypeType = ResponseTypeType, TBaseSchemaRoutes$1 extends BaseCallApiSchemaRoutes = BaseCallApiSchemaRoutes, TSchema$1 extends CallApiSchema = CallApiSchema, TBaseSchemaConfig extends CallApiSchemaConfig = CallApiSchemaConfig, TSchemaConfig$1 extends CallApiSchemaConfig = CallApiSchemaConfig, TInitURL extends InitURLOrURLObject = InitURLOrURLObject, TCurrentRouteSchemaKey extends string = string, TBasePluginArray extends CallApiPlugin[] = DefaultPluginArray, TPluginArray extends CallApiPlugin[] = DefaultPluginArray> = InferExtraOptions<TSchema$1, TBaseSchemaRoutes$1, TCurrentRouteSchemaKey, TCallApiContext> & InferRequestOptions<TSchema$1, TInitURL> & Omit<CallApiExtraOptions<TCallApiContext, TData$1, TErrorData$1, TResultMode, TThrowOnError, TResponseType, TBasePluginArray, TPluginArray, TBaseSchemaRoutes$1, TSchema$1, TBaseSchemaConfig, TSchemaConfig$1, TCurrentRouteSchemaKey>, keyof InferExtraOptions<CallApiSchema, BaseCallApiSchemaRoutes, string, CallApiContext>> & Omit<CallApiRequestOptions, keyof InferRequestOptions<CallApiSchema, string>>;
 //#endregion
 //#region src/validation.d.ts
 type ResultVariant = "infer-input" | "infer-output";
@@ -1823,6 +1772,7 @@ type BaseCallApiSchemaAndConfig = {
   routes: BaseCallApiSchemaRoutes;
 };
 //#endregion
+//#region src/createFetchClient.d.ts
 //#endregion
 //#region src/logger/logger.d.ts
 type ConsoleLikeObject = {
@@ -1862,12 +1812,12 @@ declare const loggerPlugin: (options?: LoggerOptions) => {
   name: "Logger";
   version: "1.1.0";
   hooks: {
-    onRequest: (ctx: RequestContext & PluginExtraOptions<unknown>) => void;
-    onRequestError: (ctx: RequestContext & {
+    onRequest: (ctx: RequestContext<DefaultCallApiContext>) => void;
+    onRequestError: (ctx: RequestContext<DefaultCallApiContext> & {
       error: PossibleJavaScriptError;
       response: null;
-    } & PluginExtraOptions<unknown>) => void;
-    onResponseError: (ctx: RequestContext & {
+    }) => void;
+    onResponseError: (ctx: RequestContext<DefaultCallApiContext> & {
       error: {
         errorData: never;
         message: string;
@@ -1875,8 +1825,8 @@ declare const loggerPlugin: (options?: LoggerOptions) => {
         originalError: _zayne_labs_callapi_utils0.HTTPError;
       };
       response: Response;
-    } & PluginExtraOptions<unknown>) => void;
-    onRetry: (ctx: ((RequestContext & ({
+    }) => void;
+    onRetry: (ctx: (RequestContext<DefaultCallApiContext> & ({
       error: PossibleJavaScriptOrValidationError;
       response: Response | null;
     } | {
@@ -1889,15 +1839,15 @@ declare const loggerPlugin: (options?: LoggerOptions) => {
       response: Response;
     })) & {
       retryAttemptCount: number;
-    }) & PluginExtraOptions<unknown>) => void;
-    onSuccess: (ctx: RequestContext & {
+    }) => void;
+    onSuccess: (ctx: RequestContext<DefaultCallApiContext> & {
       data: never;
       response: Response;
-    } & PluginExtraOptions<unknown>) => void;
-    onValidationError: (ctx: RequestContext & {
+    }) => void;
+    onValidationError: (ctx: RequestContext<DefaultCallApiContext> & {
       error: PossibleValidationError;
       response: Response | null;
-    } & PluginExtraOptions<unknown>) => void;
+    }) => void;
   };
 };
 //#endregion