@zayne-labs/callapi 1.11.25 → 1.11.27

package/dist/{validation-BXtphXvQ.d.ts → index-HHFgKKcn.d.ts}

@@ -65,288 +65,221 @@ type CustomAuth = {
 };
 type Auth = PossibleAuthValueOrGetter | BearerOrTokenAuth | BasicAuth | CustomAuth;
 //#endregion
-//#region src/utils/external/body.d.ts
-type ToQueryStringFn = {
-  (query: CallApiExtraOptions["query"]): string | null;
-  (query: Required<CallApiExtraOptions>["query"]): string;
-};
-declare const toQueryString: ToQueryStringFn;
-type AllowedPrimitives = boolean | number | string | Blob;
-type AllowedValues = AllowedPrimitives | AllowedPrimitives[] | Record<string, AllowedPrimitives>;
-type ToFormDataFn = {
-  (data: Record<string, AllowedValues>): FormData;
-  <TData extends Record<string, AllowedValues>>(data: TData, options: {
-    returnType: "inputType";
-  }): TData;
-};
-/**
- * @description Converts a plain object to FormData.
- *
- * Handles various data types:
- * - **Primitives** (string, number, boolean): Converted to strings
- * - **Blobs/Files**: Added directly to FormData
- * - **Arrays**: Each item is appended (allows multiple values for same key)
- * - **Objects**: JSON stringified before adding to FormData
- *
- * @example
- * ```ts
- * // Basic usage
- * const formData = toFormData({
- *   name: "John",
- *   age: 30,
- *   active: true
- * });
- *
- * // With arrays
- * const formData = toFormData({
- *   tags: ["javascript", "typescript"],
- *   name: "John"
- * });
- *
- * // With files
- * const formData = toFormData({
- *   avatar: fileBlob,
- *   name: "John"
- * });
- *
- * // With nested objects (one level only)
- * const formData = toFormData({
- *   user: { name: "John", age: 30 },
- *   settings: { theme: "dark" }
- * });
- *
- * // Type-preserving usage with Zod
- * const schema = z.object({ name: z.string(), file: z.instanceof(Blob) });
- * const data = schema.parse({ name: "John", file: blob });
- * const typedFormData = toFormData(data, { returnType: "inputType" });
- * // Type is { name: string; file: Blob }, runtime is FormData
- * ```
- */
-declare const toFormData: ToFormDataFn;
-//#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
+   * 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"
    */
-  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">;
+  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;
-type GetCallApiResult<TData$1, TErrorData$1, TResultMode extends ResultModeType, TThrowOnError extends ThrowOnErrorUnion, TResponseType extends ResponseTypeType, TComputedResultModeMapWithException extends ResultModeMapWithException<TData$1, TResponseType> = ResultModeMapWithException<TData$1, TResponseType>, TComputedResultModeMap extends ResultModeMap<TData$1, TErrorData$1, TResponseType, TThrowOnError> = ResultModeMap<TData$1, TErrorData$1, TResponseType, TThrowOnError>> = TErrorData$1 extends false ? TComputedResultModeMapWithException["onlyData"] : TErrorData$1 extends false | undefined ? TComputedResultModeMapWithException["onlyData"] : ResultModePlaceholder extends TResultMode ? TComputedResultModeMap["all"] : TResultMode extends ResultModeUnion ? TComputedResultModeMap[TResultMode] : never;
 //#endregion
 //#region src/middlewares.d.ts
 type FetchImpl = UnmaskType<(input: string | Request | URL, init?: RequestInit) => Promise<Response>>;
@@ -507,585 +440,335 @@ interface URLOptions {
   query?: Query;
 }
 //#endregion
-//#region src/plugins.d.ts
-type PluginSetupContext<TPluginExtraOptions = unknown> = RequestContext & PluginExtraOptions<TPluginExtraOptions> & {
-  initURL: string;
-};
-type PluginInitResult = Partial<Omit<PluginSetupContext, "initURL" | "request"> & {
-  initURL: InitURLOrURLObject;
-  request: CallApiRequestOptions;
-}>;
-type PluginHooksWithMoreOptions<TMoreOptions = unknown> = HooksOrHooksArray<never, never, TMoreOptions>;
-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
-declare const defineSchema: <const TBaseSchemaRoutes extends BaseCallApiSchemaRoutes, const TSchemaConfig extends CallApiSchemaConfig>(routes: TBaseSchemaRoutes, config?: Satisfies<TSchemaConfig, CallApiSchemaConfig>) => {
-  config: Writeable<Satisfies<TSchemaConfig, CallApiSchemaConfig>, "deep">;
-  routes: Writeable<TBaseSchemaRoutes, "deep">;
-};
-declare const defineSchemaRoutes: <const TSchemaRoutes extends BaseCallApiSchemaRoutes>(routes: TSchemaRoutes) => Writeable<typeof routes, "deep">;
-declare const defineMainSchema: <const TSchema extends CallApiSchema>(mainSchema: Satisfies<TSchema, CallApiSchema>) => Writeable<typeof mainSchema, "deep">;
-declare const defineSchemaConfig: <const TSchemaConfig extends CallApiSchemaConfig>(config: Satisfies<TSchemaConfig, CallApiSchemaConfig>) => Writeable<typeof config, "deep">;
-declare const definePlugin: <const TPlugin extends CallApiPlugin>(plugin: TPlugin) => Writeable<typeof plugin, "deep">;
-type BaseConfigObject = Exclude<BaseCallApiConfig, AnyFunction>;
-type BaseConfigFn = Extract<BaseCallApiConfig, AnyFunction>;
-type DefineBaseConfig = {
-  <const TBaseConfig extends BaseConfigObject>(baseConfig: Satisfies<TBaseConfig, BaseConfigObject>): Writeable<typeof baseConfig, "deep">;
-  <TBaseConfigFn extends BaseConfigFn>(baseConfig: TBaseConfigFn): TBaseConfigFn;
-};
-declare const defineBaseConfig: DefineBaseConfig;
-//#endregion
-//#region src/utils/external/guards.d.ts
-declare const isHTTPError: <TErrorData>(error: CallApiResultErrorVariant<TErrorData>["error"] | null) => error is PossibleHTTPError<TErrorData>;
-declare const isHTTPErrorInstance: <TErrorData>(error: unknown) => error is HTTPError<TErrorData>;
-declare const isValidationError: (error: CallApiResultErrorVariant<unknown>["error"] | null) => error is PossibleValidationError;
-declare const isValidationErrorInstance: (error: unknown) => error is ValidationError;
-declare const isJavascriptError: (error: CallApiResultErrorVariant<unknown>["error"] | null) => error is PossibleJavaScriptError;
-//#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>;
-  /**
-   * 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
-   *
-   */
-  onRequestStream?: (context: RequestStreamContext & PluginExtraOptions<TPluginOptions>) => Awaitable<unknown>;
-  /**
-   * 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
-   *
-   */
-  onResponse?: (context: ResponseContext<TData$1, TErrorData$1> & PluginExtraOptions<TPluginOptions>) => Awaitable<unknown>;
-  /**
-   * 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
-   */
-  onResponseError?: (context: ResponseErrorContext<TErrorData$1> & PluginExtraOptions<TPluginOptions>) => Awaitable<unknown>;
-  /**
-   * Hook called during download stream progress tracking.
-   *
-   * 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.
-   *
-   * @param context - Response stream context with progress event and response
-   * @returns Promise or void - Hook can be async or sync
-   *
-   */
-  onResponseStream?: (context: ResponseStreamContext & PluginExtraOptions<TPluginOptions>) => Awaitable<unknown>;
-  /**
-   * 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
-   *
+//#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 GetCurrentRouteSchemaKey<TSchemaConfig$1 extends CallApiSchemaConfig, TPath> = TPath extends URL ? string : TSchemaConfig$1["baseURL"] extends string ? TPath extends `${TSchemaConfig$1["baseURL"]}${infer TCurrentRoute}` ? TCurrentRoute extends string ? TCurrentRoute : string : TPath extends `${TSchemaConfig$1["prefix"]}${infer TCurrentRoute}` ? TCurrentRoute extends string ? TCurrentRoute : string : string : TPath;
+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"], {
+  /**
+   * Body of the request, can be a object or any other supported body type.
    */
-  onRetry?: (response: RetryContext<TErrorData$1> & 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 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
-   *
+   * HTTP method for the request.
+   * @default "GET"
    */
-  onSuccess?: (context: SuccessContext<TData$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 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
-   *
+   * Headers to be used in the request.
    */
-  onValidationError?: (context: ValidationErrorContext & PluginExtraOptions<TPluginOptions>) => Awaitable<unknown>;
-}
-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 {
+  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"], {
   /**
-   * 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).
+   * - An optional field you can fill with additional information,
+   * to associate with the request, typically used for logging or tracing.
    *
-   * @default "parallel"
+   * - A good use case for this, would be to use the info to handle specific cases in any of the shared interceptors.
    *
    * @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);
-   *   }
+   * 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`);
+   * 		}
+   * 	},
    * });
    *
-   * // 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
-   *   ]
+   * const response = await callMainApi({
+   * 	url: "https://example.com/api/data",
+   * 	meta: { userId: "123" },
    * });
    * ```
    */
-  hooksExecutionMode?: "parallel" | "sequential";
+  meta?: InferSchemaOutput<TSchema$1["meta"], TCallApiContext$1["Meta"]>;
+}>;
+type InferQueryOption<TSchema$1 extends CallApiSchema> = MakeSchemaOptionRequiredIfDefined<TSchema$1["query"], {
+  /**
+   * Parameters to be appended to the URL (i.e: /:id)
+   */
+  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, {
+  /**
+   * Parameters to be appended to the URL (i.e: /:id)
+   */
+  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<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> {
+  /**
+   * The Standard Schema properties.
+   */
+  readonly "~standard": StandardSchemaV1.Props<Input$1, Output$1>;
 }
-type RequestContext = {
+declare namespace StandardSchemaV1 {
   /**
-   * 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 Standard Schema properties interface.
    */
-  baseConfig: Exclude<BaseCallApiConfig, AnyFunction>;
+  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;
+  }
   /**
-   * 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 of the validate function.
    */
-  config: CallApiConfig;
+  type Result<Output> = FailureResult | SuccessResult<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 succeeds.
+   */
+  interface SuccessResult<Output> {
+    /**
+     * The non-existent issues.
+     */
+    readonly issues?: undefined;
+    /**
+     * The typed output value.
+     */
+    readonly value: Output;
+  }
+  /**
+   * 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 */
+  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;
-}>;
-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 = {
+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);
   /**
-   * All dedupe options in a single object instead of separate properties
+   * @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
    */
-  dedupe?: InnerDedupeOptions;
+  static isError<TErrorData>(error: unknown): error is HTTPError<TErrorData$1>;
+}
+type SafeExtract<TUnion, TKey extends TUnion> = Extract<TUnion, TKey>;
+type ValidationErrorDetails = {
   /**
-   * 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
-   * ```
+   * The cause of the validation error.
    *
-   * @default "local"
+   * 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.
    */
-  dedupeCacheScope?: "global" | "local";
+  issueCause: "unknown" | `schemaConfig-(${SafeExtract<keyof CallApiSchemaConfig, "strict">})` | keyof CallApiSchema;
   /**
-   * 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"
+   * The issues that caused the validation error.
    */
-  dedupeCacheScopeKey?: "default" | AnyString | ((context: RequestContext) => string | undefined);
+  issues: readonly StandardSchemaV1.Issue[];
   /**
-   * 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
+   * The response from server, if any.
    */
-  dedupeKey?: string | ((context: RequestContext) => string | undefined);
+  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);
   /**
-   * 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"
+   * @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
    */
-  dedupeStrategy?: DedupeStrategyUnion | ((context: RequestContext) => DedupeStrategyUnion);
+  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;
+type GetCallApiResult<TData$1, TErrorData$1, TResultMode$1 extends ResultModeType, TThrowOnError$1 extends ThrowOnErrorUnion, TResponseType$1 extends ResponseTypeType, TComputedResultModeMapWithException extends ResultModeMapWithException<TData$1, TResponseType$1> = ResultModeMapWithException<TData$1, TResponseType$1>, TComputedResultModeMap extends ResultModeMap<TData$1, TErrorData$1, TResponseType$1, TThrowOnError$1> = ResultModeMap<TData$1, TErrorData$1, TResponseType$1, TThrowOnError$1>> = TErrorData$1 extends false ? TComputedResultModeMapWithException["onlyData"] : TErrorData$1 extends false | undefined ? TComputedResultModeMapWithException["onlyData"] : ResultModePlaceholder extends TResultMode$1 ? TComputedResultModeMap["all"] : TResultMode$1 extends ResultModeUnion ? TComputedResultModeMap[TResultMode$1] : never;
 //#endregion
 //#region src/retry.d.ts
 declare const defaultRetryStatusCodesLookup: () => Readonly<{
@@ -1099,7 +782,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> {
@@ -1148,671 +833,940 @@ interface RetryOptions<TErrorData$1> {
   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 GetCurrentRouteSchemaKey<TSchemaConfig$1 extends CallApiSchemaConfig, TPath> = TPath extends URL ? string : TSchemaConfig$1["baseURL"] extends string ? TPath extends `${TSchemaConfig$1["baseURL"]}${infer TCurrentRoute}` ? TCurrentRoute extends string ? TCurrentRoute : string : TPath extends `${TSchemaConfig$1["prefix"]}${infer TCurrentRoute}` ? TCurrentRoute extends string ? TCurrentRoute : string : string : TPath;
-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"], {
+//#region src/types/common.d.ts
+interface Register {}
+type GlobalMeta = Register extends {
+  meta?: infer TMeta extends DefaultMetaObject;
+} ? TMeta : DefaultMetaObject;
+type CallApiContext = {
+  Data?: DefaultDataType;
+  ErrorData?: DefaultDataType;
+  InferredPluginOptions?: unknown;
+  Meta?: DefaultMetaObject;
+  ResultMode?: ResultModeType;
+};
+type FetchSpecificKeysUnion = Exclude<(typeof fetchSpecificKeys)[number], "body" | "headers" | "method">;
+type ModifiedRequestInit = RequestInit & {
+  duplex?: "half";
+};
+type CallApiRequestOptions = Prettify<{
   /**
    * 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"], {
+  body?: Body;
+  /**
+   * Headers to be used in the request.
+   */
+  headers?: HeadersOption;
   /**
    * 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"], {
+  method?: MethodUnion;
+} & Pick<ModifiedRequestInit, FetchSpecificKeysUnion>>;
+type CallApiRequestOptionsForHooks = Omit<CallApiRequestOptions, "headers"> & {
+  headers: Record<string, string | undefined>;
+};
+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 & {
   /**
-   * Headers to be used in the request.
+   * Automatically add an Authorization header value.
+   *
+   * Supports multiple authentication patterns:
+   * - String: Direct authorization header value
+   * - Auth object: Structured authentication configuration
+   *
+   * ```
+   */
+  auth?: Auth;
+  /**
+   * Custom function to serialize request body objects into strings.
+   *
+   * Useful for custom serialization formats or when the default JSON
+   * serialization doesn't meet your needs.
+   *
+   * @example
+   * ```ts
+   * // Custom form data serialization
+   * bodySerializer: (data) => {
+   *   const formData = new URLSearchParams();
+   *   Object.entries(data).forEach(([key, value]) => {
+   *     formData.append(key, String(value));
+   *   });
+   *   return formData.toString();
+   * }
+   *
+   * // XML serialization
+   * bodySerializer: (data) => {
+   *   return `<request>${Object.entries(data)
+   *     .map(([key, value]) => `<${key}>${value}</${key}>`)
+   *     .join('')}</request>`;
+   * }
+   *
+   * // Custom JSON with specific formatting
+   * bodySerializer: (data) => JSON.stringify(data, null, 2)
+   * ```
+   */
+  bodySerializer?: (bodyData: Record<string, unknown>) => string;
+  /**
+   * Whether to clone the response so it can be read multiple times.
+   *
+   * By default, response streams can only be consumed once. Enable this when you need
+   * to read the response in multiple places (e.g., in hooks and main code).
+   *
+   * @see https://developer.mozilla.org/en-US/docs/Web/API/Response/clone
+   * @default false
+   */
+  cloneResponse?: boolean;
+  /**
+   * Custom fetch implementation to replace the default fetch function.
+   *
+   * Useful for testing, adding custom behavior, or using alternative HTTP clients
+   * that implement the fetch API interface.
+   *
+   * @example
+   * ```ts
+   * // Use node-fetch in Node.js environments
+   * import fetch from 'node-fetch';
+   *
+   * // Mock fetch for testing
+   * customFetchImpl: async (url, init) => {
+   *   return new Response(JSON.stringify({ mocked: true }), {
+   *     status: 200,
+   *     headers: { 'Content-Type': 'application/json' }
+   *   });
+   * }
+   *
+   * // Add custom logging to all requests
+   * customFetchImpl: async (url, init) => {
+   *   console.log(`Fetching: ${url}`);
+   *   const response = await fetch(url, init);
+   *   console.log(`Response: ${response.status}`);
+   *   return response;
+   * }
+   *
+   * // Use with custom HTTP client
+   * customFetchImpl: async (url, init) => {
+   *   // Convert to your preferred HTTP client format
+   *   return await customHttpClient.request({
+   *     url: url.toString(),
+   *     method: init?.method || 'GET',
+   *     headers: init?.headers,
+   *     body: init?.body
+   *   });
+   * }
+   * ```
+   */
+  customFetchImpl?: FetchImpl;
+  /**
+   * Default HTTP error message when server doesn't provide one.
+   *
+   * Can be a static string or a function that receives error context
+   * to generate dynamic error messages based on the response.
+   *
+   * @default "Failed to fetch data from server!"
+   *
+   * @example
+   * ```ts
+   * // Static error message
+   * defaultHTTPErrorMessage: "API request failed. Please try again."
+   *
+   * // Dynamic error message based on status code
+   * defaultHTTPErrorMessage: ({ response }) => {
+   *   switch (response.status) {
+   *     case 401: return "Authentication required. Please log in.";
+   *     case 403: return "Access denied. Insufficient permissions.";
+   *     case 404: return "Resource not found.";
+   *     case 429: return "Too many requests. Please wait and try again.";
+   *     case 500: return "Server error. Please contact support.";
+   *     default: return `Request failed with status ${response.status}`;
+   *   }
+   * }
+   *
+   * // Include error data in message
+   * defaultHTTPErrorMessage: ({ errorData, response }) => {
+   *   const userMessage = errorData?.message || "Unknown error occurred";
+   *   return `${userMessage} (Status: ${response.status})`;
+   * }
+   * ```
+   */
+  defaultHTTPErrorMessage?: string | ((context: Pick<HTTPError<TErrorData$1>, "errorData" | "response">) => string);
+  /**
+   * Forces calculation of total byte size from request/response body streams.
+   *
+   * Useful when the Content-Length header is missing or incorrect, and you need
+   * accurate size information for progress tracking or bandwidth monitoring.
+   *
+   * @default false
+   *
+   */
+  forcefullyCalculateStreamSize?: boolean | {
+    request?: boolean;
+    response?: boolean;
+  };
+  /**
+   * Optional metadata field for associating additional information with requests.
+   *
+   * Useful for logging, tracing, or handling specific cases in shared interceptors.
+   * The meta object is passed through to all hooks and can be accessed in error handlers.
+   *
+   * @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" },
+   * });
+   *
+   * // Use case: Request tracking
+   * const result = await callMainApi({
+   *   url: "https://example.com/api/data",
+   *   meta: {
+   *     requestId: generateId(),
+   *     source: "user-dashboard",
+   *     priority: "high"
+   *   }
+   * });
+   *
+   * // Use case: Feature flags
+   * const client = callApi.create({
+   *   baseURL: "https://api.example.com",
+   *   meta: {
+   *     features: ["newUI", "betaFeature"],
+   *     experiment: "variantA"
+   *   }
+   * });
+   * ```
+   */
+  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().
+   *
+   * Useful when you need custom parsing logic for specific response formats.
+   *
+   * @example
+   * ```ts
+   * responseParser: (responseString) => {
+   *   return JSON.parse(responseString);
+   * }
+   *
+   * // Parse XML responses
+   * responseParser: (responseString) => {
+   *   const parser = new DOMParser();
+   *   const doc = parser.parseFromString(responseString, "text/xml");
+   *   return xmlToObject(doc);
+   * }
+   *
+   * // Parse CSV responses
+   * responseParser: (responseString) => {
+   *   const lines = responseString.split('\n');
+   *   const headers = lines[0].split(',');
+   *   const data = lines.slice(1).map(line => {
+   *     const values = line.split(',');
+   *     return headers.reduce((obj, header, index) => {
+   *       obj[header] = values[index];
+   *       return obj;
+   *     }, {});
+   *   });
+   *   return data;
+   * }
+   *
+   * ```
    */
-  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>;
-interface Register {}
-type GlobalMeta = Register extends {
-  meta?: infer TMeta extends Record<string, unknown>;
-} ? TMeta : never;
-type InferMetaOption<TSchema$1 extends CallApiSchema, TCallApiEnv extends CallApiEnv> = MakeSchemaOptionRequiredIfDefined<TSchema$1["meta"], {
+  responseParser?: (responseString: string) => Awaitable<TData$1>;
   /**
-   * - An optional field you can fill with additional information,
-   * to associate with the request, typically used for logging or tracing.
+   * Expected response type, determines how the response body is parsed.
    *
-   * - A good use case for this, would be to use the info to handle specific cases in any of the shared interceptors.
+   * Different response types trigger different parsing methods:
+   * - **"json"**: Parses as JSON using response.json()
+   * - **"text"**: Returns as plain text using response.text()
+   * - **"blob"**: Returns as Blob using response.blob()
+   * - **"arrayBuffer"**: Returns as ArrayBuffer using response.arrayBuffer()
+   * - **"stream"**: Returns the response body stream directly
+   *
+   * @default "json"
    *
    * @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`);
-   * 		}
-   * 	},
-   * });
+   * // JSON API responses (default)
+   * responseType: "json"
    *
-   * const response = await callMainApi({
-   * 	url: "https://example.com/api/data",
-   * 	meta: { userId: "123" },
-   * });
+   * // Plain text responses
+   * responseType: "text"
+   * // Usage: const csvData = await callApi("/export.csv", { responseType: "text" });
+   *
+   * // File downloads
+   * responseType: "blob"
+   * // Usage: const file = await callApi("/download/file.pdf", { responseType: "blob" });
+   *
+   * // Binary data
+   * responseType: "arrayBuffer"
+   * // Usage: const buffer = await callApi("/binary-data", { responseType: "arrayBuffer" });
+   *
+   * // Streaming responses
+   * responseType: "stream"
+   * // Usage: const stream = await callApi("/large-dataset", { responseType: "stream" });
    * ```
    */
-  meta?: InferSchemaOutput<TSchema$1["meta"], TCallApiEnv["Meta"]>;
-}>;
-type InferQueryOption<TSchema$1 extends CallApiSchema> = MakeSchemaOptionRequiredIfDefined<TSchema$1["query"], {
-  /**
-   * Parameters to be appended to the URL (i.e: /:id)
-   */
-  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, {
-  /**
-   * Parameters to be appended to the URL (i.e: /:id)
-   */
-  params?: InferSchemaOutput<TSchema$1["params"], InferParamsFromRoute<TCurrentRouteSchemaKey>>;
-}>;
-type InferExtraOptions<TSchema$1 extends CallApiSchema, TBaseSchemaRoutes$1 extends BaseCallApiSchemaRoutes, TCurrentRouteSchemaKey extends string, TCallApiEnv extends CallApiEnv> = InferMetaOption<TSchema$1, TCallApiEnv> & 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<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>;
-};
-//#endregion
-//#region src/types/common.d.ts
-type BlankCallApiEnv = {};
-type CallApiEnv = {
-  Meta?: GlobalMeta;
-};
-type FetchSpecificKeysUnion = Exclude<(typeof fetchSpecificKeys)[number], "body" | "headers" | "method">;
-type ModifiedRequestInit = RequestInit & {
-  duplex?: "half";
-};
-type CallApiRequestOptions = Prettify<{
-  /**
-   * Body of the request, can be a object or any other supported body type.
-   */
-  body?: Body;
+  responseType?: TResponseType$1;
   /**
-   * Headers to be used in the request.
+   * Controls what data is included in the returned result object.
+   *
+   * Different modes return different combinations of data, error, and response:
+   * - **"all"**: Returns { data, error, response } - complete result information
+   * - **"onlyData"**: Returns only data (null for errors)
+   *
+   * When combined with throwOnError: true, null/error variants are automatically removed:
+   * - **"all" + throwOnError: true**: Returns { data, error: null, response } (error property is null, throws instead)
+   * - **"onlyData" + throwOnError: true**: Returns data (never null, throws on error)
+   *
+   * @default "all"
+   *
+   * @example
+   * ```ts
+   * // Complete result with all information (default)
+   * const { data, error, response } = await callApi("/users", { resultMode: "all" });
+   * if (error) {
+   *   console.error("Request failed:", error);
+   * } else {
+   *   console.log("Users:", data);
+   * }
+   *
+   * // Complete result but throws on errors (throwOnError removes error from type)
+   * try {
+   *   const { data, response } = await callApi("/users", {
+   *     resultMode: "all",
+   *     throwOnError: true
+   *   });
+   *   console.log("Users:", data); // data is never null here
+   * } catch (error) {
+   *   console.error("Request failed:", error);
+   * }
+   *
+   * // Only data, returns null on errors
+   * const users = await callApi("/users", { resultMode: "onlyData" });
+   * if (users) {
+   *   console.log("Users:", users);
+   * } else {
+   *   console.log("Request failed");
+   * }
+   *
+   * // Only data, throws on errors (throwOnError removes null from type)
+   * try {
+   *   const users = await callApi("/users", {
+   *     resultMode: "onlyData",
+   *     throwOnError: true
+   *   });
+   *   console.log("Users:", users); // users is never null here
+   * } catch (error) {
+   *   console.error("Request failed:", error);
+   * }
+   * ```
    */
-  headers?: HeadersOption;
+  resultMode?: TResultMode$1;
   /**
-   * HTTP method for the request.
-   * @default "GET"
+   * Controls whether errors are thrown as exceptions or returned in the result.
+   *
+   * Can be a boolean or a function that receives the error and decides whether to throw.
+   * When true, errors are thrown as exceptions instead of being returned in the result object.
+   *
+   * @default false
+   *
+   * @example
+   * ```ts
+   * // Always throw errors
+   * throwOnError: true
+   * try {
+   *   const data = await callApi("/users");
+   *   console.log("Users:", data);
+   * } catch (error) {
+   *   console.error("Request failed:", error);
+   * }
+   *
+   * // Never throw errors (default)
+   * throwOnError: false
+   * const { data, error } = await callApi("/users");
+   * if (error) {
+   *   console.error("Request failed:", error);
+   * }
+   *
+   * // Conditionally throw based on error type
+   * throwOnError: (error) => {
+   *   // Throw on client errors (4xx) but not server errors (5xx)
+   *   return error.response?.status >= 400 && error.response?.status < 500;
+   * }
+   *
+   * // Throw only on specific status codes
+   * throwOnError: (error) => {
+   *   const criticalErrors = [401, 403, 404];
+   *   return criticalErrors.includes(error.response?.status);
+   * }
+   *
+   * // Throw on validation errors but not network errors
+   * throwOnError: (error) => {
+   *   return error.type === "validation";
+   * }
+   * ```
    */
-  method?: MethodUnion;
-} & Pick<ModifiedRequestInit, FetchSpecificKeysUnion>>;
-type CallApiRequestOptionsForHooks = Omit<CallApiRequestOptions, "headers"> & {
-  headers: Record<string, string | undefined>;
-};
-type SharedExtraOptions<TData$1 = DefaultDataType, TErrorData$1 = DefaultDataType, TResultMode extends ResultModeType = ResultModeType, TCallApiEnv extends CallApiEnv = CallApiEnv, 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 & {
+  throwOnError?: ThrowOnErrorType<TErrorData$1, TThrowOnError$1>;
   /**
-   * Automatically add an Authorization header value.
+   * Request timeout in milliseconds. Request will be aborted if it takes longer.
    *
-   * Supports multiple authentication patterns:
-   * - String: Direct authorization header value
-   * - Auth object: Structured authentication configuration
+   * Useful for preventing requests from hanging indefinitely and providing
+   * better user experience with predictable response times.
+   *
+   * @example
+   * ```ts
+   * // 5 second timeout
+   * timeout: 5000
+   *
+   * // Different timeouts for different endpoints
+   * const quickApi = createFetchClient({ timeout: 3000 }); // 3s for fast endpoints
+   * const slowApi = createFetchClient({ timeout: 30000 }); // 30s for slow operations
+   *
+   * // Per-request timeout override
+   * await callApi("/quick-data", { timeout: 1000 });
+   * await callApi("/slow-report", { timeout: 60000 });
    *
+   * // No timeout (use with caution)
+   * timeout: 0
    * ```
    */
-  auth?: Auth;
+  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> & {
   /**
-   * Custom function to serialize request body objects into strings.
+   * Array of base CallApi plugins to extend library functionality.
    *
-   * Useful for custom serialization formats or when the default JSON
-   * serialization doesn't meet your needs.
+   * Base plugins are applied to all instances created from this base configuration
+   * and provide foundational functionality like authentication, logging, or caching.
    *
    * @example
    * ```ts
-   * // Custom form data serialization
-   * bodySerializer: (data) => {
-   *   const formData = new URLSearchParams();
-   *   Object.entries(data).forEach(([key, value]) => {
-   *     formData.append(key, String(value));
-   *   });
-   *   return formData.toString();
-   * }
+   * // Add logging plugin
+   *
+   * // Create base client with common plugins
+   * const callApi = createFetchClient({
+   *   baseURL: "https://api.example.com",
+   *   plugins: [loggerPlugin({ enabled: true })]
+   * });
    *
-   * // XML serialization
-   * bodySerializer: (data) => {
-   *   return `<request>${Object.entries(data)
-   *     .map(([key, value]) => `<${key}>${value}</${key}>`)
-   *     .join('')}</request>`;
-   * }
+   * // All requests inherit base plugins
+   * await callApi("/users");
+   * await callApi("/posts");
    *
-   * // Custom JSON with specific formatting
-   * bodySerializer: (data) => JSON.stringify(data, null, 2)
    * ```
    */
-  bodySerializer?: (bodyData: Record<string, unknown>) => string;
+  plugins?: TBasePluginArray$1;
   /**
-   * Whether to clone the response so it can be read multiple times.
-   *
-   * By default, response streams can only be consumed once. Enable this when you need
-   * to read the response in multiple places (e.g., in hooks and main code).
+   * Base validation schemas for the client configuration.
    *
-   * @see https://developer.mozilla.org/en-US/docs/Web/API/Response/clone
-   * @default false
+   * 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.
    */
-  cloneResponse?: boolean;
+  schema?: TBaseSchemaAndConfig$1;
   /**
-   * Custom fetch implementation to replace the default fetch function.
+   * Controls which configuration parts skip automatic merging between base and instance configs.
    *
-   * Useful for testing, adding custom behavior, or using alternative HTTP clients
-   * that implement the fetch API interface.
+   * 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
-   * // Use node-fetch in Node.js environments
-   * import fetch from 'node-fetch';
+   * // Skip all automatic merging - full manual control
+   * const client = callApi.create((ctx) => ({
+   *   skipAutoMergeFor: "all",
    *
-   * // Mock fetch for testing
-   * customFetchImpl: async (url, init) => {
-   *   return new Response(JSON.stringify({ mocked: true }), {
-   *     status: 200,
-   *     headers: { 'Content-Type': 'application/json' }
-   *   });
-   * }
+   *   // 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
+   *   }
+   * }));
    *
-   * // Add custom logging to all requests
-   * customFetchImpl: async (url, init) => {
-   *   console.log(`Fetching: ${url}`);
-   *   const response = await fetch(url, init);
-   *   console.log(`Response: ${response.status}`);
-   *   return response;
-   * }
+   * // Skip options merging - manual plugin/hook control
+   * const client = callApi.create((ctx) => ({
+   *   skipAutoMergeFor: "options",
    *
-   * // Use with custom HTTP client
-   * customFetchImpl: async (url, init) => {
-   *   // Convert to your preferred HTTP client format
-   *   return await customHttpClient.request({
-   *     url: url.toString(),
-   *     method: init?.method || 'GET',
-   *     headers: init?.headers,
-   *     body: init?.body
-   *   });
-   * }
+   *   // 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") || []
+   * }));
    * ```
    */
-  customFetchImpl?: FetchImpl;
+  skipAutoMergeFor?: "all" | "options" | "request";
+};
+type GetBaseSchemaRoutes<TBaseSchemaAndConfig$1 extends BaseCallApiSchemaAndConfig> = Writeable<TBaseSchemaAndConfig$1["routes"], "deep">;
+type GetBaseSchemaConfig<TBaseSchemaAndConfig$1 extends BaseCallApiSchemaAndConfig> = Writeable<NonNullable<TBaseSchemaAndConfig$1["config"]>, "deep">;
+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> & {
   /**
-   * Default HTTP error message when server doesn't provide one.
+   * Array of instance-specific CallApi plugins or a function to configure plugins.
    *
-   * Can be a static string or a function that receives error context
-   * to generate dynamic error messages based on the response.
+   * 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.
    *
-   * @default "Failed to fetch data from server!"
+   */
+  plugins?: TPluginArray$1 | ((context: TComputedPluginContext) => TPluginArray$1);
+  /**
+   * For instance-specific validation schemas
    *
-   * @example
-   * ```ts
-   * // Static error message
-   * defaultHTTPErrorMessage: "API request failed. Please try again."
+   * Defines validation rules specific to this API instance, extending or overriding the base schema.
    *
-   * // Dynamic error message based on status code
-   * defaultHTTPErrorMessage: ({ response }) => {
-   *   switch (response.status) {
-   *     case 401: return "Authentication required. Please log in.";
-   *     case 403: return "Access denied. Insufficient permissions.";
-   *     case 404: return "Resource not found.";
-   *     case 429: return "Too many requests. Please wait and try again.";
-   *     case 500: return "Server error. Please contact support.";
-   *     default: return `Request failed with status ${response.status}`;
-   *   }
-   * }
+   * Can be a static schema object or a function that receives base schema context and returns instance schemas.
    *
-   * // Include error data in message
-   * defaultHTTPErrorMessage: ({ errorData, response }) => {
-   *   const userMessage = errorData?.message || "Unknown error occurred";
-   *   return `${userMessage} (Status: ${response.status})`;
-   * }
-   * ```
    */
-  defaultHTTPErrorMessage?: string | ((context: Pick<HTTPError<TErrorData$1>, "errorData" | "response">) => string);
+  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>>;
+type CallApiParameters<TData$1 = DefaultDataType, TErrorData$1 = DefaultDataType, TResultMode$1 extends ResultModeType = ResultModeType, TCallApiContext$1 extends CallApiContext = DefaultCallApiContext, 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> = [initURL: TInitURL$1, config?: CallApiConfig<TCallApiContext$1, TData$1, TErrorData$1, TResultMode$1, TThrowOnError$1, TResponseType$1, TBaseSchemaRoutes$1, TSchema$1, TBaseSchemaConfig, TSchemaConfig$1, TInitURL$1, TCurrentRouteSchemaKey$1, TBasePluginArray$1, TPluginArray$1>];
+type CallApiResult<TData$1, TErrorData$1, TResultMode$1 extends ResultModeType, TThrowOnError$1 extends ThrowOnErrorUnion, TResponseType$1 extends ResponseTypeType> = GetCallApiResult<TData$1, TErrorData$1, TResultMode$1, TThrowOnError$1, TResponseType$1>;
+type CallApiResultLoose<TData$1, TErrorData$1, TResultMode$1 extends ResultModeType = ResultModeType, TThrowOnError$1 extends ThrowOnErrorUnion = ThrowOnErrorUnion, TResponseType$1 extends ResponseTypeType = ResponseTypeType> = GetCallApiResult<TData$1, TErrorData$1, TResultMode$1, TThrowOnError$1, TResponseType$1>;
+//#endregion
+//#region src/utils/external/body.d.ts
+type ToQueryStringFn = {
+  (query: CallApiExtraOptions["query"]): string | null;
+  (query: Required<CallApiExtraOptions>["query"]): string;
+};
+declare const toQueryString: ToQueryStringFn;
+type AllowedPrimitives = boolean | number | string | Blob | null | undefined;
+type AllowedValues = AllowedPrimitives | AllowedPrimitives[] | Record<string, AllowedPrimitives>;
+type ToFormDataFn = {
+  (data: Record<string, AllowedValues>): FormData;
+  <TData extends Record<string, AllowedValues>>(data: TData, options: {
+    returnType: "inputType";
+  }): TData;
+};
+/**
+ * @description Converts a plain object to FormData.
+ *
+ * Handles various data types:
+ * - **Primitives** (string, number, boolean): Converted to strings
+ * - **Blobs/Files**: Added directly to FormData
+ * - **Arrays**: Each item is appended (allows multiple values for same key)
+ * - **Objects**: JSON stringified before adding to FormData
+ *
+ * @example
+ * ```ts
+ * // Basic usage
+ * const formData = toFormData({
+ *   name: "John",
+ *   age: 30,
+ *   active: true
+ * });
+ *
+ * // With arrays
+ * const formData = toFormData({
+ *   tags: ["javascript", "typescript"],
+ *   name: "John"
+ * });
+ *
+ * // With files
+ * const formData = toFormData({
+ *   avatar: fileBlob,
+ *   name: "John"
+ * });
+ *
+ * // With nested objects (one level only)
+ * const formData = toFormData({
+ *   user: { name: "John", age: 30 },
+ *   settings: { theme: "dark" }
+ * });
+ *
+ * // Type-preserving usage with Zod
+ * const schema = z.object({ name: z.string(), file: z.instanceof(Blob) });
+ * const data = schema.parse({ name: "John", file: blob });
+ * const typedFormData = toFormData(data, { returnType: "inputType" });
+ * // Type is { name: string; file: Blob }, runtime is FormData
+ * ```
+ */
+declare const toFormData: ToFormDataFn;
+//#endregion
+//#region src/utils/external/define.d.ts
+declare const defineSchema: <const TBaseSchemaRoutes extends BaseCallApiSchemaRoutes, const TSchemaConfig extends CallApiSchemaConfig>(routes: TBaseSchemaRoutes, config?: Satisfies<TSchemaConfig, CallApiSchemaConfig>) => {
+  config: Writeable<Satisfies<TSchemaConfig, CallApiSchemaConfig>, "deep">;
+  routes: Writeable<TBaseSchemaRoutes, "deep">;
+};
+declare const defineSchemaRoutes: <const TSchemaRoutes extends BaseCallApiSchemaRoutes>(routes: TSchemaRoutes) => Writeable<typeof routes, "deep">;
+declare const defineMainSchema: <const TSchema extends CallApiSchema>(mainSchema: Satisfies<TSchema, CallApiSchema>) => Writeable<typeof mainSchema, "deep">;
+declare const defineSchemaConfig: <const TSchemaConfig extends CallApiSchemaConfig>(config: Satisfies<TSchemaConfig, CallApiSchemaConfig>) => Writeable<typeof config, "deep">;
+declare const definePlugin: <const TPlugin extends CallApiPlugin>(plugin: TPlugin) => Writeable<typeof plugin, "deep">;
+type BaseConfigObject = Exclude<BaseCallApiConfig, AnyFunction>;
+type BaseConfigFn = Extract<BaseCallApiConfig, AnyFunction>;
+type DefineBaseConfig = {
+  <const TBaseConfig extends BaseConfigObject>(baseConfig: Satisfies<TBaseConfig, BaseConfigObject>): Writeable<typeof baseConfig, "deep">;
+  <TBaseConfigFn extends BaseConfigFn>(baseConfig: TBaseConfigFn): TBaseConfigFn;
+};
+declare const defineBaseConfig: DefineBaseConfig;
+//#endregion
+//#region src/utils/external/guards.d.ts
+declare const isHTTPError: <TErrorData>(error: CallApiResultErrorVariant<TErrorData>["error"] | null) => error is PossibleHTTPError<TErrorData>;
+declare const isHTTPErrorInstance: <TErrorData>(error: unknown) => error is HTTPError<TErrorData>;
+declare const isValidationError: (error: CallApiResultErrorVariant<unknown>["error"] | null) => error is PossibleValidationError;
+declare const isValidationErrorInstance: (error: unknown) => error is ValidationError;
+declare const isJavascriptError: (error: CallApiResultErrorVariant<unknown>["error"] | null) => error is PossibleJavaScriptError;
+//#endregion
+//#region src/stream.d.ts
+type StreamProgressEvent = {
+  /**
+   * Current chunk of data being streamed
+   */
+  chunk: Uint8Array;
   /**
-   * Forces calculation of total byte size from request/response body streams.
-   *
-   * Useful when the Content-Length header is missing or incorrect, and you need
-   * accurate size information for progress tracking or bandwidth monitoring.
-   *
-   * @default false
-   *
+   * Progress in percentage
    */
-  forcefullyCalculateStreamSize?: boolean | {
-    request?: boolean;
-    response?: boolean;
-  };
+  progress: number;
   /**
-   * Optional metadata field for associating additional information with requests.
-   *
-   * Useful for logging, tracing, or handling specific cases in shared interceptors.
-   * The meta object is passed through to all hooks and can be accessed in error handlers.
-   *
-   * @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" },
-   * });
-   *
-   * // Use case: Request tracking
-   * const result = await callMainApi({
-   *   url: "https://example.com/api/data",
-   *   meta: {
-   *     requestId: generateId(),
-   *     source: "user-dashboard",
-   *     priority: "high"
-   *   }
-   * });
-   *
-   * // Use case: Feature flags
-   * const client = callApi.create({
-   *   baseURL: "https://api.example.com",
-   *   meta: {
-   *     features: ["newUI", "betaFeature"],
-   *     experiment: "variantA"
-   *   }
-   * });
-   * ```
+   * Total size of data in bytes
    */
-  meta?: TCallApiEnv["Meta"];
+  totalBytes: number;
   /**
-   * Custom function to parse response strings into actual value instead of the default response.json().
-   *
-   * Useful when you need custom parsing logic for specific response formats.
-   *
-   * @example
-   * ```ts
-   * responseParser: (responseString) => {
-   *   return JSON.parse(responseString);
-   * }
-   *
-   * // Parse XML responses
-   * responseParser: (responseString) => {
-   *   const parser = new DOMParser();
-   *   const doc = parser.parseFromString(responseString, "text/xml");
-   *   return xmlToObject(doc);
-   * }
-   *
-   * // Parse CSV responses
-   * responseParser: (responseString) => {
-   *   const lines = responseString.split('\n');
-   *   const headers = lines[0].split(',');
-   *   const data = lines.slice(1).map(line => {
-   *     const values = line.split(',');
-   *     return headers.reduce((obj, header, index) => {
-   *       obj[header] = values[index];
-   *       return obj;
-   *     }, {});
-   *   });
-   *   return data;
-   * }
-   *
-   * ```
+   * Amount of data transferred so far
    */
-  responseParser?: (responseString: string) => Awaitable<TData$1>;
+  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"]> {
   /**
-   * Expected response type, determines how the response body is parsed.
-   *
-   * Different response types trigger different parsing methods:
-   * - **"json"**: Parses as JSON using response.json()
-   * - **"text"**: Returns as plain text using response.text()
-   * - **"blob"**: Returns as Blob using response.blob()
-   * - **"arrayBuffer"**: Returns as ArrayBuffer using response.arrayBuffer()
-   * - **"stream"**: Returns the response body stream directly
-   *
-   * @default "json"
-   *
-   * @example
-   * ```ts
-   * // JSON API responses (default)
-   * responseType: "json"
-   *
-   * // Plain text responses
-   * responseType: "text"
-   * // Usage: const csvData = await callApi("/export.csv", { responseType: "text" });
-   *
-   * // File downloads
-   * responseType: "blob"
-   * // Usage: const file = await callApi("/download/file.pdf", { responseType: "blob" });
+   * Hook called when any error occurs within the request/response lifecycle.
    *
-   * // Binary data
-   * responseType: "arrayBuffer"
-   * // Usage: const buffer = await callApi("/binary-data", { responseType: "arrayBuffer" });
+   * 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.
    *
-   * // Streaming responses
-   * responseType: "stream"
-   * // Usage: const stream = await callApi("/large-dataset", { responseType: "stream" });
-   * ```
+   * @param context - Error context containing error details, request info, and response (if available)
+   * @returns Promise or void - Hook can be async or sync
    */
-  responseType?: TResponseType;
+  onError?: (context: ErrorContext<TCallApiContext$1, TErrorData$1>) => Awaitable<unknown>;
   /**
-   * Controls what data is included in the returned result object.
-   *
-   * Different modes return different combinations of data, error, and response:
-   * - **"all"**: Returns { data, error, response } - complete result information
-   * - **"onlyData"**: Returns only data (null for errors)
-   *
-   * When combined with throwOnError: true, null/error variants are automatically removed:
-   * - **"all" + throwOnError: true**: Returns { data, error: null, response } (error property is null, throws instead)
-   * - **"onlyData" + throwOnError: true**: Returns data (never null, throws on error)
-   *
-   * @default "all"
-   *
-   * @example
-   * ```ts
-   * // Complete result with all information (default)
-   * const { data, error, response } = await callApi("/users", { resultMode: "all" });
-   * if (error) {
-   *   console.error("Request failed:", error);
-   * } else {
-   *   console.log("Users:", data);
-   * }
+   * Hook called before the HTTP request is sent and before any internal processing of the request object begins.
    *
-   * // Complete result but throws on errors (throwOnError removes error from type)
-   * try {
-   *   const { data, response } = await callApi("/users", {
-   *     resultMode: "all",
-   *     throwOnError: true
-   *   });
-   *   console.log("Users:", data); // data is never null here
-   * } catch (error) {
-   *   console.error("Request failed:", error);
-   * }
+   * This is the ideal place to modify request headers, add authentication,
+   * implement request logging, or perform any setup before the network call.
    *
-   * // Only data, returns null on errors
-   * const users = await callApi("/users", { resultMode: "onlyData" });
-   * if (users) {
-   *   console.log("Users:", users);
-   * } else {
-   *   console.log("Request failed");
-   * }
+   * @param context - Request context with mutable request object and configuration
+   * @returns Promise or void - Hook can be async or sync
    *
-   * // Only data, throws on errors (throwOnError removes null from type)
-   * try {
-   *   const users = await callApi("/users", {
-   *     resultMode: "onlyData",
-   *     throwOnError: true
-   *   });
-   *   console.log("Users:", users); // users is never null here
-   * } catch (error) {
-   *   console.error("Request failed:", error);
-   * }
-   * ```
    */
-  resultMode?: TResultMode;
+  onRequest?: (context: RequestContext<TCallApiContext$1>) => Awaitable<unknown>;
   /**
-   * Controls whether errors are thrown as exceptions or returned in the result.
-   *
-   * Can be a boolean or a function that receives the error and decides whether to throw.
-   * When true, errors are thrown as exceptions instead of being returned in the result object.
-   *
-   * @default false
-   *
-   * @example
-   * ```ts
-   * // Always throw errors
-   * throwOnError: true
-   * try {
-   *   const data = await callApi("/users");
-   *   console.log("Users:", data);
-   * } catch (error) {
-   *   console.error("Request failed:", error);
-   * }
-   *
-   * // Never throw errors (default)
-   * throwOnError: false
-   * const { data, error } = await callApi("/users");
-   * if (error) {
-   *   console.error("Request failed:", error);
-   * }
-   *
-   * // Conditionally throw based on error type
-   * throwOnError: (error) => {
-   *   // Throw on client errors (4xx) but not server errors (5xx)
-   *   return error.response?.status >= 400 && error.response?.status < 500;
-   * }
+   * Hook called when an error occurs during the fetch request itself.
    *
-   * // Throw only on specific status codes
-   * throwOnError: (error) => {
-   *   const criticalErrors = [401, 403, 404];
-   *   return criticalErrors.includes(error.response?.status);
-   * }
+   * 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`.
    *
-   * // Throw on validation errors but not network errors
-   * throwOnError: (error) => {
-   *   return error.type === "validation";
-   * }
-   * ```
+   * @param context - Request error context with error details and null response
+   * @returns Promise or void - Hook can be async or sync
    */
-  throwOnError?: ThrowOnErrorType<TErrorData$1, TThrowOnError>;
+  onRequestError?: (context: RequestErrorContext<TCallApiContext$1>) => Awaitable<unknown>;
   /**
-   * Request timeout in milliseconds. Request will be aborted if it takes longer.
-   *
-   * Useful for preventing requests from hanging indefinitely and providing
-   * better user experience with predictable response times.
-   *
-   * @example
-   * ```ts
-   * // 5 second timeout
-   * timeout: 5000
-   *
-   * // Different timeouts for different endpoints
-   * const quickApi = createFetchClient({ timeout: 3000 }); // 3s for fast endpoints
-   * const slowApi = createFetchClient({ timeout: 30000 }); // 30s for slow operations
-   *
-   * // Per-request timeout override
-   * await callApi("/quick-data", { timeout: 1000 });
-   * await callApi("/slow-report", { timeout: 60000 });
-   *
-   * // No timeout (use with caution)
-   * timeout: 0
-   * ```
+   * 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
    */
-  timeout?: number;
-};
-type BaseCallApiExtraOptions<TBaseData = DefaultDataType, TBaseErrorData = DefaultDataType, TBaseResultMode extends ResultModeType = ResultModeType, TBaseCallApiEnv extends CallApiEnv = CallApiEnv, TBaseThrowOnError extends ThrowOnErrorUnion = DefaultThrowOnError, TBaseResponseType extends ResponseTypeType = ResponseTypeType, TBasePluginArray extends CallApiPlugin[] = DefaultPluginArray, TBaseSchemaAndConfig extends BaseCallApiSchemaAndConfig = BaseCallApiSchemaAndConfig> = SharedExtraOptions<TBaseData, TBaseErrorData, TBaseResultMode, TBaseCallApiEnv, TBaseThrowOnError, TBaseResponseType, TBasePluginArray> & {
+  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 GetBaseSchemaRoutes<TBaseSchemaAndConfig extends BaseCallApiSchemaAndConfig> = Writeable<TBaseSchemaAndConfig["routes"], "deep">;
-type GetBaseSchemaConfig<TBaseSchemaAndConfig extends BaseCallApiSchemaAndConfig> = Writeable<NonNullable<TBaseSchemaAndConfig["config"]>, "deep">;
-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<TData$1 = DefaultDataType, TErrorData$1 = DefaultDataType, TResultMode extends ResultModeType = ResultModeType, TCallApiEnv extends CallApiEnv = CallApiEnv, 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<TData$1, TErrorData$1, TResultMode, TCallApiEnv, 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>;
+  /**
+   * 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 = Hooks & Omit<CallApiExtraOptions, 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<TBaseData = DefaultDataType, TBaseErrorData = DefaultDataType, TBaseResultMode extends ResultModeType = ResultModeType, TBaseCallApiEnv extends CallApiEnv = CallApiEnv, TBaseThrowOnError extends ThrowOnErrorUnion = DefaultThrowOnError, TBaseResponseType extends ResponseTypeType = ResponseTypeType, TBaseSchemaAndConfig extends BaseCallApiSchemaAndConfig = BaseCallApiSchemaAndConfig, TBasePluginArray extends CallApiPlugin[] = DefaultPluginArray, TComputedBaseConfig = BaseCallApiExtraOptions<TBaseData, TBaseErrorData, TBaseResultMode, TBaseCallApiEnv, TBaseThrowOnError, TBaseResponseType, TBasePluginArray, TBaseSchemaAndConfig>> = (CallApiRequestOptions & TComputedBaseConfig) | ((context: InstanceContext) => CallApiRequestOptions & TComputedBaseConfig);
-type CallApiConfig<TData$1 = DefaultDataType, TErrorData$1 = DefaultDataType, TResultMode extends ResultModeType = ResultModeType, TCallApiEnv extends CallApiEnv = CallApiEnv, 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, TCallApiEnv> & InferRequestOptions<TSchema$1, TInitURL> & Omit<CallApiExtraOptions<TData$1, TErrorData$1, TResultMode, TCallApiEnv, TThrowOnError, TResponseType, TBasePluginArray, TPluginArray, TBaseSchemaRoutes$1, TSchema$1, TBaseSchemaConfig, TSchemaConfig$1, TCurrentRouteSchemaKey>, keyof InferExtraOptions<CallApiSchema, BaseCallApiSchemaRoutes, string, CallApiEnv>> & Omit<CallApiRequestOptions, keyof InferRequestOptions<CallApiSchema, string>>;
-type CallApiParameters<TData$1 = DefaultDataType, TErrorData$1 = DefaultDataType, TResultMode extends ResultModeType = ResultModeType, TCallApiEnv extends CallApiEnv = CallApiEnv, 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> = [initURL: TInitURL, config?: CallApiConfig<TData$1, TErrorData$1, TResultMode, TCallApiEnv, TThrowOnError, TResponseType, TBaseSchemaRoutes$1, TSchema$1, TBaseSchemaConfig, TSchemaConfig$1, TInitURL, TCurrentRouteSchemaKey, TBasePluginArray, TPluginArray>];
-type CallApiResult<TData$1, TErrorData$1, TResultMode extends ResultModeType, TThrowOnError extends ThrowOnErrorUnion, TResponseType extends ResponseTypeType> = GetCallApiResult<TData$1, TErrorData$1, TResultMode, TThrowOnError, TResponseType>;
-type CallApiResultLoose<TData$1, TErrorData$1, TResultMode extends ResultModeType = ResultModeType, TThrowOnError extends ThrowOnErrorUnion = ThrowOnErrorUnion, TResponseType extends ResponseTypeType = ResponseTypeType> = GetCallApiResult<TData$1, TErrorData$1, TResultMode, TThrowOnError, TResponseType>;
 //#endregion
 //#region src/validation.d.ts
 type ResultVariant = "infer-input" | "infer-output";
@@ -1899,5 +1853,60 @@ type BaseCallApiSchemaAndConfig = {
   routes: BaseCallApiSchemaRoutes;
 };
 //#endregion
-export { definePlugin as $, InferInitURL as A, RequestContext as B, InferExtendSchemaConfigContext as C, DefaultPluginArray as Ct, ApplyURLBasedConfig as D, Writeable as Dt, ApplyStrictConfig as E, AnyString as Et, DedupeOptions as F, SuccessContext as G, ResponseContext as H, ErrorContext as I, isJavascriptError as J, isHTTPError as K, Hooks as L, Register as M, ThrowOnErrorUnion as N, GetCurrentRouteSchema as O, RetryOptions as P, defineMainSchema as Q, HooksOrHooksArray as R, GetBaseSchemaRoutes as S, ValidationError as St, InstanceContext as T, toQueryString as Tt, ResponseErrorContext as U, RequestStreamContext as V, ResponseStreamContext as W, isValidationErrorInstance as X, isValidationError as Y, defineBaseConfig as Z, CallApiRequestOptions as _, ResponseTypeMap as _t, CallApiSchemaConfig as a, PluginHooksWithMoreOptions as at, CallApiResultLoose as b, ResultModeType as bt, InferSchemaResult as c, CallApiResultErrorVariant as ct, BlankCallApiEnv as d, GetCallApiResult as dt, defineSchema as et, CallApiConfig as f, GetResponseType as ft, CallApiParameters as g, PossibleValidationError as gt, CallApiExtraOptionsForHooks as h, PossibleJavaScriptOrValidationError as ht, CallApiSchema as i, PluginHooks as it, InferParamsFromRoute as j, GetCurrentRouteSchemaKey as k, BaseCallApiConfig as l, CallApiResultSuccessVariant as lt, CallApiExtraOptions as m, PossibleJavaScriptError as mt, BaseCallApiSchemaRoutes as n, defineSchemaRoutes as nt, InferSchemaInput as o, PluginSetupContext as ot, CallApiEnv as p, PossibleHTTPError as pt, isHTTPErrorInstance as q, BaseSchemaRouteKeyPrefixes as r, CallApiPlugin as rt, InferSchemaOutput as s, URLOptions as st, BaseCallApiSchemaAndConfig as t, defineSchemaConfig as tt, BaseCallApiExtraOptions as u, CallApiSuccessOrErrorVariant as ut, CallApiRequestOptionsForHooks as v, ResponseTypeType as vt, InferExtendSchemaContext as w, toFormData as wt, GetBaseSchemaConfig as x, HTTPError as xt, CallApiResult as y, ResultModeMap as yt, PluginExtraOptions as z };
-//# sourceMappingURL=validation-BXtphXvQ.d.ts.map
+//#region src/createFetchClient.d.ts
+declare const createFetchClientWithContext: <TOuterCallApiContext extends CallApiContext = DefaultCallApiContext>() => <TBaseCallApiContext extends CallApiContext = TOuterCallApiContext, TBaseData = TBaseCallApiContext["Data"], TBaseErrorData = TBaseCallApiContext["ErrorData"], TBaseResultMode extends ResultModeType = (TBaseCallApiContext["ResultMode"] extends ResultModeType ? TBaseCallApiContext["ResultMode"] : ResultModeType), TBaseThrowOnError extends ThrowOnErrorUnion = boolean, TBaseResponseType extends ResponseTypeType = ResponseTypeType, const TBaseSchemaAndConfig extends BaseCallApiSchemaAndConfig = BaseCallApiSchemaAndConfig, const TBasePluginArray extends CallApiPlugin[] = DefaultPluginArray, TComputedBaseSchemaConfig extends CallApiSchemaConfig = GetBaseSchemaConfig<TBaseSchemaAndConfig>, TComputedBaseSchemaRoutes extends BaseCallApiSchemaRoutes = GetBaseSchemaRoutes<TBaseSchemaAndConfig>>(initBaseConfig?: BaseCallApiConfig<TBaseCallApiContext, TBaseData, TBaseErrorData, TBaseResultMode, TBaseThrowOnError, TBaseResponseType, TBaseSchemaAndConfig, TBasePluginArray>) => <TData = TBaseData, TErrorData = TBaseErrorData, TResultMode extends ResultModeType = TBaseResultMode, TCallApiContext extends CallApiContext = TBaseCallApiContext, TThrowOnError extends ThrowOnErrorUnion = TBaseThrowOnError, TResponseType extends ResponseTypeType = TBaseResponseType, const TSchemaConfig extends CallApiSchemaConfig = TComputedBaseSchemaConfig, TInitURL extends InferInitURL<TComputedBaseSchemaRoutes, TSchemaConfig> = InferInitURL<TComputedBaseSchemaRoutes, TSchemaConfig>, TCurrentRouteSchemaKey extends GetCurrentRouteSchemaKey<TSchemaConfig, TInitURL> = GetCurrentRouteSchemaKey<TSchemaConfig, TInitURL>, const TSchema extends CallApiSchema = GetCurrentRouteSchema<TComputedBaseSchemaRoutes, TCurrentRouteSchemaKey>, const TPluginArray extends CallApiPlugin[] = TBasePluginArray, TComputedResult = CallApiResult<InferSchemaOutput<TSchema["data"], TData>, InferSchemaOutput<TSchema["errorData"], TErrorData>, TResultMode, TThrowOnError, TResponseType>>(initURL: TInitURL, initConfig?: CallApiConfig<TCallApiContext, InferSchemaOutput<TSchema["data"], GetResponseType<TData, TResponseType>>, InferSchemaOutput<TSchema["errorData"], GetResponseType<TErrorData, TResponseType>>, TResultMode, TThrowOnError, TResponseType, TComputedBaseSchemaRoutes, TSchema, TComputedBaseSchemaConfig, TSchemaConfig, TInitURL, TCurrentRouteSchemaKey, TBasePluginArray, TPluginArray>) => Promise<TComputedResult>;
+declare const createFetchClient: <TBaseCallApiContext extends CallApiContext = DefaultCallApiContext, TBaseData = TBaseCallApiContext["Data"], TBaseErrorData = TBaseCallApiContext["ErrorData"], TBaseResultMode extends ResultModeType = (TBaseCallApiContext["ResultMode"] extends ResultModeType ? TBaseCallApiContext["ResultMode"] : ResultModeType), TBaseThrowOnError extends ThrowOnErrorUnion = boolean, TBaseResponseType extends ResponseTypeType = ResponseTypeType, const TBaseSchemaAndConfig extends BaseCallApiSchemaAndConfig = BaseCallApiSchemaAndConfig, const TBasePluginArray extends CallApiPlugin[] = DefaultPluginArray, TComputedBaseSchemaConfig extends CallApiSchemaConfig = Writeable<NonNullable<TBaseSchemaAndConfig["config"]>, "deep">, TComputedBaseSchemaRoutes extends BaseCallApiSchemaRoutes = Writeable<TBaseSchemaAndConfig["routes"], "deep">>(initBaseConfig?: BaseCallApiConfig<TBaseCallApiContext, TBaseData, TBaseErrorData, TBaseResultMode, TBaseThrowOnError, TBaseResponseType, TBaseSchemaAndConfig, TBasePluginArray>) => <TData = TBaseData, TErrorData = TBaseErrorData, TResultMode extends ResultModeType = TBaseResultMode, TCallApiContext extends CallApiContext = TBaseCallApiContext, TThrowOnError extends ThrowOnErrorUnion = TBaseThrowOnError, TResponseType extends ResponseTypeType = TBaseResponseType, const TSchemaConfig extends CallApiSchemaConfig = TComputedBaseSchemaConfig, TInitURL extends InferInitURL<TComputedBaseSchemaRoutes, TSchemaConfig> = InferInitURL<TComputedBaseSchemaRoutes, TSchemaConfig>, TCurrentRouteSchemaKey extends GetCurrentRouteSchemaKey<TSchemaConfig, TInitURL> = GetCurrentRouteSchemaKey<TSchemaConfig, TInitURL>, const TSchema extends CallApiSchema = GetCurrentRouteSchema<TComputedBaseSchemaRoutes, TCurrentRouteSchemaKey, TComputedBaseSchemaRoutes["@default"], TComputedBaseSchemaRoutes[TCurrentRouteSchemaKey], NonNullable<Omit<TComputedBaseSchemaRoutes["@default"], keyof TComputedBaseSchemaRoutes[TCurrentRouteSchemaKey]> & TComputedBaseSchemaRoutes[TCurrentRouteSchemaKey]>>, const TPluginArray extends CallApiPlugin[] = TBasePluginArray, TComputedResult = GetCallApiResult<InferSchemaResult<TSchema["data"], TData, "infer-output">, InferSchemaResult<TSchema["errorData"], TErrorData, "infer-output">, TResultMode, TThrowOnError, TResponseType, {
+  all: CallApiResultSuccessVariant<GetResponseType<InferSchemaResult<TSchema["data"], TData, "infer-output">, TResponseType, ResponseTypeMap<InferSchemaResult<TSchema["data"], TData, "infer-output">>>>;
+  onlyData: NoInfer<GetResponseType<InferSchemaResult<TSchema["data"], TData, "infer-output">, TResponseType, ResponseTypeMap<InferSchemaResult<TSchema["data"], TData, "infer-output">>>>;
+  onlyResponse: Response;
+  withoutResponse: Omit<CallApiResultSuccessVariant<GetResponseType<InferSchemaResult<TSchema["data"], TData, "infer-output">, TResponseType, ResponseTypeMap<InferSchemaResult<TSchema["data"], TData, "infer-output">>>>, "response">;
+}, ResultModeMap<InferSchemaResult<TSchema["data"], TData, "infer-output">, InferSchemaResult<TSchema["errorData"], TErrorData, "infer-output">, TResponseType, TThrowOnError>>>(initURL: TInitURL, initConfig?: CallApiConfig<TCallApiContext, InferSchemaResult<TSchema["data"], GetResponseType<TData, TResponseType, ResponseTypeMap<TData>>, "infer-output">, InferSchemaResult<TSchema["errorData"], GetResponseType<TErrorData, TResponseType, ResponseTypeMap<TErrorData>>, "infer-output">, TResultMode, TThrowOnError, TResponseType, TComputedBaseSchemaRoutes, TSchema, TComputedBaseSchemaConfig, TSchemaConfig, TInitURL, TCurrentRouteSchemaKey, TBasePluginArray, TPluginArray>) => Promise<TComputedResult>;
+declare const callApi: <TData = unknown, TErrorData = unknown, TResultMode extends ResultModeType = ResultModeType, TCallApiContext extends CallApiContext = DefaultCallApiContext, TThrowOnError extends ThrowOnErrorUnion = boolean, TResponseType extends ResponseTypeType = ResponseTypeType, const TSchemaConfig extends CallApiSchemaConfig = CallApiSchemaConfig, TInitURL extends ApplyStrictConfig<TSchemaConfig, ApplyURLBasedConfig<TSchemaConfig, AnyString | "@delete/" | "@get/" | "@patch/" | "@post/" | "@put/">> = ApplyStrictConfig<TSchemaConfig, ApplyURLBasedConfig<TSchemaConfig, AnyString | "@delete/" | "@get/" | "@patch/" | "@post/" | "@put/">>, TCurrentRouteSchemaKey extends GetCurrentRouteSchemaKey<TSchemaConfig, TInitURL> = GetCurrentRouteSchemaKey<TSchemaConfig, TInitURL>, const TSchema extends CallApiSchema = GetCurrentRouteSchema<{
+  [x: AnyString]: CallApiSchema | undefined;
+  "@default"?: CallApiSchema | undefined;
+  "@delete/"?: CallApiSchema | undefined;
+  "@get/"?: CallApiSchema | undefined;
+  "@patch/"?: CallApiSchema | undefined;
+  "@post/"?: CallApiSchema | undefined;
+  "@put/"?: CallApiSchema | undefined;
+}, TCurrentRouteSchemaKey, CallApiSchema | undefined, {
+  [x: AnyString]: CallApiSchema | undefined;
+  "@default"?: CallApiSchema | undefined;
+  "@delete/"?: CallApiSchema | undefined;
+  "@get/"?: CallApiSchema | undefined;
+  "@patch/"?: CallApiSchema | undefined;
+  "@post/"?: CallApiSchema | undefined;
+  "@put/"?: CallApiSchema | undefined;
+}[TCurrentRouteSchemaKey], NonNullable<Omit<CallApiSchema | undefined, keyof {
+  [x: AnyString]: CallApiSchema | undefined;
+  "@default"?: CallApiSchema | undefined;
+  "@delete/"?: CallApiSchema | undefined;
+  "@get/"?: CallApiSchema | undefined;
+  "@patch/"?: CallApiSchema | undefined;
+  "@post/"?: CallApiSchema | undefined;
+  "@put/"?: CallApiSchema | undefined;
+}[TCurrentRouteSchemaKey]> & {
+  [x: AnyString]: CallApiSchema | undefined;
+  "@default"?: CallApiSchema | undefined;
+  "@delete/"?: CallApiSchema | undefined;
+  "@get/"?: CallApiSchema | undefined;
+  "@patch/"?: CallApiSchema | undefined;
+  "@post/"?: CallApiSchema | undefined;
+  "@put/"?: CallApiSchema | undefined;
+}[TCurrentRouteSchemaKey]>>, const TPluginArray extends CallApiPlugin[] = DefaultPluginArray, TComputedResult = GetCallApiResult<InferSchemaResult<TSchema["data"], TData, "infer-output">, InferSchemaResult<TSchema["errorData"], TErrorData, "infer-output">, TResultMode, TThrowOnError, TResponseType, {
+  all: CallApiResultSuccessVariant<GetResponseType<InferSchemaResult<TSchema["data"], TData, "infer-output">, TResponseType, ResponseTypeMap<InferSchemaResult<TSchema["data"], TData, "infer-output">>>>;
+  onlyData: NoInfer<GetResponseType<InferSchemaResult<TSchema["data"], TData, "infer-output">, TResponseType, ResponseTypeMap<InferSchemaResult<TSchema["data"], TData, "infer-output">>>>;
+  onlyResponse: Response;
+  withoutResponse: Omit<CallApiResultSuccessVariant<GetResponseType<InferSchemaResult<TSchema["data"], TData, "infer-output">, TResponseType, ResponseTypeMap<InferSchemaResult<TSchema["data"], TData, "infer-output">>>>, "response">;
+}, ResultModeMap<InferSchemaResult<TSchema["data"], TData, "infer-output">, InferSchemaResult<TSchema["errorData"], TErrorData, "infer-output">, TResponseType, TThrowOnError>>>(initURL: TInitURL, initConfig?: CallApiConfig<TCallApiContext, InferSchemaResult<TSchema["data"], GetResponseType<TData, TResponseType, ResponseTypeMap<TData>>, "infer-output">, InferSchemaResult<TSchema["errorData"], GetResponseType<TErrorData, TResponseType, ResponseTypeMap<TErrorData>>, "infer-output">, TResultMode, TThrowOnError, TResponseType, {
+  [x: AnyString]: CallApiSchema | undefined;
+  "@default"?: CallApiSchema | undefined;
+  "@delete/"?: CallApiSchema | undefined;
+  "@get/"?: CallApiSchema | undefined;
+  "@patch/"?: CallApiSchema | undefined;
+  "@post/"?: CallApiSchema | undefined;
+  "@put/"?: CallApiSchema | undefined;
+}, TSchema, CallApiSchemaConfig, TSchemaConfig, TInitURL, TCurrentRouteSchemaKey, DefaultPluginArray, TPluginArray>) => Promise<TComputedResult>;
+//#endregion
+export { PossibleHTTPError as $, definePlugin as A, CallApiExtraOptionsForHooks as B, isHTTPError as C, isValidationErrorInstance as D, isValidationError as E, toQueryString as F, GetExtendSchemaConfigContext as G, CallApiRequestOptions as H, BaseCallApiConfig as I, Register as J, InferExtendSchemaContext as K, BaseCallApiExtraOptions as L, defineSchemaConfig as M, defineSchemaRoutes as N, defineBaseConfig as O, toFormData as P, CallApiSuccessOrErrorVariant as Q, CallApiConfig as R, SuccessContext as S, isJavascriptError as T, CallApiRequestOptionsForHooks as U, CallApiParameters as V, CallApiResultLoose as W, CallApiResultErrorVariant as X, RetryOptions as Y, CallApiResultSuccessVariant as Z, RequestContext as _, BaseSchemaRouteKeyPrefixes as a, HTTPError as at, ResponseErrorContext as b, InferSchemaInput as c, URLOptions as ct, CallApiPlugin as d, PossibleJavaScriptError as et, PluginHooks as f, HooksOrHooksArray as g, Hooks as h, BaseCallApiSchemaRoutes as i, ResultModeType as it, defineSchema as j, defineMainSchema as k, InferSchemaOutput as l, DedupeOptions as lt, ErrorContext as m, createFetchClient as n, PossibleValidationError as nt, CallApiSchema as o, ValidationError as ot, PluginSetupContext as p, InstanceContext as q, createFetchClientWithContext as r, ResponseTypeType as rt, CallApiSchemaConfig as s, InferParamsFromRoute as st, callApi as t, PossibleJavaScriptOrValidationError as tt, DefaultCallApiContext as u, RequestStreamContext as v, isHTTPErrorInstance as w, ResponseStreamContext as x, ResponseContext as y, CallApiExtraOptions as z };
+//# sourceMappingURL=index-HHFgKKcn.d.ts.map