@zayne-labs/callapi 1.14.2 → 1.16.0

package/dist/{conditional-types-C9cMfJMZ.d.ts → callapi-context-NF0HXJwF.d.ts}

@@ -1,12 +1,22 @@
 //#region src/constants/common.d.ts
 declare const fetchSpecificKeys: readonly (keyof RequestInit | "duplex" | "extraFetchOptions")[];
 //#endregion
+//#region src/types/default-types.d.ts
+type DefaultDataType = unknown;
+type DefaultPluginArray = CallApiPlugin[];
+type DefaultThrowOnError = boolean;
+type DefaultMetaObject = Record<string, unknown>;
+type DefaultInferredExtraOptions = unknown;
+type DefaultCallApiContext = Omit<CallApiContext, "Meta">;
+//#endregion
 //#region src/types/type-helpers.d.ts
-type AnyString = string & NonNullable<unknown>;
-type AnyNumber = number & NonNullable<unknown>;
+type NonNullableUnknown = NonNullable<unknown>;
+type AnyString = string & NonNullableUnknown;
+type AnyNumber = number & NonNullableUnknown;
 type AnyFunction<TResult = unknown> = (...args: any[]) => TResult;
 type Prettify<TObject> = NonNullable<unknown> & { [Key in keyof TObject]: TObject[Key]; };
 type WriteableLevel = "deep" | "shallow";
+type IsEmptyObject<TObject> = keyof TObject extends never ? true : false;
 /**
  * Makes all properties in an object type writeable (removes readonly modifiers).
  * Supports both shallow and deep modes, and handles special cases like arrays, tuples, and unions.
@@ -37,208 +47,343 @@ type CommonRequestHeaders = "Access-Control-Allow-Credentials" | "Access-Control
 type CommonAuthorizationHeaders = `${"Basic" | "Bearer" | "Token"} ${string}`;
 type CommonContentTypes = "application/epub+zip" | "application/gzip" | "application/json" | "application/ld+json" | "application/octet-stream" | "application/ogg" | "application/pdf" | "application/rtf" | "application/vnd.ms-fontobject" | "application/wasm" | "application/xhtml+xml" | "application/xml" | "application/zip" | "audio/aac" | "audio/mpeg" | "audio/ogg" | "audio/opus" | "audio/webm" | "audio/x-midi" | "font/otf" | "font/ttf" | "font/woff" | "font/woff2" | "image/avif" | "image/bmp" | "image/gif" | "image/jpeg" | "image/png" | "image/svg+xml" | "image/tiff" | "image/webp" | "image/x-icon" | "model/gltf-binary" | "model/gltf+json" | "text/calendar" | "text/css" | "text/csv" | "text/html" | "text/javascript" | "text/plain" | "video/3gpp" | "video/3gpp2" | "video/av1" | "video/mp2t" | "video/mp4" | "video/mpeg" | "video/ogg" | "video/webm" | "video/x-msvideo" | AnyString;
 //#endregion
-//#region src/types/standard-schema.d.ts
-/** The Standard Typed interface. This is a base type extended by other specs. */
-interface StandardTypedV1<Input = unknown, Output = Input> {
-  /** The Standard properties. */
-  readonly "~standard": StandardTypedV1.Props<Input, Output>;
-}
-declare namespace StandardTypedV1 {
-  /** The Standard Typed properties interface. */
-  interface Props<Input = unknown, Output = Input> {
-    /** Inferred types associated with the schema. */
-    readonly types?: Types<Input, Output> | undefined;
-    /** The vendor name of the schema library. */
-    readonly vendor: string;
-    /** The version number of the standard. */
-    readonly version: 1;
-  }
-  /** The Standard Typed 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 Typed. */
-  type InferInput<Schema extends StandardTypedV1> = NonNullable<Schema["~standard"]["types"]>["input"];
-  /** Infers the output type of a Standard Typed. */
-  type InferOutput<Schema extends StandardTypedV1> = NonNullable<Schema["~standard"]["types"]>["output"];
-}
-/** The Standard Schema interface. */
-interface StandardSchemaV1<Input = unknown, Output = Input> {
-  /** The Standard Schema properties. */
-  readonly "~standard": StandardSchemaV1.Props<Input, Output>;
-}
-declare namespace StandardSchemaV1 {
-  /** The Standard Schema properties interface. */
-  interface Props<Input = unknown, Output = Input> extends StandardTypedV1.Props<Input, Output> {
-    /** Validates unknown input values. */
-    readonly validate: (value: unknown, options?: StandardSchemaV1.Options) => Promise<Result<Output>> | Result<Output>;
-  }
-  /** The result interface of the validate function. */
-  type Result<Output> = FailureResult | SuccessResult<Output>;
-  /** The result interface if validation succeeds. */
-  interface SuccessResult<Output> {
-    /** A falsy value for `issues` indicates success. */
-    readonly issues?: undefined;
-    /** The typed output value. */
-    readonly value: Output;
-  }
-  interface Options {
-    /** Explicit support for additional vendor-specific parameters, if needed. */
-    readonly libraryOptions?: Record<string, unknown> | undefined;
-  }
-  /** 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 types interface. */
-  interface Types<Input = unknown, Output = Input> extends StandardTypedV1.Types<Input, Output> {}
-  /** Infers the input type of a Standard. */
-  type InferInput<Schema extends StandardTypedV1> = StandardTypedV1.InferInput<Schema>;
-  /** Infers the output type of a Standard. */
-  type InferOutput<Schema extends StandardTypedV1> = StandardTypedV1.InferOutput<Schema>;
-}
-//#endregion
-//#region src/constants/validation.d.ts
-declare const fallBackRouteSchemaKey = "@default";
-type FallBackRouteSchemaKey = typeof fallBackRouteSchemaKey;
-//#endregion
-//#region src/url.d.ts
-declare const atSymbol = "@";
-type AtSymbol = typeof atSymbol;
-type AllowedQueryParamValues = UnmaskType<boolean | number | string>;
-type RecordStyleParams = UnmaskType<Record<string, AllowedQueryParamValues>>;
-type TupleStyleParams = UnmaskType<AllowedQueryParamValues[]>;
-type Params = UnmaskType<RecordStyleParams | TupleStyleParams>;
-type StructuredQueryValues = Record<string, unknown> | unknown[] | null | undefined;
-type Query = UnmaskType<Record<string, AllowedQueryParamValues | StructuredQueryValues> | URLSearchParams>;
-type InitURLOrURLObject = AnyString | RouteKeyMethodsURLUnion | URL;
-interface URLOptions {
+//#region src/dedupe.d.ts
+type DedupeStrategyUnion = UnmaskType<"cancel" | "defer" | "none">;
+type DedupeOptions = {
   /**
-   * Base URL for all API requests. Will only be prepended to relative URLs.
+   * Controls the scope of request deduplication caching.
    *
-   * Absolute URLs (starting with http/https) will not be prepended by the baseURL.
+   * - `"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
-   * // Set base URL for all requests
-   * baseURL: "https://api.example.com/v1"
-   *
-   * // Then use relative URLs in requests
-   * callApi("/users") // → https://api.example.com/v1/users
-   * callApi("/posts/123") // → https://api.example.com/v1/posts/123
+   * // 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
    *
-   * // Environment-specific base URLs
-   * baseURL: process.env.NODE_ENV === "production"
-   *   ? "https://api.example.com"
-   *   : "http://localhost:3000/api"
+   * // 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
    * ```
-   */
-  baseURL?: string;
-  /**
-   * Resolved request URL after processing baseURL, parameters, and query strings (readonly)
-   *
-   * This is the final URL that will be used for the HTTP request, computed from
-   * baseURL, initURL, params, and query parameters.
-   *
-   */
-  readonly fullURL?: string;
-  /**
-   * The original URL string passed to the callApi instance (readonly)
-   *
-   * This preserves the original URL as provided, including any method modifiers like "@get/" or "@post/".
    *
+   * @default "local"
    */
-  readonly initURL?: string;
+  dedupeCacheScope?: "global" | "local";
   /**
-   * The URL string after normalization, with method modifiers removed(readonly)
+   * Unique namespace for the global deduplication cache when using `dedupeCacheScope: "global"`.
    *
-   * Method modifiers like "@get/", "@post/" are stripped to create a clean URL
-   * for parameter substitution and final URL construction.
+   * 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.
    *
-   */
-  readonly initURLNormalized?: string;
-  /**
-   * Parameters to be substituted into URL path segments.
+   * **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
    *
-   * Supports both object-style (named parameters) and array-style (positional parameters)
-   * for flexible URL parameter substitution.
+   * **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
-   * ```typescript
-   * // Object-style parameters (recommended)
-   * const namedParams: URLOptions = {
-   *   initURL: "/users/:userId/posts/:postId",
-   *   params: { userId: "123", postId: "456" }
-   * };
-   * // Results in: /users/123/posts/456
+   * ```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
+   * });
    *
-   * // Array-style parameters (positional)
-   * const positionalParams: URLOptions = {
-   *   initURL: "/users/:userId/posts/:postId",
-   *   params: ["123", "456"]  // Maps in order: userId=123, postId=456
-   * };
-   * // Results in: /users/123/posts/456
+   * // Separate analytics client with its own cache
+   * const analyticsClient = createFetchClient({
+   *   baseURL: "/api/analytics",
+   *   dedupeCacheScope: "global",
+   *   dedupeCacheScopeKey: "analytics-service" // Different scope
+   * });
    *
-   * // Single parameter
-   * const singleParam: URLOptions = {
-   *   initURL: "/users/:id",
-   *   params: { id: "user-123" }
-   * };
-   * // Results in: /users/user-123
+   * // Environment-specific scoping
+   * const apiClient = createFetchClient({
+   *   dedupeCacheScope: "global",
+   *   dedupeCacheScopeKey: `api-${process.env.NODE_ENV}` // "api-development", "api-production", etc.
+   * });
    * ```
+   *
+   * @default "default"
    */
-  params?: Params;
+  dedupeCacheScopeKey?: "default" | AnyString | ((context: RequestContext) => string | undefined);
   /**
-   * Query parameters to append to the URL as search parameters.
+   * Custom key generator for request deduplication.
    *
-   * These will be serialized into the URL query string using standard
-   * URL encoding practices.
+   * 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.).
    *
-   * @example
-   * ```typescript
-   * // Basic query parameters
-   * const queryOptions: URLOptions = {
-   *   initURL: "/users",
-   *   query: {
-   *     page: 1,
-   *     limit: 10,
-   *     search: "john doe",
-   *     active: true
-   *   }
-   * };
-   * // Results in: /users?page=1&limit=10&search=john%20doe&active=true
+   * **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.)
    *
-   * // Filtering and sorting
-   * const filterOptions: URLOptions = {
-   *   initURL: "/products",
-   *   query: {
-   *     category: "electronics",
-   *     minPrice: 100,
-   *     maxPrice: 500,
-   *     sortBy: "price",
-   *     order: "asc"
+   * **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
+   */
+  dedupeKey?: string | ((context: RequestContext) => string | undefined);
+  /**
+   * 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);
    *   }
    * };
-   * // Results in: /products?category=electronics&minPrice=100&maxPrice=500&sortBy=price&order=asc
+   *
    * ```
+   *
+   * @default "cancel"
    */
-  query?: Query;
+  dedupeStrategy?: DedupeStrategyUnion | ((context: RequestContext) => DedupeStrategyUnion);
+};
+//#endregion
+//#region src/middlewares.d.ts
+type FetchImpl = UnmaskType<(input: string | Request | URL, init?: RequestInit) => Awaitable<Response>>;
+type FetchMiddlewareContext<TCallApiContext extends CallApiContext> = RequestContext<TCallApiContext> & {
+  fetchImpl: FetchImpl;
+};
+interface Middlewares<TCallApiContext extends NoInfer<CallApiContext> = DefaultCallApiContext> {
+  /**
+   * Wraps the fetch implementation to intercept requests at the network layer.
+   *
+   * Takes a context object containing the current fetch function and returns a new fetch function.
+   * Use it to cache responses, add logging, handle offline mode, or short-circuit requests etc.
+   * Multiple middleware compose in order: plugins → base config → per-request.
+   *
+   * Unlike `customFetchImpl`, middleware can call through to the original fetch.
+   *
+   * @example
+   * ```ts
+   * // Cache responses
+   * const cache = new Map();
+   *
+   * fetchMiddleware: (ctx) => async (input, init) => {
+   *   const key = input.toString();
+   *
+   *   const cachedResponse = cache.get(key);
+   *
+   *   if (cachedResponse) {
+   *	    return cachedResponse.clone();
+   *   }
+   *
+   *   const response = await ctx.fetchImpl(input, init);
+   *   cache.set(key, response.clone());
+   *
+   *   return response;
+   * }
+   *
+   * // Handle offline
+   * fetchMiddleware: (ctx) => async (...parameters) => {
+   *   if (!navigator.onLine) {
+   *     return new Response('{"error": "offline"}', { status: 503 });
+   *   }
+   *
+   *   return ctx.fetchImpl(...parameters);
+   * }
+   * ```
+   */
+  fetchMiddleware?: (context: FetchMiddlewareContext<TCallApiContext>) => FetchImpl;
+}
+//#endregion
+//#region src/constants/validation.d.ts
+declare const fallBackRouteSchemaKey = "@default";
+type FallBackRouteSchemaKey = typeof fallBackRouteSchemaKey;
+//#endregion
+//#region src/types/standard-schema.d.ts
+/** The Standard Typed interface. This is a base type extended by other specs. */
+interface StandardTypedV1<Input = unknown, Output = Input> {
+  /** The Standard properties. */
+  readonly "~standard": StandardTypedV1.Props<Input, Output>;
+}
+declare namespace StandardTypedV1 {
+  /** The Standard Typed properties interface. */
+  interface Props<Input = unknown, Output = Input> {
+    /** Inferred types associated with the schema. */
+    readonly types?: Types<Input, Output> | undefined;
+    /** The vendor name of the schema library. */
+    readonly vendor: string;
+    /** The version number of the standard. */
+    readonly version: 1;
+  }
+  /** The Standard Typed 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 Typed. */
+  type InferInput<Schema extends StandardTypedV1> = NonNullable<Schema["~standard"]["types"]>["input"];
+  /** Infers the output type of a Standard Typed. */
+  type InferOutput<Schema extends StandardTypedV1> = NonNullable<Schema["~standard"]["types"]>["output"];
+}
+/** The Standard Schema interface. */
+interface StandardSchemaV1<Input = unknown, Output = Input> {
+  /** The Standard Schema properties. */
+  readonly "~standard": StandardSchemaV1.Props<Input, Output>;
+}
+declare namespace StandardSchemaV1 {
+  /** The Standard Schema properties interface. */
+  interface Props<Input = unknown, Output = Input> extends StandardTypedV1.Props<Input, Output> {
+    /** Validates unknown input values. */
+    readonly validate: (value: unknown, options?: StandardSchemaV1.Options) => Promise<Result<Output>> | Result<Output>;
+  }
+  /** The result interface of the validate function. */
+  type Result<Output> = FailureResult | SuccessResult<Output>;
+  /** The result interface if validation succeeds. */
+  interface SuccessResult<Output> {
+    /** A falsy value for `issues` indicates success. */
+    readonly issues?: undefined;
+    /** The typed output value. */
+    readonly value: Output;
+  }
+  interface Options {
+    /** Explicit support for additional vendor-specific parameters, if needed. */
+    readonly libraryOptions?: Record<string, unknown> | undefined;
+  }
+  /** 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 types interface. */
+  interface Types<Input = unknown, Output = Input> extends StandardTypedV1.Types<Input, Output> {}
+  /** Infers the input type of a Standard. */
+  type InferInput<Schema extends StandardTypedV1> = StandardTypedV1.InferInput<Schema>;
+  /** Infers the output type of a Standard. */
+  type InferOutput<Schema extends StandardTypedV1> = StandardTypedV1.InferOutput<Schema>;
 }
 //#endregion
 //#region src/validation.d.ts
@@ -342,27 +487,150 @@ declare const getCurrentRouteSchemaKeyAndMainInitURL: (context: Pick<GetResolved
   mainInitURL: string;
 };
 //#endregion
-//#region src/utils/external/error.d.ts
-type HTTPErrorDetails<TErrorData> = Pick<CallApiExtraOptions, "defaultHTTPErrorMessage"> & {
-  errorData: TErrorData;
-  response: Response;
-};
-declare class HTTPError<TErrorData = Record<string, unknown>> extends Error {
-  errorData: HTTPErrorDetails<TErrorData>["errorData"];
-  readonly httpErrorSymbol: symbol;
-  name: "HTTPError";
-  response: HTTPErrorDetails<TErrorData>["response"];
-  constructor(errorDetails: HTTPErrorDetails<TErrorData>, errorOptions?: ErrorOptions);
-  /**
-   * @description Checks if the given error is an instance of HTTPError
-   * @param error - The error to check
-   * @returns true if the error is an instance of HTTPError, false otherwise
-   */
-  static isError<TErrorData>(error: unknown): error is HTTPError<TErrorData>;
-}
-type SafeExtract<TUnion, TKey extends TUnion> = Extract<TUnion, TKey>;
-type ValidationErrorDetails = {
-  /**
+//#region src/url.d.ts
+declare const atSymbol = "@";
+type AtSymbol = typeof atSymbol;
+type AllowedQueryParamValues = UnmaskType<boolean | number | string>;
+type RecordStyleParams = UnmaskType<Record<string, AllowedQueryParamValues>>;
+type TupleStyleParams = UnmaskType<AllowedQueryParamValues[]>;
+type Params = UnmaskType<RecordStyleParams | TupleStyleParams>;
+type StructuredQueryValues = Record<string, unknown> | unknown[] | null | undefined;
+type Query = UnmaskType<Record<string, AllowedQueryParamValues | StructuredQueryValues> | URLSearchParams>;
+type InitURLOrURLObject = AnyString | RouteKeyMethodsURLUnion | URL;
+interface URLOptions {
+  /**
+   * Base URL for all API requests. Will only be prepended to relative URLs.
+   *
+   * Absolute URLs (starting with http/https) will not be prepended by the baseURL.
+   *
+   * @example
+   * ```ts
+   * // Set base URL for all requests
+   * baseURL: "https://api.example.com/v1"
+   *
+   * // Then use relative URLs in requests
+   * callApi("/users") // → https://api.example.com/v1/users
+   * callApi("/posts/123") // → https://api.example.com/v1/posts/123
+   *
+   * // Environment-specific base URLs
+   * baseURL: process.env.NODE_ENV === "production"
+   *   ? "https://api.example.com"
+   *   : "http://localhost:3000/api"
+   * ```
+   */
+  baseURL?: string;
+  /**
+   * Resolved request URL after processing baseURL, parameters, and query strings (readonly)
+   *
+   * This is the final URL that will be used for the HTTP request, computed from
+   * baseURL, initURL, params, and query parameters.
+   *
+   */
+  readonly fullURL?: string;
+  /**
+   * The original URL string passed to the callApi instance (readonly)
+   *
+   * This preserves the original URL as provided, including any method modifiers like "@get/" or "@post/".
+   *
+   */
+  readonly initURL?: string;
+  /**
+   * The URL string after normalization, with method modifiers removed(readonly)
+   *
+   * Method modifiers like "@get/", "@post/" are stripped to create a clean URL
+   * for parameter substitution and final URL construction.
+   *
+   */
+  readonly initURLNormalized?: string;
+  /**
+   * Parameters to be substituted into URL path segments.
+   *
+   * Supports both object-style (named parameters) and array-style (positional parameters)
+   * for flexible URL parameter substitution.
+   *
+   * @example
+   * ```typescript
+   * // Object-style parameters (recommended)
+   * const namedParams: URLOptions = {
+   *   initURL: "/users/:userId/posts/:postId",
+   *   params: { userId: "123", postId: "456" }
+   * };
+   * // Results in: /users/123/posts/456
+   *
+   * // Array-style parameters (positional)
+   * const positionalParams: URLOptions = {
+   *   initURL: "/users/:userId/posts/:postId",
+   *   params: ["123", "456"]  // Maps in order: userId=123, postId=456
+   * };
+   * // Results in: /users/123/posts/456
+   *
+   * // Single parameter
+   * const singleParam: URLOptions = {
+   *   initURL: "/users/:id",
+   *   params: { id: "user-123" }
+   * };
+   * // Results in: /users/user-123
+   * ```
+   */
+  params?: Params;
+  /**
+   * Query parameters to append to the URL as search parameters.
+   *
+   * These will be serialized into the URL query string using standard
+   * URL encoding practices.
+   *
+   * @example
+   * ```typescript
+   * // Basic query parameters
+   * const queryOptions: URLOptions = {
+   *   initURL: "/users",
+   *   query: {
+   *     page: 1,
+   *     limit: 10,
+   *     search: "john doe",
+   *     active: true
+   *   }
+   * };
+   * // Results in: /users?page=1&limit=10&search=john%20doe&active=true
+   *
+   * // Filtering and sorting
+   * const filterOptions: URLOptions = {
+   *   initURL: "/products",
+   *   query: {
+   *     category: "electronics",
+   *     minPrice: 100,
+   *     maxPrice: 500,
+   *     sortBy: "price",
+   *     order: "asc"
+   *   }
+   * };
+   * // Results in: /products?category=electronics&minPrice=100&maxPrice=500&sortBy=price&order=asc
+   * ```
+   */
+  query?: Query;
+}
+//#endregion
+//#region src/utils/external/error.d.ts
+type HTTPErrorDetails<TErrorData> = Pick<CallApiExtraOptions, "defaultHTTPErrorMessage"> & {
+  errorData: TErrorData;
+  response: Response;
+};
+declare class HTTPError<TErrorData = Record<string, unknown>> extends Error {
+  errorData: HTTPErrorDetails<TErrorData>["errorData"];
+  readonly httpErrorSymbol: symbol;
+  name: "HTTPError";
+  response: HTTPErrorDetails<TErrorData>["response"];
+  constructor(errorDetails: HTTPErrorDetails<TErrorData>, errorOptions?: ErrorOptions);
+  /**
+   * @description Checks if the given error is an instance of HTTPError
+   * @param error - The error to check
+   * @returns true if the error is an instance of HTTPError, false otherwise
+   */
+  static isError<TErrorData>(error: unknown): error is HTTPError<TErrorData>;
+}
+type SafeExtract<TUnion, TKey extends TUnion> = Extract<TUnion, TKey>;
+type ValidationErrorDetails = {
+  /**
    * The cause of the validation error.
    *
    * 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.
@@ -392,1525 +660,1261 @@ declare class ValidationError extends Error {
   static isError(error: unknown): error is ValidationError;
 }
 //#endregion
-//#region src/result.d.ts
-type ResponseParser<TData> = (text: string) => Awaitable<TData>;
-declare const getResponseType: <TData>(response: Response, responseParser: ResponseParser<TData>) => {
-  arrayBuffer: () => Promise<ArrayBuffer>;
-  blob: () => Promise<Blob>;
-  formData: () => Promise<FormData>;
-  json: () => Promise<TData>;
-  stream: () => ReadableStream<Uint8Array<ArrayBuffer>> | null;
-  text: () => Promise<string>;
-};
-type InitResponseTypeMap<TData = unknown> = ReturnType<typeof getResponseType<TData>>;
-type ResponseTypeUnion = keyof InitResponseTypeMap;
-type ResponseTypePlaceholder = null;
-type ResponseTypeType = ResponseTypePlaceholder | ResponseTypeUnion;
-type ResponseTypeMap<TData> = { [Key in keyof InitResponseTypeMap<TData>]: Awaited<ReturnType<InitResponseTypeMap<TData>[Key]>>; };
-type GetResponseType<TData, TResponseType extends ResponseTypeType, TComputedResponseTypeMap extends ResponseTypeMap<TData> = ResponseTypeMap<TData>> = null extends TResponseType ? TComputedResponseTypeMap["json"] : TResponseType extends NonNullable<ResponseTypeType> ? TComputedResponseTypeMap[TResponseType] : never;
-type CallApiResultSuccessVariant<TData> = {
-  data: NoInferUnMasked<TData>;
-  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> = UnmaskType<{
-  errorData: NoInferUnMasked<TErrorData>;
-  message: string;
-  name: "HTTPError";
-  originalError: HTTPError;
-}>;
-type PossibleValidationError = UnmaskType<{
-  errorData: ValidationError["errorData"];
-  issueCause: ValidationError["issueCause"];
-  message: string;
-  name: "ValidationError";
-  originalError: ValidationError;
-}>;
-type CallApiResultErrorVariant<TErrorData> = {
-  data: null;
-  error: PossibleHTTPError<TErrorData>;
-  response: Response;
-} | {
-  data: null;
-  error: PossibleJavaScriptError;
-  response: Response | null;
-} | {
-  data: null;
-  error: PossibleValidationError;
-  response: Response | null;
-};
-type CallApiResultSuccessOrErrorVariant<TData, TError> = CallApiResultErrorVariant<TError> | CallApiResultSuccessVariant<TData>;
-type GetCallApiResult<TThrowOnError extends ThrowOnErrorBoolean, TResultWithException extends CallApiResultSuccessVariant<unknown>, TResultWithoutException extends CallApiResultSuccessOrErrorVariant<unknown, unknown>> = TThrowOnError extends true ? TResultWithException : TResultWithoutException;
-type ResultModeMap<TData = DefaultDataType, TErrorData = DefaultDataType, TThrowOnError extends ThrowOnErrorBoolean = DefaultThrowOnError, TComputedResult extends GetCallApiResult<TThrowOnError, CallApiResultSuccessVariant<TData>, CallApiResultSuccessOrErrorVariant<TData, TErrorData>> = GetCallApiResult<TThrowOnError, CallApiResultSuccessVariant<TData>, CallApiResultSuccessOrErrorVariant<TData, TErrorData>>> = UnmaskType<{
-  all: TComputedResult;
-  fetchApi: TComputedResult["response"];
-  onlyData: TComputedResult["data"];
-  onlyResponse: TComputedResult["response"];
-  withoutResponse: Prettify<DistributiveOmit<TComputedResult, "response">>;
-}>;
-type ResultModePlaceholder = null;
-type ResultModeUnion = keyof ResultModeMap;
-type ResultModeType = ResultModePlaceholder | ResultModeUnion;
-type InferCallApiResult<TData, TErrorData, TResultMode extends ResultModeType, TThrowOnError extends ThrowOnErrorBoolean, TComputedResultModeMapWithException extends ResultModeMap<TData, TErrorData, true> = ResultModeMap<TData, TErrorData, true>, TComputedResultModeMapWithoutException extends ResultModeMap<TData, TErrorData, TThrowOnError> = ResultModeMap<TData, TErrorData, TThrowOnError>> = TErrorData extends false ? TComputedResultModeMapWithException["onlyData"] : TErrorData extends false | undefined ? TComputedResultModeMapWithException["onlyData"] : ResultModePlaceholder extends TResultMode ? TComputedResultModeMapWithoutException["all"] : TResultMode extends ResultModeUnion ? TComputedResultModeMapWithoutException[TResultMode] : never;
-type ErrorInfoOptions = Pick<CallApiExtraOptions, "cloneResponse" | "resultMode"> & {
-  message?: string;
-};
-//#endregion
-//#region src/middlewares.d.ts
-type FetchImpl = UnmaskType<(input: string | Request | URL, init?: RequestInit) => Awaitable<Response>>;
-type FetchMiddlewareContext<TCallApiContext extends CallApiContext> = RequestContext<TCallApiContext> & {
-  fetchImpl: FetchImpl;
+//#region src/types/options-types.d.ts
+interface Register {}
+type GlobalMeta = Register extends {
+  meta?: infer TMeta extends DefaultMetaObject;
+} ? TMeta : DefaultMetaObject;
+type FetchSpecificKeysUnion = Exclude<(typeof fetchSpecificKeys)[number], "body" | "headers" | "method">;
+type ModifiedRequestInit = RequestInit & {
+  duplex?: "half";
+  /**
+   * Custom fetch options that are merged into the final request configuration.
+   *
+   * This property is intended for environment-specific extensions not included in the standard web `RequestInit` type, such as `dispatcher` for Undici/Node.js or the `next` object for Next.js extended fetch.
+   */
+  extraFetchOptions?: RequestInit;
 };
-interface Middlewares<TCallApiContext extends NoInfer<CallApiContext> = DefaultCallApiContext> {
+type CallApiRequestOptions<TBody = Body> = {
   /**
-   * Wraps the fetch implementation to intercept requests at the network layer.
+   * Body of the request, can be a object or any other supported body type.
+   */
+  body?: TBody;
+  /**
+   * Headers to be used in the request.
+   */
+  headers?: HeadersOption;
+  /**
+   * HTTP method for the request.
+   * @default "GET"
+   */
+  method?: MethodUnion;
+} & Pick<ModifiedRequestInit, FetchSpecificKeysUnion>;
+type SharedExtraOptions<TCallApiContext extends CallApiContext = DefaultCallApiContext, TData = DefaultDataType, TErrorData = DefaultDataType, TResultMode extends ResultModeType = ResultModeType, TThrowOnError extends ThrowOnErrorBoolean = DefaultThrowOnError, TResponseType extends ResponseTypeType = ResponseTypeType, TBody = Body> = DedupeOptions & HookConfigOptions & HooksOrHooksArray<NoInferUnMasked<TCallApiContext>> & Middlewares<NoInferUnMasked<TCallApiContext>> & RefetchOptions & ResultModeOption<TErrorData, TResultMode> & RetryOptions<TErrorData> & Partial<TCallApiContext["InferredExtraOptions"]> & ThrowOnErrorOption<TErrorData, TThrowOnError> & URLOptions & {
+  /**
+   * Automatically add an Authorization header value.
    *
-   * Takes a context object containing the current fetch function and returns a new fetch function.
-   * Use it to cache responses, add logging, handle offline mode, or short-circuit requests etc.
-   * Multiple middleware compose in order: plugins → base config → per-request.
+   * Supports multiple authentication patterns:
+   * - String: Direct authorization header value
+   * - Auth object: Structured authentication configuration
    *
-   * Unlike `customFetchImpl`, middleware can call through to the original fetch.
+   * ```
+   */
+  auth?: AuthOption;
+  /**
+   * Custom function to serialize request body objects into strings.
+   *
+   * Useful for custom string serialization formats or when the default JSON
+   * serialization doesn't meet your needs.
    *
    * @example
    * ```ts
-   * // Cache responses
-   * const cache = new Map();
-   *
-   * fetchMiddleware: (ctx) => async (input, init) => {
-   *   const key = input.toString();
+   * // XML serialization
+   * bodySerializer: (body) => {
+   *   return `<request>${Object.entries(body)
+   *     .map(([key, value]) => `<${key}>${value}</${key}>`)
+   *     .join('')}</request>`;
+   * }
    *
-   *   const cachedResponse = cache.get(key);
+   * // Custom JSON with specific formatting
+   * bodySerializer: (body) => JSON.stringify(body, null, 2)
+   * ```
+   */
+  bodySerializer?: (body: TBody extends SerializableObject ? TBody : SerializableObject) => string;
+  /**
+   * Custom function to transform the request body before it is passed to fetch.
    *
-   *   if (cachedResponse) {
-   *	    return cachedResponse.clone();
-   *   }
+   * Useful for converting plain objects into formats like `FormData`,
+   * `URLSearchParams`, `Blob`, or other Fetch-compatible body values.
    *
-   *   const response = await ctx.fetchImpl(input, init);
-   *   cache.set(key, response.clone());
+   * Takes precedence over `bodySerializer`.
    *
-   *   return response;
-   * }
+   * @example
+   * ```ts
+   * bodyTransformer: ({ body }) => {
+   *   const formData = new FormData();
    *
-   * // Handle offline
-   * fetchMiddleware: (ctx) => async (...parameters) => {
-   *   if (!navigator.onLine) {
-   *     return new Response('{"error": "offline"}', { status: 503 });
-   *   }
+   *   Object.entries(body).forEach(([key, value]) => {
+   *     formData.append(key, String(value));
+   *   });
    *
-   *   return ctx.fetchImpl(...parameters);
+   *   return formData;
    * }
    * ```
    */
-  fetchMiddleware?: (context: FetchMiddlewareContext<TCallApiContext>) => FetchImpl;
-}
-//#endregion
-//#region src/plugins.d.ts
-type PluginSetupContext<TCallApiContext extends CallApiContext = DefaultCallApiContext> = RequestContext<TCallApiContext> & ReturnType<typeof getCurrentRouteSchemaKeyAndMainInitURL>;
-type PluginInitResult<TCallApiContext extends CallApiContext = DefaultCallApiContext> = Partial<Omit<PluginSetupContext<TCallApiContext>, "initURL" | "request"> & {
-  initURL: InitURLOrURLObject;
-  request: CallApiRequestOptions;
-}>;
-type GetDefaultDataTypeForPlugins<TData> = DefaultDataType extends TData ? never : TData;
-type PluginHooks<TCallApiContext extends CallApiContext = DefaultCallApiContext> = HooksOrHooksArray<OverrideCallApiContext<TCallApiContext, {
-  Data: GetDefaultDataTypeForPlugins<TCallApiContext["Data"]>;
-  ErrorData: GetDefaultDataTypeForPlugins<TCallApiContext["ErrorData"]>;
-}>>;
-type PluginMiddlewares<TCallApiContext extends CallApiContext = DefaultCallApiContext> = Middlewares<OverrideCallApiContext<TCallApiContext, {
-  Data: GetDefaultDataTypeForPlugins<TCallApiContext["Data"]>;
-  ErrorData: GetDefaultDataTypeForPlugins<TCallApiContext["ErrorData"]>;
-}>>;
-interface CallApiPlugin<TCallApiContext extends CallApiContext = DefaultCallApiContext> {
+  bodyTransformer?: (context: {
+    body: TBody;
+    headers: Headers;
+  }) => Body;
   /**
-   * Defines additional options that can be passed to callApi
+   * 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
    */
-  defineExtraOptions?: () => TCallApiContext["InferredExtraOptions"];
+  cloneResponse?: boolean;
   /**
-   * A description for the plugin
+   * 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
+   *   });
+   * }
+   * ```
    */
-  description?: string;
+  customFetchImpl?: FetchImpl;
   /**
-   * Hooks for the plugin
+   * Enable debug mode for the request.
+   *
+   * @default true
    */
-  hooks?: PluginHooks<TCallApiContext> | ((context: PluginSetupContext<TCallApiContext>) => Awaitable<PluginHooks<TCallApiContext>> | Awaitable<void>);
+  debugMode?: boolean;
   /**
-   *  A unique id for the plugin
+   * 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})`;
+   * }
+   * ```
    */
-  id: string;
+  defaultHTTPErrorMessage?: string | ((context: Pick<HTTPError<TErrorData>, "errorData" | "response">) => string);
   /**
-   * Middlewares that for the plugin
+   * 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: (text) => {
+   *   return JSON.parse(text);
+   * }
+   *
+   * // Parse XML responses
+   * responseParser: (text) => {
+   *   const parser = new DOMParser();
+   *   const doc = parser.parseFromString(text, "text/xml");
+   *   return xmlToObject(doc);
+   * }
+   *
+   * // Parse CSV responses
+   * responseParser: (text) => {
+   *   const lines = text.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;
+   * }
+   *
+   * ```
    */
-  middlewares?: PluginMiddlewares<TCallApiContext> | ((context: PluginSetupContext<TCallApiContext>) => Awaitable<PluginMiddlewares<TCallApiContext>> | Awaitable<void>);
+  responseParser?: ResponseParser<TData>;
   /**
-   * A name for the plugin
+   * 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" });
+   *
+   * // 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" });
+   * ```
    */
-  name: string;
+  responseType?: TResponseType;
   /**
-   * Base schema for the client.
-   */
-  schema?: BaseCallApiSchemaAndConfig;
+     * Dictates how CallApi processes and returns the final result
+     *
+    - **"all"** (default): Returns `{ data, error, response }`. Standard lifecycle.
+    - **"onlyData"**: Returns only the data from the response.
+    - **"onlyResponse"**: Returns only the `Response` object.
+    - **"fetchApi"**: Also returns only the `Response` object, but also skips parsing of the response body internally and data/errorData schema validation.
+    - **"withoutResponse"**: Returns `{ data, error }`. Standard lifecycle, but omits the `response` property.
+     *
+     *
+     * **Note:**
+     * By default, simplified modes (`"onlyData"`, `"onlyResponse"`, `"fetchApi"`) do not throw errors.
+     *	Success/failure should be handled via hooks or by checking the return value (e.g., `if (data)` or `if (response?.ok)`).
+     * To force an exception instead, set `throwOnError: true`.
+     *
+     *
+     * @default "all"
+     *
+     */
+  resultMode?: TResultMode;
   /**
-   * 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<TCallApiContext>) => Awaitable<PluginInitResult<TCallApiContext>> | Awaitable<void>;
-  /**
-   *  A version for the plugin
-   */
-  version?: string;
-}
-type InferPluginExtraOptions<TPluginArray extends CallApiPlugin[]> = UnionToIntersection<TPluginArray extends Array<infer TPlugin> ? TPlugin extends CallApiPlugin ? TPlugin["defineExtraOptions"] extends AnyFunction<infer TResult> ? InferSchemaOutput<TResult, TResult> : never : never : never>;
-//#endregion
-//#region src/types/default-types.d.ts
-type DefaultDataType = unknown;
-type DefaultPluginArray = CallApiPlugin[];
-type DefaultThrowOnError = boolean;
-type DefaultMetaObject = Record<string, unknown>;
-type DefaultCallApiContext = Prettify<OverrideCallApiContext<Required<CallApiContext>, {
-  Meta: GlobalMeta;
-}>>;
-//#endregion
-//#region src/utils/external/body.d.ts
-type BodyType = NonNullable<CallApiRequestOptions["body"]>;
-declare const toSearchParams: <TSchema extends CallApiSchemaType<BodyType>>(data: InferSchemaOutput<TSchema>, schema?: TSchema) => URLSearchParams;
-declare const toQueryString: <TSchema extends CallApiSchemaType<BodyType>>(...parameters: Parameters<typeof toSearchParams<TSchema>>) => string;
-/**
- * @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" }
- * });
- */
-declare const toFormData: <TSchema extends CallApiSchemaType<BodyType>>(data: InferSchemaOutput<TSchema>, schema?: TSchema) => FormData;
-//#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">;
-  <const TBaseConfig extends BaseConfigObject>(baseConfig: (...parameters: Parameters<BaseConfigFn>) => Writeable<TBaseConfig, "deep">): typeof baseConfig;
-};
-declare const defineBaseConfig: DefineBaseConfig;
-declare const defineInstanceConfig: <const TInstanceConfig extends CallApiConfig>(config: TInstanceConfig) => Writeable<typeof config, "deep">;
-//#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/utils/external/headers.d.ts
-declare const objectifyHeaders: (headers: CallApiRequestOptions["headers"]) => Record<string, string>;
-//#endregion
-//#region src/retry.d.ts
-declare const defaultRetryStatusCodesLookup: () => Readonly<{
-  408: "Request Timeout";
-  409: "Conflict";
-  425: "Too Early";
-  429: "Too Many Requests";
-  500: "Internal Server Error";
-  502: "Bad Gateway";
-  503: "Service Unavailable";
-  504: "Gateway Timeout";
-}>;
-type RetryStatusCodes = UnmaskType<AnyNumber | keyof ReturnType<typeof defaultRetryStatusCodesLookup>>;
-type RetryCondition<TErrorData> = (context: ErrorContext<{
-  ErrorData: TErrorData;
-}>) => Awaitable<boolean>;
-type CallApiLooseImpl = (initURL: InitURLOrURLObject, init?: CallApiConfig) => Promise<CallApiResultLoose<unknown, unknown>>;
-interface RetryOptions<TErrorData> {
-  /**
-   * Tracks the number of times the request has already been retried internally
-   * @internal
-   * @deprecated **WARNING**: This property is used internally to track retries. Please abstain from reading or modifying it.
-   */
-  readonly ["~retryAttemptCount"]?: number;
-  /**
-   * Number of allowed retry attempts on HTTP errors
-   * @default 0
-   */
-  retryAttempts?: number;
-  /**
-   * Callback whose return value determines if a request should be retried or not
-   */
-  retryCondition?: RetryCondition<TErrorData>;
-  /**
-   * Delay between retries in milliseconds
-   * @default 1000
-   */
-  retryDelay?: number | ((currentAttemptCount: number) => number);
-  /**
-   * Maximum delay in milliseconds. Only applies to exponential strategy
-   * @default 10000
-   */
-  retryMaxDelay?: number;
-  /**
-   * HTTP methods that are allowed to retry
-   * @default ["GET", "POST"]
-   */
-  retryMethods?: MethodUnion[];
-  /**
-   * HTTP status codes that trigger a retry
-   */
-  retryStatusCodes?: RetryStatusCodes[];
-  /**
-   * Strategy to use when retrying
-   * @default "linear"
-   */
-  retryStrategy?: "exponential" | "linear";
-}
-type RetryManagerContext = {
-  callApi: CallApiLooseImpl;
-  callApiArgs: {
-    config: CallApiConfig;
-    initURL: InitURLOrURLObject;
-  };
-  error: unknown;
-  errorContext: ErrorContext;
-  hookInfo: ExecuteHookInfo;
-  removeDedupeCacheEntry: () => void;
-};
-//#endregion
-//#region src/refetch.d.ts
-declare const shouldAttemptRefetchSymbol: unique symbol;
-interface RefetchOptions {
-  /**
-   * Tracks if the refetching of the request should be attempted
-   * @internal
-   * @deprecated **WARNING**: This property is used internally to track retries. Please abstain from reading or modifying it.
-   */
-  [shouldAttemptRefetchSymbol]?: boolean;
-}
-type RefetchFn = () => void;
-type RefetchManagerResult = {
-  handleRefetch: () => Promise<CallApiResultLoose<unknown, unknown>> | null;
-  refetch: RefetchFn;
-};
-declare const createRefetchManager: (ctx: Pick<RetryManagerContext, "callApi" | "callApiArgs" | "removeDedupeCacheEntry"> & {
-  options: CallApiExtraOptions;
-}) => RefetchManagerResult;
-type RefetchFnOption = Pick<ReturnType<typeof createRefetchManager>, "refetch">;
-//#endregion
-//#region src/stream.d.ts
-type StreamProgressEvent = {
-  /**
-   * Current chunk of data being streamed.
-   *
-   * Will be `null` on the final completion tick (when progress reaches 100%).
-   */
-  chunk: Uint8Array | null;
-  /**
-   * Progress in percentage
-   */
-  progress: number;
-  /**
-   * Total size of data in bytes
-   */
-  totalBytes: number;
-  /**
-   * Amount of data transferred so far
-   */
-  transferredBytes: number;
-};
-//#endregion
-//#region src/hooks.d.ts
-type CallApiRequestOptionsForHooks = Omit<CallApiRequestOptions, "headers"> & {
-  headers: Partial<Record<"Authorization" | "Content-Type" | CommonRequestHeaders, string>>;
-};
-type CallApiExtraOptionsForHooks<TCallApiContext extends CallApiContext = DefaultCallApiContext> = Hooks & Omit<CallApiExtraOptions<TCallApiContext>, keyof Hooks> & Pick<RefetchFnOption, "refetch">;
-interface Hooks<TCallApiContext extends CallApiContext = DefaultCallApiContext> {
-  /**
-   * Hook called when any error occurs within the request/response lifecycle.
-   *
-   * This is a unified error handler that catches both request errors (network failures,
-   * timeouts, etc.) and response errors (HTTP error status codes). It's essentially
-   * a combination of `onRequestError` and `onResponseError` hooks.
-   *
-   * @param context - Error context containing error details, request info, and response (if available)
-   * @returns Promise or void - Hook can be async or sync
-   */
-  onError?: (context: ErrorContext<TCallApiContext>) => Awaitable<unknown>;
-  /**
-   * Hook called before the HTTP request is sent and before any internal processing of the request object begins.
-   *
-   * This is the ideal place to modify request headers, add authentication,
-   * implement request logging, or perform any setup before the network call.
-   *
-   * @param context - Request context with mutable request object and configuration
-   * @returns Promise or void - Hook can be async or sync
-   *
-   */
-  onRequest?: (context: RequestContext<TCallApiContext>) => Awaitable<unknown>;
-  /**
-   * Hook called when an error occurs during the fetch request itself.
-   *
-   * This handles network-level errors like connection failures, timeouts,
-   * DNS resolution errors, or other issues that prevent getting an HTTP response.
-   * Note that HTTP error status codes (4xx, 5xx) are handled by `onResponseError`.
-   *
-   * @param context - Request error context with error details and null response
-   * @returns Promise or void - Hook can be async or sync
-   */
-  onRequestError?: (context: RequestErrorContext<TCallApiContext>) => Awaitable<unknown>;
-  /**
-   * Hook called just before the HTTP request is sent and after the request has been processed.
-   *
-   * @param context - Request context with mutable request object and configuration
-   */
-  onRequestReady?: (context: RequestContext<TCallApiContext>) => 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<TCallApiContext>) => 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<TCallApiContext>) => 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<TCallApiContext>) => 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<TCallApiContext>) => 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
+   * Controls whether errors are thrown as exceptions or returned in the result.
    *
-   */
-  onRetry?: (context: RetryContext<TCallApiContext>) => Awaitable<unknown>;
-  /**
-   * Hook called when a successful response (2xx status) is received from the API.
+   * 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.
    *
-   * 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.
+   * @default false
    *
-   * @param context - Success context with parsed response data and response object
-   * @returns Promise or void - Hook can be async or sync
+   * @example
+   * ```ts
+   * // Always throw errors
+   * throwOnError: true
+   * try {
+   *   const data = await callApi("/users");
+   *   console.log("Users:", data);
+   * } catch (error) {
+   *   console.error("Request failed:", error);
+   * }
    *
-   */
-  onSuccess?: (context: SuccessContext<TCallApiContext>) => Awaitable<unknown>;
-  /**
-   * Hook called when a validation error occurs.
+   * // Never throw errors (default)
+   * throwOnError: false
+   * const { data, error } = await callApi("/users");
+   * if (error) {
+   *   console.error("Request failed:", error);
+   * }
    *
-   * 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.
+   * // 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;
+   * }
    *
-   * @param context - Validation error context with error details and response (if available)
-   * @returns Promise or void - Hook can be async or sync
+   * // 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";
+   * }
+   * ```
    */
-  onValidationError?: (context: ValidationErrorContext<TCallApiContext>) => Awaitable<unknown>;
-}
-type HooksOrHooksArray<TCallApiContext extends NoInfer<CallApiContext> = DefaultCallApiContext> = { [Key in keyof Hooks<TCallApiContext>]: Hooks<TCallApiContext>[Key] | Array<Hooks<TCallApiContext>[Key]>; };
-interface HookConfigOptions {
+  throwOnError?: ThrowOnErrorType<TErrorData, TThrowOnError>;
   /**
-   * 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).
+   * Request timeout in milliseconds. Request will be aborted if it takes longer.
    *
-   * @default "parallel"
-   */
-  hooksExecutionMode?: "parallel" | "sequential";
-}
-type RequestContext<TCallApiContext extends Pick<CallApiContext, "InferredExtraOptions" | "Meta"> = DefaultCallApiContext> = {
-  /**
-   * Base configuration object passed to createFetchClient.
+   * Useful for preventing requests from hanging indefinitely and providing
+   * better user experience with predictable response times.
    *
-   * 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.
+   * @example
+   * ```ts
+   * // 5 second timeout
+   * timeout: 5000
    *
-   * Contains configuration specific to this particular API call, which
-   * can override or extend the base configuration.
-   */
-  config: CallApiConfig;
-  /**
-   * Merged options combining base config, instance config, and default options.
+   * // Different timeouts for different endpoints
+   * const quickApi = createFetchClient({ timeout: 3000 }); // 3s for fast endpoints
+   * const slowApi = createFetchClient({ timeout: 30000 }); // 30s for slow operations
    *
-   * This is the final resolved configuration that will be used for the request,
-   * with proper precedence applied (instance > base > defaults).
-   */
-  options: CallApiExtraOptionsForHooks<TCallApiContext>;
-  /**
-   * Merged request object ready to be sent.
+   * // Per-request timeout override
+   * await callApi("/quick-data", { timeout: 1000 });
+   * await callApi("/slow-report", { timeout: 60000 });
    *
-   * 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.
+   * // No timeout (use with caution)
+   * timeout: 0
+   * ```
    */
-  request: CallApiRequestOptionsForHooks;
-};
-type SuccessContext<TCallApiContext extends Pick<CallApiContext, "Data" | "InferredExtraOptions" | "Meta"> = DefaultCallApiContext> = DistributiveOmit<CallApiResultSuccessVariant<TCallApiContext["Data"]>, "error"> & RequestContext<TCallApiContext>;
-type ResponseContext<TCallApiContext extends Pick<CallApiContext, "Data" | "ErrorData" | "InferredExtraOptions" | "Meta"> = DefaultCallApiContext> = RequestContext<TCallApiContext> & (Prettify<CallApiResultSuccessVariant<TCallApiContext["Data"]>> | Prettify<Extract<CallApiResultErrorVariant<TCallApiContext["ErrorData"]>, {
-  error: PossibleHTTPError<TCallApiContext["ErrorData"]>;
-}>>);
-type RequestStreamContext<TCallApiContext extends Pick<CallApiContext, "InferredExtraOptions" | "Meta"> = DefaultCallApiContext> = RequestContext<TCallApiContext> & {
-  event: StreamProgressEvent;
-  requestInstance: Request;
-};
-type ResponseStreamContext<TCallApiContext extends Pick<CallApiContext, "InferredExtraOptions" | "Meta"> = DefaultCallApiContext> = RequestContext<TCallApiContext> & {
-  event: StreamProgressEvent;
-  response: Response;
-};
-type ErrorContext<TCallApiContext extends Pick<CallApiContext, "ErrorData" | "InferredExtraOptions" | "Meta"> = DefaultCallApiContext> = DistributiveOmit<CallApiResultErrorVariant<TCallApiContext["ErrorData"]>, "data"> & RequestContext<TCallApiContext>;
-type ValidationErrorContext<TCallApiContext extends Pick<CallApiContext, "InferredExtraOptions" | "Meta"> = DefaultCallApiContext> = Extract<ErrorContext<TCallApiContext>, {
-  error: PossibleValidationError;
-}> & RequestContext<TCallApiContext>;
-type RequestErrorContext<TCallApiContext extends Pick<CallApiContext, "InferredExtraOptions" | "Meta"> = DefaultCallApiContext> = Extract<ErrorContext<TCallApiContext>, {
-  error: PossibleJavaScriptError;
-}> & RequestContext<TCallApiContext>;
-type ResponseErrorContext<TCallApiContext extends Pick<CallApiContext, "ErrorData" | "InferredExtraOptions" | "Meta"> = DefaultCallApiContext> = Extract<ErrorContext<TCallApiContext>, {
-  error: PossibleHTTPError<TCallApiContext["ErrorData"]>;
-}> & RequestContext<TCallApiContext>;
-type RetryContext<TCallApiContext extends Pick<CallApiContext, "ErrorData" | "InferredExtraOptions" | "Meta"> = DefaultCallApiContext> = ErrorContext<TCallApiContext> & {
-  retryAttemptCount: number;
-};
-type ExecuteHookInfo = {
-  errorInfoOptions: ErrorInfoOptions;
-  shouldThrowOnError: boolean | undefined;
+  timeout?: number;
 };
-//#endregion
-//#region src/dedupe.d.ts
-type DedupeStrategyUnion = UnmaskType<"cancel" | "defer" | "none">;
-type DedupeOptions = {
+type BaseCallApiExtraOptions<TBaseCallApiContext extends CallApiContext = DefaultCallApiContext, TBaseData = DefaultDataType, TBaseErrorData = DefaultDataType, TBaseResultMode extends ResultModeType = ResultModeType, TBaseThrowOnError extends ThrowOnErrorBoolean = DefaultThrowOnError, TBaseResponseType extends ResponseTypeType = ResponseTypeType, TBaseMeta extends DefaultMetaObject = DefaultMetaObject, TBasePluginArray extends CallApiPlugin[] = DefaultPluginArray, TBaseSchemaAndConfig extends BaseCallApiSchemaAndConfig = BaseCallApiSchemaAndConfig> = SharedExtraOptions<TBaseCallApiContext, TBaseData, TBaseErrorData, TBaseResultMode, TBaseThrowOnError, TBaseResponseType> & {
+  meta?: TBaseMeta;
   /**
-   * 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.
-   *
+   * Array of base CallApi plugins to extend library functionality.
    *
-   * **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
+   * Base plugins are applied to all instances created from this base configuration
+   * and provide foundational functionality like authentication, logging, or caching.
    *
    * @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
+   * // Add logging plugin
    *
-   * // Global scope - share cache across related clients
-   * const userClient = createFetchClient({
-   *   baseURL: "/api/users",
-   *   dedupeCacheScope: "global",
-   * });
-   * const postClient = createFetchClient({
-   *   baseURL: "/api/posts",
-   *   dedupeCacheScope: "global",
+   * // Create base client with common plugins
+   * const callApi = createFetchClient({
+   *   baseURL: "https://api.example.com",
+   *   plugins: [loggerPlugin({ enabled: true })]
    * });
-   * // These clients will share deduplication state
-   * ```
    *
-   * @default "local"
+   * // All requests inherit base plugins
+   * await callApi("/users");
+   * await callApi("/posts");
+   *
+   * ```
    */
-  dedupeCacheScope?: "global" | "local";
+  plugins?: TBasePluginArray;
   /**
-   * Unique namespace for the global deduplication cache when using `dedupeCacheScope: "global"`.
+   * Base validation schemas for the client configuration.
    *
-   * 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.
+   * Defines validation rules for requests and responses that apply to all
+   * instances created from this base configuration. Provides type safety
+   * and runtime validation for API interactions.
+   */
+  schema?: TBaseSchemaAndConfig;
+  /**
+   * Controls which configuration parts skip automatic merging between base and instance configs.
    *
-   * **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
+   * 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.
    *
-   * **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
+   * @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
-   * // 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
-   * });
+   * // Skip all automatic merging - full manual control
+   * const client = callApi.create((ctx) => ({
+   *   skipAutoMergeFor: "all",
    *
-   * // Separate analytics client with its own cache
-   * const analyticsClient = createFetchClient({
-   *   baseURL: "/api/analytics",
-   *   dedupeCacheScope: "global",
-   *   dedupeCacheScopeKey: "analytics-service" // Different scope
-   * });
+   *   // 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
+   *   }
+   * }));
    *
-   * // Environment-specific scoping
-   * const apiClient = createFetchClient({
-   *   dedupeCacheScope: "global",
-   *   dedupeCacheScopeKey: `api-${process.env.NODE_ENV}` // "api-development", "api-production", etc.
-   * });
+   * // Skip options merging - manual plugin/hook control
+   * const client = callApi.create((ctx) => ({
+   *   skipAutoMergeFor: "options",
+   *
+   *   // Manually control which plugins to use
+   *   plugins: [
+   *     ...ctx.options.plugins?.filter(p => p.name !== "unwanted") || [],
+   *     customPlugin
+   *   ],
+   *
+   *   // Request options still auto-merge
+   *   method: "POST"
+   * }));
+   *
+   * // Skip request merging - manual request control
+   * const client = callApi.create((ctx) => ({
+   *   skipAutoMergeFor: "request",
+   *
+   *   // Extra options still auto-merge (plugins, hooks, etc.)
+   *
+   *   // Manually control request options
+   *   headers: {
+   *     "Content-Type": "application/json",
+   *     // Don't merge base headers
+   *   },
+   *   method: ctx.request.method || "GET"
+   * }));
+   *
+   * // Use case: Conditional merging based on request
+   * const client = createFetchClient((ctx) => ({
+   *   skipAutoMergeFor: "options",
+   *
+   *   // Only use auth plugin for protected routes
+   *   plugins: ctx.initURL.includes("/protected/")
+   *     ? [...(ctx.options.plugins || []), authPlugin]
+   *     : ctx.options.plugins?.filter(p => p.name !== "auth") || []
+   * }));
    * ```
+   */
+  skipAutoMergeFor?: "all" | "options" | "request";
+};
+type GetBaseSchemaRoutes<TBaseSchemaAndConfig extends BaseCallApiSchemaAndConfig> = Writeable<TBaseSchemaAndConfig["routes"], "deep">;
+type GetBaseSchemaConfig<TBaseSchemaAndConfig extends BaseCallApiSchemaAndConfig> = Writeable<NonNullable<TBaseSchemaAndConfig["config"]>, "deep">;
+type InferExtendSchemaContext<TBaseSchemaRoutes extends BaseCallApiSchemaRoutes, TCurrentRouteSchemaKey extends string> = {
+  baseSchemaRoutes: TBaseSchemaRoutes;
+  currentRouteSchema: GetCurrentRouteSchema<TBaseSchemaRoutes, TCurrentRouteSchemaKey>;
+  currentRouteSchemaKey: TCurrentRouteSchemaKey;
+};
+type GetExtendSchemaConfigContext<TBaseSchemaConfig extends CallApiSchemaConfig> = {
+  baseSchemaConfig: TBaseSchemaConfig;
+};
+type InferExtendPluginContext<TBasePluginArray extends CallApiPlugin[]> = {
+  basePlugins: TBasePluginArray;
+};
+type CallApiExtraOptions<TCallApiContext extends CallApiContext = DefaultCallApiContext, TData = DefaultDataType, TErrorData = DefaultDataType, TResultMode extends ResultModeType = ResultModeType, TThrowOnError extends ThrowOnErrorBoolean = DefaultThrowOnError, TResponseType extends ResponseTypeType = ResponseTypeType, TBasePluginArray extends CallApiPlugin[] = DefaultPluginArray, TPluginArray extends CallApiPlugin[] = DefaultPluginArray, TBaseSchemaRoutes extends BaseCallApiSchemaRoutes = BaseCallApiSchemaRoutes, TSchema extends CallApiSchema = CallApiSchema, TBaseSchemaConfig extends CallApiSchemaConfig = CallApiSchemaConfig, TSchemaConfig extends CallApiSchemaConfig = CallApiSchemaConfig, TCurrentRouteSchemaKey extends string = string, TBody extends InferSchemaOutput<TSchema["body"], Body> = InferSchemaOutput<TSchema["body"], Body>> = InferRequiredExtraOptions<TSchema, TBaseSchemaRoutes, TCurrentRouteSchemaKey, TCallApiContext> & Omit<SharedExtraOptions<TCallApiContext, TData, TErrorData, TResultMode, TThrowOnError, TResponseType, TBody>, keyof InferRequiredExtraOptions<CallApiSchema, BaseCallApiSchemaRoutes, string, CallApiContext>> & {
+  /**
+   * Array of instance-specific CallApi plugins or a function to configure plugins.
+   *
+   * Instance plugins are added to the base plugins and provide functionality
+   * specific to this particular API instance. Can be a static array or a function
+   * that receives base plugins and returns the instance plugins.
    *
-   * @default "default"
    */
-  dedupeCacheScopeKey?: "default" | AnyString | ((context: RequestContext) => string | undefined);
+  plugins?: TPluginArray | ((context: InferExtendPluginContext<TBasePluginArray>) => TPluginArray);
   /**
-   * Custom key generator for request deduplication.
+   * For instance-specific validation schemas
    *
-   * 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.).
+   * Defines validation rules specific to this API instance, extending or overriding the base schema.
    *
-   * **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.)
+   * Can be a static schema object or a function that receives base schema context and returns instance schemas.
    *
-   * **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
+   */
+  schema?: TSchema | ((context: InferExtendSchemaContext<TBaseSchemaRoutes, TCurrentRouteSchemaKey>) => TSchema);
+  /**
+   * 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 | ((context: GetExtendSchemaConfigContext<TBaseSchemaConfig>) => TSchemaConfig);
+};
+type InstanceContext = {
+  initURL: string;
+  options: CallApiExtraOptions;
+  request: CallApiRequestOptions;
+};
+type BaseCallApiConfig<TBaseCallApiContext extends CallApiContext = DefaultCallApiContext, TBaseData = DefaultDataType, TBaseErrorData = DefaultDataType, TBaseResultMode extends ResultModeType = ResultModeType, TBaseThrowOnError extends ThrowOnErrorBoolean = DefaultThrowOnError, TBaseResponseType extends ResponseTypeType = ResponseTypeType, TBaseMeta extends DefaultMetaObject = DefaultMetaObject, TBaseSchemaAndConfig extends BaseCallApiSchemaAndConfig = BaseCallApiSchemaAndConfig, TBasePluginArray extends CallApiPlugin[] = DefaultPluginArray, TComputedBaseExtraOptions = BaseCallApiExtraOptions<TBaseCallApiContext, TBaseData, TBaseErrorData, TBaseResultMode, TBaseThrowOnError, TBaseResponseType, TBaseMeta, TBasePluginArray, TBaseSchemaAndConfig>> = (CallApiRequestOptions & TComputedBaseExtraOptions) | ((context: InstanceContext) => CallApiRequestOptions & TComputedBaseExtraOptions);
+type CallApiConfig<TCallApiContext extends CallApiContext = DefaultCallApiContext, TData = DefaultDataType, TErrorData = DefaultDataType, TResultMode extends ResultModeType = ResultModeType, TThrowOnError extends ThrowOnErrorBoolean = DefaultThrowOnError, TResponseType extends ResponseTypeType = ResponseTypeType, TBaseSchemaRoutes extends BaseCallApiSchemaRoutes = BaseCallApiSchemaRoutes, TSchema extends CallApiSchema = CallApiSchema, TBaseSchemaConfig extends CallApiSchemaConfig = CallApiSchemaConfig, TSchemaConfig extends CallApiSchemaConfig = CallApiSchemaConfig, TInitURL extends InitURLOrURLObject = InitURLOrURLObject, TCurrentRouteSchemaKey extends string = string, TBody extends InferSchemaOutput<TSchema["body"], Body> = InferSchemaOutput<TSchema["body"], Body>, TBasePluginArray extends CallApiPlugin[] = DefaultPluginArray, TPluginArray extends CallApiPlugin[] = DefaultPluginArray> = CallApiExtraOptions<TCallApiContext, TData, TErrorData, TResultMode, TThrowOnError, TResponseType, TBasePluginArray, TPluginArray, TBaseSchemaRoutes, TSchema, TBaseSchemaConfig, TSchemaConfig, TCurrentRouteSchemaKey, TBody> & InferRequestOptions<TSchema, TInitURL, TBody> & Omit<CallApiRequestOptions<TBody>, keyof InferRequestOptions<CallApiSchema, string>>;
+type CallApiParameters<TData = DefaultDataType, TErrorData = DefaultDataType, TResultMode extends ResultModeType = ResultModeType, TCallApiContext extends CallApiContext = DefaultCallApiContext, TThrowOnError extends ThrowOnErrorBoolean = DefaultThrowOnError, TResponseType extends ResponseTypeType = ResponseTypeType, TBaseSchemaRoutes extends BaseCallApiSchemaRoutes = BaseCallApiSchemaRoutes, TSchema extends CallApiSchema = CallApiSchema, TBaseSchemaConfig extends CallApiSchemaConfig = CallApiSchemaConfig, TSchemaConfig extends CallApiSchemaConfig = CallApiSchemaConfig, TInitURL extends InitURLOrURLObject = InitURLOrURLObject, TCurrentRouteSchemaKey extends string = string, TBody extends InferSchemaOutput<TSchema["body"], Body> = InferSchemaOutput<TSchema["body"], Body>, TBasePluginArray extends CallApiPlugin[] = DefaultPluginArray, TPluginArray extends CallApiPlugin[] = DefaultPluginArray, TComputedRequiredOptions = InferRequestOptions<TSchema, TInitURL, TBody> & InferRequiredExtraOptions<TSchema, TBaseSchemaRoutes, TCurrentRouteSchemaKey, TCallApiContext>, TComputedConfig = CallApiConfig<TCallApiContext, TData, TErrorData, TResultMode, TThrowOnError, TResponseType, TBaseSchemaRoutes, TSchema, TBaseSchemaConfig, TSchemaConfig, TInitURL, TCurrentRouteSchemaKey, TBody, TBasePluginArray, TPluginArray>> = NonNullableUnknown extends TComputedRequiredOptions ? [initURL: TInitURL, config?: TComputedConfig] : [initURL: TInitURL, config: TComputedConfig];
+type CallApiResult<TData, TErrorData, TResultMode extends ResultModeType, TThrowOnError extends ThrowOnErrorBoolean> = InferCallApiResult<TData, TErrorData, TResultMode, TThrowOnError>;
+type CallApiResultLoose<TData, TErrorData, TResultMode extends ResultModeType = ResultModeType, TThrowOnError extends ThrowOnErrorBoolean = ThrowOnErrorBoolean> = InferCallApiResult<TData, TErrorData, TResultMode, TThrowOnError>;
+//#endregion
+//#region src/auth.d.ts
+type PossibleAuthValue = Awaitable<string | null | undefined>;
+type PossibleAuthValueOrGetter = PossibleAuthValue | (() => PossibleAuthValue);
+type BearerAuth = {
+  type: "Bearer";
+  value: PossibleAuthValueOrGetter;
+};
+type TokenAuth = {
+  type: "Token";
+  value: PossibleAuthValueOrGetter;
+};
+type BasicAuth = {
+  type: "Basic";
+  username: PossibleAuthValueOrGetter;
+  password: PossibleAuthValueOrGetter;
+};
+/**
+ * Custom auth
+ *
+ * @param prefix - prefix of the header
+ * @param authValue - value of the header
+ *
+ * @example
+ * ```ts
+ * {
+ *  type: "Custom",
+ *  prefix: "Token",
+ *  authValue: "token"
+ * }
+ * ```
+ */
+type CustomAuth = {
+  type: "Custom";
+  prefix: PossibleAuthValueOrGetter;
+  value: PossibleAuthValueOrGetter;
+};
+type AuthOption = PossibleAuthValueOrGetter | BearerAuth | TokenAuth | BasicAuth | CustomAuth;
+//#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 MergeBaseWithRouteKey<TBaseURLOrPrefix extends string | undefined, TRouteKey extends string> = TBaseURLOrPrefix extends string ? TRouteKey extends `${AtSymbol}${infer TMethod extends RouteKeyMethods}/${infer TRestOfRoutKey}` ? `${AtSymbol}${TMethod}/${RemoveLeadingSlash<RemoveTrailingSlash<TBaseURLOrPrefix>>}/${RemoveLeadingSlash<TRestOfRoutKey>}` : `${TBaseURLOrPrefix}${TRouteKey}` : TRouteKey;
+type ApplyURLBasedConfig<TSchemaConfig extends CallApiSchemaConfig, TSchemaRouteKeys extends string> = TSchemaConfig["prefix"] extends string ? MergeBaseWithRouteKey<TSchemaConfig["prefix"], TSchemaRouteKeys> : TSchemaConfig["baseURL"] extends string ? MergeBaseWithRouteKey<TSchemaConfig["baseURL"], TSchemaRouteKeys> : TSchemaRouteKeys;
+type ApplyStrictConfig<TSchemaConfig extends CallApiSchemaConfig, TSchemaRouteKeys extends string> = TSchemaConfig["strict"] extends true ? TSchemaRouteKeys // eslint-disable-next-line perfectionist/sort-union-types -- Don't sort union types
+ : TSchemaRouteKeys | Exclude<InitURLOrURLObject, RouteKeyMethodsURLUnion>;
+type ApplySchemaConfiguration<TSchemaConfig extends CallApiSchemaConfig, TSchemaRouteKeys extends string> = ApplyStrictConfig<TSchemaConfig, ApplyURLBasedConfig<TSchemaConfig, TSchemaRouteKeys>>;
+type InferAllMainRoutes<TBaseSchemaRoutes extends BaseCallApiSchemaRoutes> = Omit<TBaseSchemaRoutes, FallBackRouteSchemaKey>;
+type InferAllMainRouteKeys<TBaseSchemaRoutes extends BaseCallApiSchemaRoutes, TSchemaConfig extends CallApiSchemaConfig> = ApplySchemaConfiguration<TSchemaConfig, Extract<keyof InferAllMainRoutes<TBaseSchemaRoutes>, string>>;
+type InferInitURL<TBaseSchemaRoutes extends BaseCallApiSchemaRoutes, TSchemaConfig extends CallApiSchemaConfig> = keyof TBaseSchemaRoutes extends never ? InitURLOrURLObject : InferAllMainRouteKeys<TBaseSchemaRoutes, TSchemaConfig>;
+type GetCurrentRouteSchemaKey<TSchemaConfig extends CallApiSchemaConfig, TPath> = TPath extends URL ? string : TSchemaConfig["prefix"] extends string ? TPath extends (`${AtSymbol}${infer TMethod extends RouteKeyMethods}/${RemoveLeadingSlash<TSchemaConfig["prefix"]>}${infer TCurrentRoute}`) ? `${AtSymbol}${TMethod}/${RemoveLeadingSlash<TCurrentRoute>}` : TPath extends `${TSchemaConfig["prefix"]}${infer TCurrentRoute}` ? TCurrentRoute : string : TSchemaConfig["baseURL"] extends string ? TPath extends (`${AtSymbol}${infer TMethod extends RouteKeyMethods}/${TSchemaConfig["baseURL"]}${infer TCurrentRoute}`) ? `${AtSymbol}${TMethod}/${RemoveLeadingSlash<TCurrentRoute>}` : TPath extends `${TSchemaConfig["baseURL"]}${infer TCurrentRoute}` ? TCurrentRoute : string : TPath;
+type GetCurrentRouteSchema<TBaseSchemaRoutes extends BaseCallApiSchemaRoutes, TCurrentRouteSchemaKey extends string, TComputedFallBackRouteSchema = TBaseSchemaRoutes[FallBackRouteSchemaKey], TComputedCurrentRouteSchema = TBaseSchemaRoutes[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 extends CallApiSchema, TBody = InferSchemaOutput<TSchema["body"], Body>> = MakeSchemaOptionRequiredIfDefined<TSchema["body"], {
+  /**
+   * Body of the request, can be a object or any other supported body type.
+   */
+  body?: TBody;
+}>;
+type MethodUnion = UnmaskType<"CONNECT" | "DELETE" | "GET" | "HEAD" | "OPTIONS" | "PATCH" | "POST" | "PUT" | "TRACE" | AnyString>;
+type ExtractMethodFromURL<TInitURL> = string extends TInitURL ? MethodUnion : TInitURL extends `${AtSymbol}${infer TMethod extends RouteKeyMethods}/${string}` ? Uppercase<TMethod> : MethodUnion;
+type InferMethodOption<TSchema extends CallApiSchema, TInitURL extends InitURLOrURLObject> = MakeSchemaOptionRequiredIfDefined<TSchema["method"], {
+  /**
+   * HTTP method for the request.
+   * @default "GET"
+   */
+  method?: InferSchemaOutput<TSchema["method"], ExtractMethodFromURL<TInitURL>>;
+}>;
+type HeadersOption = UnmaskType<Headers | Record<"Authorization", CommonAuthorizationHeaders | undefined> | Record<"Content-Type", CommonContentTypes | undefined> | Record<CommonRequestHeaders, string | undefined> | Record<string, string | undefined> | Array<[string, string]>>;
+type InferHeadersOption<TSchema extends CallApiSchema> = MakeSchemaOptionRequiredIfDefined<TSchema["headers"], {
+  /**
+   * Headers to be used in the request.
+   */
+  headers?: InferSchemaOutput<TSchema["headers"], HeadersOption> | ((context: {
+    baseHeaders: Extract<HeadersOption, Record<string, unknown>>;
+  }) => InferSchemaOutput<TSchema["headers"], HeadersOption>);
+}>;
+type InferRequestOptions<TSchema extends CallApiSchema, TInitURL extends InferInitURL<BaseCallApiSchemaRoutes, CallApiSchemaConfig>, TBody = InferSchemaOutput<TSchema["body"], Body>> = InferBodyOption<TSchema, TBody> & InferHeadersOption<TSchema> & InferMethodOption<TSchema, TInitURL>;
+type InferMetaOption<TSchema extends CallApiSchema, TCallApiContext extends CallApiContext> = MakeSchemaOptionRequiredIfDefined<TSchema["meta"], {
+  /**
+   * Optional metadata field for associating additional information with requests.
    *
-   * **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
+   * 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
-   * 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}`
+   * 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`);
+   * 		}
+   * 	},
    * });
    *
-   * // Include specific headers in deduplication
-   * const apiCall = callApi("/api/data", {
-   *   dedupeKey: (context) => {
-   *     const authHeader = context.request.headers.get("Authorization");
-   *     return `${context.options.fullURL}-${authHeader}`;
-   *   }
+   * const response = await callMainApi({
+   * 	url: "https://example.com/api/data",
+   * 	meta: { userId: "123" },
    * });
    *
-   * // User-specific deduplication
-   * const userSpecificCall = callApi("/api/dashboard", {
-   *   dedupeKey: (context) => {
-   *     const userId = context.options.fullURL.match(/user\/(\d+)/)?.[1];
-   *     return `dashboard-${userId}`;
+   * // Use case: Request tracking
+   * const result = await callMainApi({
+   *   url: "https://example.com/api/data",
+   *   meta: {
+   *     requestId: generateId(),
+   *     source: "user-dashboard",
+   *     priority: "high"
    *   }
    * });
    *
-   * // 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()}`;
+   * // Use case: Feature flags
+   * const client = callApi.create({
+   *   baseURL: "https://api.example.com",
+   *   meta: {
+   *     features: ["newUI", "betaFeature"],
+   *     experiment: "variantA"
    *   }
    * });
    * ```
-   *
-   * @default Auto-generated from request details
    */
-  dedupeKey?: string | ((context: RequestContext) => string | undefined);
+  meta?: InferSchemaOutput<TSchema["meta"], TCallApiContext["Meta"] extends DefaultMetaObject ? TCallApiContext["Meta"] : GlobalMeta>;
+}>;
+type InferAuthOption<TSchema extends CallApiSchema> = MakeSchemaOptionRequiredIfDefined<TSchema["auth"], {
   /**
-   * 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"
+     * Automatically add an Authorization header value.
+     *
+     * Supports multiple authentication patterns:
+     * - String: Direct authorization header value
+     * - Auth object: Structured authentication configuration
+     *
+     * @example
+     * ```ts
+     * // Bearer auth
+     * const response = await callMainApi({
+     * 	url: "https://example.com/api/data",
+     * 	auth: "123456",
+     * });
+     *
+     * // Bearer auth
+     * const response = await callMainApi({
+     * 	url: "https://example.com/api/data",
+     * 	auth: {
+     * 		type: "Bearer",
+     * 		value: "123456",
+     * 	},
+     })
+     *
+     * // Token auth
+     * const response = await callMainApi({
+     * 	url: "https://example.com/api/data",
+     * 	auth: {
+     * 		type: "Token",
+     * 		value: "123456",
+     * 	},
+     * });
+     *
+     * // Basic auth
+     * const response = await callMainApi({
+     * 	url: "https://example.com/api/data",
+     * 	auth: {
+     * 		type: "Basic",
+     * 		username: "username",
+     * 		password: "password",
+     * 	},
+     * });
+     *
+     * ```
+     */
+  auth?: InferSchemaOutput<TSchema["auth"], AuthOption>;
+}>;
+type InferQueryOption<TSchema extends CallApiSchema> = MakeSchemaOptionRequiredIfDefined<TSchema["query"], {
+  /**
+   * Parameters to be appended to the URL (i.e: /:id)
    */
-  dedupeStrategy?: DedupeStrategyUnion | ((context: RequestContext) => DedupeStrategyUnion);
+  query?: InferSchemaOutput<TSchema["query"], Query>;
+}>;
+type EmptyString = "";
+type EmptyTuple = readonly [];
+type StringTuple = readonly string[];
+type PossibleParamNamePatterns = `${string}:${string}` | `${string}{${string}}${"" | AnyString}`;
+type ExtractRouteParamNames<TCurrentRoute, TParamNamesAccumulator extends StringTuple = EmptyTuple> = TCurrentRoute extends PossibleParamNamePatterns ? TCurrentRoute 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 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> : NonNullableUnknown>;
+type ConvertParamNamesToTuple<TParamNames extends StringTuple> = TParamNames extends readonly [string, ...infer TRemainingParamNames extends StringTuple] ? [AllowedQueryParamValues, ...ConvertParamNamesToTuple<TRemainingParamNames>] : [];
+type InferParamsFromRoute<TCurrentRoute> = ExtractRouteParamNames<TCurrentRoute> extends StringTuple ? ExtractRouteParamNames<TCurrentRoute> extends EmptyTuple ? Params : ConvertParamNamesToRecord<ExtractRouteParamNames<TCurrentRoute>> | ConvertParamNamesToTuple<ExtractRouteParamNames<TCurrentRoute>> : Params;
+type MakeParamsOptionRequired<TParamsSchemaOption extends CallApiSchema["params"], TBaseSchemaRoutes extends BaseCallApiSchemaRoutes, TCurrentRouteSchemaKey extends string, TObject> = MakeSchemaOptionRequiredIfDefined<TParamsSchemaOption, Params extends InferParamsFromRoute<TCurrentRouteSchemaKey> ? TObject : TCurrentRouteSchemaKey extends Extract<keyof TBaseSchemaRoutes, TCurrentRouteSchemaKey> ? undefined extends InferSchemaOutput<TParamsSchemaOption, null> ? TObject : Required<TObject> : TObject>;
+type InferParamsOption<TSchema extends CallApiSchema, TBaseSchemaRoutes extends BaseCallApiSchemaRoutes, TCurrentRouteSchemaKey extends string> = MakeParamsOptionRequired<TSchema["params"], TBaseSchemaRoutes, TCurrentRouteSchemaKey, {
+  /**
+   * Parameters to be appended to the URL (i.e: /:id)
+   */
+  params?: InferSchemaOutput<TSchema["params"], InferParamsFromRoute<TCurrentRouteSchemaKey>>;
+}>;
+type InferRequiredExtraOptions<TSchema extends CallApiSchema, TBaseSchemaRoutes extends BaseCallApiSchemaRoutes, TCurrentRouteSchemaKey extends string, TCallApiContext extends CallApiContext> = InferAuthOption<TSchema> & InferMetaOption<TSchema, TCallApiContext> & InferParamsOption<TSchema, TBaseSchemaRoutes, TCurrentRouteSchemaKey> & InferQueryOption<TSchema>;
+type ResultModeOption<TErrorData, TResultMode extends ResultModeType> = TErrorData extends false ? {
+  resultMode: "onlyData";
+} : TErrorData extends false | undefined ? {
+  resultMode?: "onlyData";
+} : {
+  resultMode?: TResultMode;
+};
+type ThrowOnErrorBoolean = boolean;
+type ThrowOnErrorType<TErrorData, TThrowOnError extends ThrowOnErrorBoolean> = TThrowOnError | ((context: ErrorContext<{
+  ErrorData: TErrorData;
+}>) => TThrowOnError);
+type ThrowOnErrorOption<TErrorData, TThrowOnError extends ThrowOnErrorBoolean> = TErrorData extends false ? {
+  throwOnError: true;
+} : TErrorData extends false | undefined ? {
+  throwOnError?: true;
+} : {
+  throwOnError?: ThrowOnErrorType<TErrorData, TThrowOnError>;
+};
+//#endregion
+//#region src/result.d.ts
+type ResponseParser<TData> = (text: string) => Awaitable<TData>;
+declare const getResponseType: <TData>(response: Response, responseParser: ResponseParser<TData>) => {
+  arrayBuffer: () => Promise<ArrayBuffer>;
+  blob: () => Promise<Blob>;
+  formData: () => Promise<FormData>;
+  json: () => Promise<TData>;
+  stream: () => ReadableStream<Uint8Array<ArrayBuffer>> | null;
+  text: () => Promise<string>;
+};
+type InitResponseTypeMap<TData = unknown> = ReturnType<typeof getResponseType<TData>>;
+type ResponseTypeUnion = keyof InitResponseTypeMap;
+type ResponseTypePlaceholder = null;
+type ResponseTypeType = ResponseTypePlaceholder | ResponseTypeUnion;
+type ResponseTypeMap<TData> = { [Key in keyof InitResponseTypeMap<TData>]: Awaited<ReturnType<InitResponseTypeMap<TData>[Key]>>; };
+type GetResponseType<TData, TResponseType extends ResponseTypeType, TComputedResponseTypeMap extends ResponseTypeMap<TData> = ResponseTypeMap<TData>> = null extends TResponseType ? TComputedResponseTypeMap["json"] : TResponseType extends NonNullable<ResponseTypeType> ? TComputedResponseTypeMap[TResponseType] : never;
+type CallApiResultSuccessVariant<TData> = {
+  data: NoInferUnMasked<TData>;
+  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> = UnmaskType<{
+  errorData: NoInferUnMasked<TErrorData>;
+  message: string;
+  name: "HTTPError";
+  originalError: HTTPError;
+}>;
+type PossibleValidationError = UnmaskType<{
+  errorData: ValidationError["errorData"];
+  issueCause: ValidationError["issueCause"];
+  message: string;
+  name: "ValidationError";
+  originalError: ValidationError;
+}>;
+type CallApiResultErrorVariant<TErrorData> = {
+  data: null;
+  error: PossibleHTTPError<TErrorData>;
+  response: Response;
+} | {
+  data: null;
+  error: PossibleJavaScriptError;
+  response: Response | null;
+} | {
+  data: null;
+  error: PossibleValidationError;
+  response: Response | null;
+};
+type CallApiResultSuccessOrErrorVariant<TData, TError> = CallApiResultErrorVariant<TError> | CallApiResultSuccessVariant<TData>;
+type GetCallApiResult<TThrowOnError extends ThrowOnErrorBoolean, TResultWithException extends CallApiResultSuccessVariant<unknown>, TResultWithoutException extends CallApiResultSuccessOrErrorVariant<unknown, unknown>> = TThrowOnError extends true ? TResultWithException : TResultWithoutException;
+type ResultModeMap<TData = DefaultDataType, TErrorData = DefaultDataType, TThrowOnError extends ThrowOnErrorBoolean = DefaultThrowOnError, TComputedResult extends GetCallApiResult<TThrowOnError, CallApiResultSuccessVariant<TData>, CallApiResultSuccessOrErrorVariant<TData, TErrorData>> = GetCallApiResult<TThrowOnError, CallApiResultSuccessVariant<TData>, CallApiResultSuccessOrErrorVariant<TData, TErrorData>>> = UnmaskType<{
+  all: TComputedResult;
+  fetchApi: TComputedResult["response"];
+  onlyData: TComputedResult["data"];
+  onlyResponse: TComputedResult["response"];
+  withoutResponse: Prettify<DistributiveOmit<TComputedResult, "response">>;
+}>;
+type ResultModePlaceholder = null;
+type ResultModeUnion = keyof ResultModeMap;
+type ResultModeType = ResultModePlaceholder | ResultModeUnion;
+type InferCallApiResult<TData, TErrorData, TResultMode extends ResultModeType, TThrowOnError extends ThrowOnErrorBoolean, TComputedResultModeMapWithException extends ResultModeMap<TData, TErrorData, true> = ResultModeMap<TData, TErrorData, true>, TComputedResultModeMapWithoutException extends ResultModeMap<TData, TErrorData, TThrowOnError> = ResultModeMap<TData, TErrorData, TThrowOnError>> = TErrorData extends false ? TComputedResultModeMapWithException["onlyData"] : TErrorData extends false | undefined ? TComputedResultModeMapWithException["onlyData"] : ResultModePlaceholder extends TResultMode ? TComputedResultModeMapWithoutException["all"] : TResultMode extends ResultModeUnion ? TComputedResultModeMapWithoutException[TResultMode] : never;
+type ErrorInfoOptions = Pick<CallApiExtraOptions, "cloneResponse" | "resultMode"> & {
+  message?: string;
 };
 //#endregion
-//#region src/types/options-types.d.ts
-interface Register {}
-type GlobalMeta = Register extends {
-  meta?: infer TMeta extends DefaultMetaObject;
-} ? TMeta : DefaultMetaObject;
-interface CallApiContext {
-  Data?: DefaultDataType;
-  ErrorData?: DefaultDataType;
-  InferredExtraOptions?: unknown;
-  Meta?: DefaultMetaObject;
-  ResultMode?: ResultModeType;
-}
-type GetCallApiContext<TCallApiContext extends CallApiContext> = TCallApiContext;
-type GetCallApiContextRequired<TCallApiContext extends Required<CallApiContext>> = TCallApiContext;
-type OverrideCallApiContext<TFullCallApiContext extends CallApiContext, TOverrideCallApiContext extends CallApiContext> = Omit<TFullCallApiContext, keyof TOverrideCallApiContext> & TOverrideCallApiContext;
-type FetchSpecificKeysUnion = Exclude<(typeof fetchSpecificKeys)[number], "body" | "headers" | "method">;
-type ModifiedRequestInit = RequestInit & {
-  duplex?: "half";
-  /**
-   * Custom fetch options that are merged into the final request configuration.
-   *
-   * This property is intended for environment-specific extensions not included in the standard web `RequestInit` type, such as `dispatcher` for Undici/Node.js or the `next` object for Next.js extended fetch.
-   */
-  extraFetchOptions?: RequestInit;
+//#region src/utils/external/body.d.ts
+type BodyType = NonNullable<CallApiRequestOptions["body"]>;
+declare const toSearchParams: <TSchema extends CallApiSchemaType<BodyType>>(data: InferSchemaOutput<TSchema>, schema?: TSchema) => URLSearchParams;
+declare const toQueryString: <TSchema extends CallApiSchemaType<BodyType>>(...parameters: Parameters<typeof toSearchParams<TSchema>>) => string;
+/**
+ * @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" }
+ * });
+ */
+declare const toFormData: <TSchema extends CallApiSchemaType<BodyType>>(data: InferSchemaOutput<TSchema>, schema?: TSchema) => FormData;
+//#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>) => {
+  routes: Writeable<TBaseSchemaRoutes, "deep">;
+  config: Writeable<Satisfies<TSchemaConfig, CallApiSchemaConfig>, "deep">;
 };
-type CallApiRequestOptions<TBody = Body> = {
-  /**
-   * Body of the request, can be a object or any other supported body type.
-   */
-  body?: TBody;
-  /**
-   * Headers to be used in the request.
-   */
-  headers?: HeadersOption;
+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 definePluginWithContext: <const TCallApiContext extends CallApiContext = NonNullableUnknown>() => <const TPlugin extends CallApiPlugin<TCallApiContext>>(plugin: TPlugin) => NonNullableUnknown extends TCallApiContext ? Writeable<TPlugin, "deep"> : ContextTag<Writeable<TPlugin, "deep">, TCallApiContext>;
+declare const definePlugin: <const TPlugin extends CallApiPlugin<{}>>(plugin: TPlugin) => Writeable<TPlugin, "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">;
+  <const TBaseConfig extends BaseConfigObject>(baseConfig: (...parameters: Parameters<BaseConfigFn>) => Writeable<TBaseConfig, "deep">): typeof baseConfig;
+};
+declare const defineBaseConfig: DefineBaseConfig;
+declare const defineInstanceConfig: <const TInstanceConfig extends CallApiConfig>(config: TInstanceConfig) => Writeable<typeof config, "deep">;
+declare const defineFallbackRouteSchema: <const TSchema extends CallApiSchema>(schema: TSchema) => {
+  "@default": NonNullable<TSchema> extends Record<string | number | symbol, unknown> | unknown[] | readonly unknown[] ? Writeable<TSchema, "deep"> : TSchema;
+};
+//#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/utils/external/headers.d.ts
+declare const objectifyHeaders: (headers: CallApiRequestOptions["headers"]) => Record<string, string>;
+//#endregion
+//#region src/utils/external/helpers.d.ts
+declare const extraOptionsHelper: <TExtraOptions>() => ExtraOptionsWithContextTag<TExtraOptions>;
+declare const metaHelper: <TMeta extends DefaultMetaObject>() => MetaWithContextTag<TMeta>;
+//#endregion
+//#region src/retry.d.ts
+declare const defaultRetryStatusCodesLookup: () => Readonly<{
+  408: "Request Timeout";
+  409: "Conflict";
+  425: "Too Early";
+  429: "Too Many Requests";
+  500: "Internal Server Error";
+  502: "Bad Gateway";
+  503: "Service Unavailable";
+  504: "Gateway Timeout";
+}>;
+type RetryStatusCodes = UnmaskType<AnyNumber | keyof ReturnType<typeof defaultRetryStatusCodesLookup>>;
+type RetryCondition<TErrorData> = (context: ErrorContext<{
+  ErrorData: TErrorData;
+}>) => Awaitable<boolean>;
+type CallApiLooseImpl = (initURL: InitURLOrURLObject, init?: CallApiConfig) => Promise<CallApiResultLoose<unknown, unknown>>;
+interface RetryOptions<TErrorData> {
   /**
-   * HTTP method for the request.
-   * @default "GET"
+   * Tracks the number of times the request has already been retried internally
+   * @internal
+   * @deprecated **WARNING**: This property is used internally to track retries. Please abstain from reading or modifying it.
    */
-  method?: MethodUnion;
-} & Pick<ModifiedRequestInit, FetchSpecificKeysUnion>;
-type SharedExtraOptions<TCallApiContext extends CallApiContext = DefaultCallApiContext, TData = DefaultDataType, TErrorData = DefaultDataType, TResultMode extends ResultModeType = ResultModeType, TThrowOnError extends ThrowOnErrorBoolean = DefaultThrowOnError, TResponseType extends ResponseTypeType = ResponseTypeType, TPluginArray extends CallApiPlugin[] = DefaultPluginArray, TBody = Body, TComputedMergedPluginExtraOptions = Partial<InferPluginExtraOptions<TPluginArray> & InferSchemaOutput<TCallApiContext["InferredExtraOptions"], TCallApiContext["InferredExtraOptions"]>>, TComputedCallApiContext extends CallApiContext = OverrideCallApiContext<TCallApiContext, {
-  Data: TData;
-  ErrorData: TErrorData;
-  InferredExtraOptions: TComputedMergedPluginExtraOptions;
-  ResultMode: TResultMode;
-}>> = DedupeOptions & HookConfigOptions & HooksOrHooksArray<NoInferUnMasked<TComputedCallApiContext>> & Middlewares<NoInferUnMasked<TComputedCallApiContext>> & RefetchOptions & ResultModeOption<TErrorData, TResultMode> & RetryOptions<TErrorData> & TComputedMergedPluginExtraOptions & ThrowOnErrorOption<TErrorData, TThrowOnError> & URLOptions & {
+  readonly ["~retryAttemptCount"]?: number;
   /**
-   * Automatically add an Authorization header value.
-   *
-   * Supports multiple authentication patterns:
-   * - String: Direct authorization header value
-   * - Auth object: Structured authentication configuration
-   *
-   * ```
+   * Use a valid `Retry-After` response header instead of the configured retry delay
+   * @default false
    */
-  auth?: AuthOption;
+  respectRetryAfter?: boolean;
   /**
-   * Custom function to serialize request body objects into strings.
-   *
-   * Useful for custom string serialization formats or when the default JSON
-   * serialization doesn't meet your needs.
-   *
-   * @example
-   * ```ts
-   * // XML serialization
-   * bodySerializer: (body) => {
-   *   return `<request>${Object.entries(body)
-   *     .map(([key, value]) => `<${key}>${value}</${key}>`)
-   *     .join('')}</request>`;
-   * }
-   *
-   * // Custom JSON with specific formatting
-   * bodySerializer: (body) => JSON.stringify(body, null, 2)
-   * ```
+   * Number of allowed retry attempts on HTTP errors
+   * @default 0
    */
-  bodySerializer?: (body: TBody extends SerializableObject ? TBody : SerializableObject) => string;
+  retryAttempts?: number;
   /**
-   * Custom function to transform the request body before it is passed to fetch.
-   *
-   * Useful for converting plain objects into formats like `FormData`,
-   * `URLSearchParams`, `Blob`, or other Fetch-compatible body values.
-   *
-   * Takes precedence over `bodySerializer`.
-   *
-   * @example
-   * ```ts
-   * bodyTransformer: ({ body }) => {
-   *   const formData = new FormData();
-   *
-   *   Object.entries(body).forEach(([key, value]) => {
-   *     formData.append(key, String(value));
-   *   });
-   *
-   *   return formData;
-   * }
-   * ```
+   * Callback whose return value determines if a request should be retried or not
    */
-  bodyTransformer?: (context: {
-    body: TBody;
-    headers: Headers;
-  }) => Body;
+  retryCondition?: RetryCondition<TErrorData>;
   /**
-   * 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
+   * Delay between retries in milliseconds
+   * @default 1000
    */
-  cloneResponse?: boolean;
+  retryDelay?: number | ((currentAttemptCount: number) => number);
   /**
-   * 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
-   *   });
-   * }
-   * ```
+   * Maximum delay in milliseconds. Only applies to exponential strategy
+   * @default 10000
    */
-  customFetchImpl?: FetchImpl;
+  retryMaxDelay?: number;
   /**
-   * Enable debug mode for the request.
-   *
-   * @default true
+   * HTTP methods that are allowed to retry
+   * @default ["GET", "POST"]
    */
-  debugMode?: boolean;
+  retryMethods?: MethodUnion[];
   /**
-   * 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})`;
-   * }
-   * ```
+   * HTTP status codes that trigger a retry
    */
-  defaultHTTPErrorMessage?: string | ((context: Pick<HTTPError<TErrorData>, "errorData" | "response">) => string);
+  retryStatusCodes?: RetryStatusCodes[];
   /**
-   * 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"
-   *   }
-   * });
-   * ```
+   * Strategy to use when retrying
+   * @default "linear"
    */
-  meta?: TCallApiContext["Meta"] extends DefaultMetaObject ? TCallApiContext["Meta"] : DefaultCallApiContext["Meta"];
+  retryStrategy?: "exponential" | "linear";
+}
+type RetryManagerContext = {
+  callApi: CallApiLooseImpl;
+  callApiArgs: {
+    config: CallApiConfig;
+    initURL: InitURLOrURLObject;
+  };
+  error: unknown;
+  errorContext: ErrorContext;
+  hookInfo: ExecuteHookInfo;
+  removeDedupeCacheEntry: () => void;
+};
+//#endregion
+//#region src/refetch.d.ts
+declare const refetchAttemptTrackerSymbol: unique symbol;
+interface RefetchOptions {
   /**
-   * 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: (text) => {
-   *   return JSON.parse(text);
-   * }
-   *
-   * // Parse XML responses
-   * responseParser: (text) => {
-   *   const parser = new DOMParser();
-   *   const doc = parser.parseFromString(text, "text/xml");
-   *   return xmlToObject(doc);
-   * }
-   *
-   * // Parse CSV responses
-   * responseParser: (text) => {
-   *   const lines = text.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;
-   * }
-   *
-   * ```
+   * Tracks if the refetching of the request should be attempted
+   * @internal
+   * @deprecated **WARNING**: This property is used internally to track retries. Please abstain from reading or modifying it.
    */
-  responseParser?: ResponseParser<TData>;
+  [refetchAttemptTrackerSymbol]?: boolean;
+}
+type RefetchFn = () => void;
+type RefetchManagerResult = {
+  handleRefetch: () => Promise<CallApiResultLoose<unknown, unknown>> | null;
+  refetch: RefetchFn;
+};
+declare const createRefetchManager: (ctx: Pick<RetryManagerContext, "callApi" | "callApiArgs" | "removeDedupeCacheEntry"> & {
+  options: CallApiExtraOptions;
+}) => RefetchManagerResult;
+type RefetchFnOption = Pick<ReturnType<typeof createRefetchManager>, "refetch">;
+//#endregion
+//#region src/stream.d.ts
+type StreamProgressEvent = {
   /**
-   * 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" });
-   *
-   * // Binary data
-   * responseType: "arrayBuffer"
-   * // Usage: const buffer = await callApi("/binary-data", { responseType: "arrayBuffer" });
+   * Current chunk of data being streamed.
    *
-   * // Streaming responses
-   * responseType: "stream"
-   * // Usage: const stream = await callApi("/large-dataset", { responseType: "stream" });
-   * ```
+   * Will be `null` on the final completion tick (when progress reaches 100%).
    */
-  responseType?: TResponseType;
+  chunk: Uint8Array | null;
   /**
-     * Dictates how CallApi processes and returns the final result
-     *
-    - **"all"** (default): Returns `{ data, error, response }`. Standard lifecycle.
-    - **"onlyData"**: Returns only the data from the response.
-    - **"onlyResponse"**: Returns only the `Response` object.
-    - **"fetchApi"**: Also returns only the `Response` object, but also skips parsing of the response body internally and data/errorData schema validation.
-    - **"withoutResponse"**: Returns `{ data, error }`. Standard lifecycle, but omits the `response` property.
-     *
-     *
-     * **Note:**
-     * By default, simplified modes (`"onlyData"`, `"onlyResponse"`, `"fetchApi"`) do not throw errors.
-     *	Success/failure should be handled via hooks or by checking the return value (e.g., `if (data)` or `if (response?.ok)`).
-     * To force an exception instead, set `throwOnError: true`.
-     *
-     *
-     * @default "all"
-     *
-     */
-  resultMode?: TResultMode;
+   * Progress in percentage
+   */
+  progress: number;
   /**
-   * Controls whether errors are thrown as exceptions or returned in the result.
+   * Total size of data in bytes
+   */
+  totalBytes: number;
+  /**
+   * Amount of data transferred so far
+   */
+  transferredBytes: number;
+};
+//#endregion
+//#region src/hooks.d.ts
+type CallApiRequestOptionsForHooks = Omit<CallApiRequestOptions, "headers"> & {
+  headers: Partial<Record<"Authorization" | "Content-Type" | CommonRequestHeaders, string>>;
+};
+type CallApiExtraOptionsForHooks<TCallApiContext extends CallApiContext = DefaultCallApiContext> = Hooks & Omit<CallApiExtraOptions<TCallApiContext>, keyof Hooks> & Pick<RefetchFnOption, "refetch">;
+interface Hooks<TCallApiContext extends CallApiContext = DefaultCallApiContext> {
+  /**
+   * Hook called when any error occurs within the request/response lifecycle.
    *
-   * 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.
+   * 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.
    *
-   * @default false
+   * @param context - Error context containing error details, request info, and response (if available)
+   * @returns Promise or void - Hook can be async or sync
+   */
+  onError?: (context: ErrorContext<TCallApiContext>) => Awaitable<unknown>;
+  /**
+   * Hook called before the HTTP request is sent and before any internal processing of the request object begins.
    *
-   * @example
-   * ```ts
-   * // Always throw errors
-   * throwOnError: true
-   * try {
-   *   const data = await callApi("/users");
-   *   console.log("Users:", data);
-   * } 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.
    *
-   * // Never throw errors (default)
-   * throwOnError: false
-   * const { data, error } = await callApi("/users");
-   * if (error) {
-   *   console.error("Request failed:", error);
-   * }
+   * @param context - Request context with mutable request object and configuration
+   * @returns Promise or void - Hook can be async or sync
    *
-   * // 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;
-   * }
+   */
+  onRequest?: (context: RequestContext<TCallApiContext>) => Awaitable<unknown>;
+  /**
+   * 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, TThrowOnError>;
+  onRequestError?: (context: RequestErrorContext<TCallApiContext>) => Awaitable<unknown>;
   /**
-   * Request timeout in milliseconds. Request will be aborted if it takes longer.
+   * Hook called just before the HTTP request is sent and after the request has been processed.
    *
-   * Useful for preventing requests from hanging indefinitely and providing
-   * better user experience with predictable response times.
+   * @param context - Request context with mutable request object and configuration
+   */
+  onRequestReady?: (context: RequestContext<TCallApiContext>) => Awaitable<unknown>;
+  /**
+   * Hook called during upload stream progress tracking.
    *
-   * @example
-   * ```ts
-   * // 5 second timeout
-   * timeout: 5000
+   * 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.
    *
-   * // Different timeouts for different endpoints
-   * const quickApi = createFetchClient({ timeout: 3000 }); // 3s for fast endpoints
-   * const slowApi = createFetchClient({ timeout: 30000 }); // 30s for slow operations
+   * @param context - Request stream context with progress event and request instance
+   * @returns Promise or void - Hook can be async or sync
    *
-   * // Per-request timeout override
-   * await callApi("/quick-data", { timeout: 1000 });
-   * await callApi("/slow-report", { timeout: 60000 });
+   */
+  onRequestStream?: (context: RequestStreamContext<TCallApiContext>) => 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
    *
-   * // No timeout (use with caution)
-   * timeout: 0
-   * ```
    */
-  timeout?: number;
-};
-type BaseCallApiExtraOptions<TBaseCallApiContext extends CallApiContext = DefaultCallApiContext, TBaseData = DefaultDataType, TBaseErrorData = DefaultDataType, TBaseResultMode extends ResultModeType = ResultModeType, TBaseThrowOnError extends ThrowOnErrorBoolean = DefaultThrowOnError, TBaseResponseType extends ResponseTypeType = ResponseTypeType, TBasePluginArray extends CallApiPlugin[] = DefaultPluginArray, TBaseSchemaAndConfig extends BaseCallApiSchemaAndConfig = BaseCallApiSchemaAndConfig> = SharedExtraOptions<TBaseCallApiContext, TBaseData, TBaseErrorData, TBaseResultMode, TBaseThrowOnError, TBaseResponseType, TBasePluginArray> & {
+  onResponse?: (context: ResponseContext<TCallApiContext>) => Awaitable<unknown>;
   /**
-   * Array of base CallApi plugins to extend library functionality.
+   * Hook called when an HTTP error response (4xx, 5xx) is received from the API.
    *
-   * Base plugins are applied to all instances created from this base configuration
-   * and provide foundational functionality like authentication, logging, or caching.
+   * 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.
    *
-   * @example
-   * ```ts
-   * // Add logging plugin
+   * @param context - Response error context with HTTP error details and response
+   * @returns Promise or void - Hook can be async or sync
+   */
+  onResponseError?: (context: ResponseErrorContext<TCallApiContext>) => Awaitable<unknown>;
+  /**
+   * Hook called during download stream progress tracking.
    *
-   * // Create base client with common plugins
-   * const callApi = createFetchClient({
-   *   baseURL: "https://api.example.com",
-   *   plugins: [loggerPlugin({ enabled: true })]
-   * });
+   * 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.
    *
-   * // All requests inherit base plugins
-   * await callApi("/users");
-   * await callApi("/posts");
+   * @param context - Response stream context with progress event and response
+   * @returns Promise or void - Hook can be async or sync
    *
-   * ```
    */
-  plugins?: TBasePluginArray;
+  onResponseStream?: (context: ResponseStreamContext<TCallApiContext>) => Awaitable<unknown>;
   /**
-   * Base validation schemas for the client configuration.
+   * 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
    *
-   * Defines validation rules for requests and responses that apply to all
-   * instances created from this base configuration. Provides type safety
-   * and runtime validation for API interactions.
    */
-  schema?: TBaseSchemaAndConfig;
+  onRetry?: (context: RetryContext<TCallApiContext>) => Awaitable<unknown>;
   /**
-   * Controls which configuration parts skip automatic merging between base and instance configs.
+   * Hook called when a successful response (2xx status) is received from the API.
    *
-   * 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 only for successful responses and provides access to
+   * the parsed response data. Ideal for success logging, caching, or post-processing
+   * of successful API responses.
    *
-   * @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 - Success context with parsed response data and response object
+   * @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",
+   */
+  onSuccess?: (context: SuccessContext<TCallApiContext>) => Awaitable<unknown>;
+  /**
+   * Hook called when a validation error occurs.
    *
-   *   // 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 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.
    *
-   * // Skip options merging - manual plugin/hook control
-   * const client = callApi.create((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
    *
-   *   // Manually control which plugins to use
-   *   plugins: [
-   *     ...ctx.options.plugins?.filter(p => p.name !== "unwanted") || [],
-   *     customPlugin
-   *   ],
+   */
+  onValidationError?: (context: ValidationErrorContext<TCallApiContext>) => Awaitable<unknown>;
+}
+type HooksOrHooksArray<TCallApiContext extends NoInfer<CallApiContext> = DefaultCallApiContext> = { [Key in keyof Hooks<TCallApiContext>]: Hooks<TCallApiContext>[Key] | Array<Hooks<TCallApiContext>[Key]>; };
+interface HookConfigOptions {
+  /**
+   * Controls the execution mode of all composed hooks (main + plugin hooks).
    *
-   *   // Request options still auto-merge
-   *   method: "POST"
-   * }));
+   * - **"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
    *
-   * // Skip request merging - manual request control
-   * const client = callApi.create((ctx) => ({
-   *   skipAutoMergeFor: "request",
+   * This affects how ALL hooks execute together, regardless of their source (main or plugin).
    *
-   *   // Extra options still auto-merge (plugins, hooks, etc.)
+   * @default "parallel"
+   */
+  hooksExecutionMode?: "parallel" | "sequential";
+}
+type RequestContext<TCallApiContext extends Pick<CallApiContext, "InferredExtraOptions" | "Meta"> = DefaultCallApiContext> = {
+  /**
+   * Base configuration object passed to createFetchClient.
    *
-   *   // Manually control request options
-   *   headers: {
-   *     "Content-Type": "application/json",
-   *     // Don't merge base headers
-   *   },
-   *   method: ctx.request.method || "GET"
-   * }));
+   * 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.
    *
-   * // Use case: Conditional merging based on request
-   * const client = createFetchClient((ctx) => ({
-   *   skipAutoMergeFor: "options",
+   * Contains configuration specific to this particular API call, which
+   * can override or extend the base configuration.
+   */
+  config: CallApiConfig;
+  /**
+   * Merged options combining base config, instance config, and default 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") || []
-   * }));
-   * ```
+   * This is the final resolved configuration that will be used for the request,
+   * with proper precedence applied (instance > base > defaults).
    */
-  skipAutoMergeFor?: "all" | "options" | "request";
+  options: CallApiExtraOptionsForHooks<TCallApiContext>;
+  /**
+   * 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.
+   */
+  request: CallApiRequestOptionsForHooks;
 };
-type GetBaseSchemaRoutes<TBaseSchemaAndConfig extends BaseCallApiSchemaAndConfig> = Writeable<TBaseSchemaAndConfig["routes"], "deep">;
-type GetBaseSchemaConfig<TBaseSchemaAndConfig extends BaseCallApiSchemaAndConfig> = Writeable<NonNullable<TBaseSchemaAndConfig["config"]>, "deep">;
-type InferExtendSchemaContext<TBaseSchemaRoutes extends BaseCallApiSchemaRoutes, TCurrentRouteSchemaKey extends string> = {
-  baseSchemaRoutes: TBaseSchemaRoutes;
-  currentRouteSchema: GetCurrentRouteSchema<TBaseSchemaRoutes, TCurrentRouteSchemaKey>;
-  currentRouteSchemaKey: TCurrentRouteSchemaKey;
+type SuccessContext<TCallApiContext extends Pick<CallApiContext, "Data" | "InferredExtraOptions" | "Meta"> = DefaultCallApiContext> = DistributiveOmit<CallApiResultSuccessVariant<TCallApiContext["Data"]>, "error"> & RequestContext<TCallApiContext>;
+type ResponseContext<TCallApiContext extends Pick<CallApiContext, "Data" | "ErrorData" | "InferredExtraOptions" | "Meta"> = DefaultCallApiContext> = RequestContext<TCallApiContext> & (Prettify<CallApiResultSuccessVariant<TCallApiContext["Data"]>> | Prettify<Extract<CallApiResultErrorVariant<TCallApiContext["ErrorData"]>, {
+  error: PossibleHTTPError<TCallApiContext["ErrorData"]>;
+}>>);
+type RequestStreamContext<TCallApiContext extends Pick<CallApiContext, "InferredExtraOptions" | "Meta"> = DefaultCallApiContext> = RequestContext<TCallApiContext> & {
+  event: StreamProgressEvent;
+  requestInstance: Request;
 };
-type GetExtendSchemaConfigContext<TBaseSchemaConfig extends CallApiSchemaConfig> = {
-  baseSchemaConfig: TBaseSchemaConfig;
+type ResponseStreamContext<TCallApiContext extends Pick<CallApiContext, "InferredExtraOptions" | "Meta"> = DefaultCallApiContext> = RequestContext<TCallApiContext> & {
+  event: StreamProgressEvent;
+  response: Response;
 };
-type InferExtendPluginContext<TBasePluginArray extends CallApiPlugin[]> = {
-  basePlugins: TBasePluginArray;
+type ErrorContext<TCallApiContext extends Pick<CallApiContext, "ErrorData" | "InferredExtraOptions" | "Meta"> = DefaultCallApiContext> = DistributiveOmit<CallApiResultErrorVariant<TCallApiContext["ErrorData"]>, "data"> & RequestContext<TCallApiContext>;
+type ValidationErrorContext<TCallApiContext extends Pick<CallApiContext, "InferredExtraOptions" | "Meta"> = DefaultCallApiContext> = Extract<ErrorContext<TCallApiContext>, {
+  error: PossibleValidationError;
+}> & RequestContext<TCallApiContext>;
+type RequestErrorContext<TCallApiContext extends Pick<CallApiContext, "InferredExtraOptions" | "Meta"> = DefaultCallApiContext> = Extract<ErrorContext<TCallApiContext>, {
+  error: PossibleJavaScriptError;
+}> & RequestContext<TCallApiContext>;
+type ResponseErrorContext<TCallApiContext extends Pick<CallApiContext, "ErrorData" | "InferredExtraOptions" | "Meta"> = DefaultCallApiContext> = Extract<ErrorContext<TCallApiContext>, {
+  error: PossibleHTTPError<TCallApiContext["ErrorData"]>;
+}> & RequestContext<TCallApiContext>;
+type RetryContext<TCallApiContext extends Pick<CallApiContext, "ErrorData" | "InferredExtraOptions" | "Meta"> = DefaultCallApiContext> = ErrorContext<TCallApiContext> & {
+  retryAttemptCount: number;
 };
-type CallApiExtraOptions<TCallApiContext extends CallApiContext = DefaultCallApiContext, TData = DefaultDataType, TErrorData = DefaultDataType, TResultMode extends ResultModeType = ResultModeType, TThrowOnError extends ThrowOnErrorBoolean = DefaultThrowOnError, TResponseType extends ResponseTypeType = ResponseTypeType, TBasePluginArray extends CallApiPlugin[] = DefaultPluginArray, TPluginArray extends CallApiPlugin[] = DefaultPluginArray, TBaseSchemaRoutes extends BaseCallApiSchemaRoutes = BaseCallApiSchemaRoutes, TSchema extends CallApiSchema = CallApiSchema, TBaseSchemaConfig extends CallApiSchemaConfig = CallApiSchemaConfig, TSchemaConfig extends CallApiSchemaConfig = CallApiSchemaConfig, TCurrentRouteSchemaKey extends string = string, TBody extends InferSchemaOutput<TSchema["body"], Body> = InferSchemaOutput<TSchema["body"], Body>> = SharedExtraOptions<TCallApiContext, TData, TErrorData, TResultMode, TThrowOnError, TResponseType, TPluginArray, TBody> & {
+type ExecuteHookInfo = {
+  errorInfoOptions: ErrorInfoOptions;
+  shouldThrowOnError: boolean | undefined;
+};
+//#endregion
+//#region src/plugins.d.ts
+type PluginSetupContext<TCallApiContext extends CallApiContext = DefaultCallApiContext> = RequestContext<TCallApiContext> & ReturnType<typeof getCurrentRouteSchemaKeyAndMainInitURL>;
+type PluginInitResult<TCallApiContext extends CallApiContext = DefaultCallApiContext> = Partial<Omit<PluginSetupContext<TCallApiContext>, "initURL" | "request"> & {
+  initURL: InitURLOrURLObject;
+  request: CallApiRequestOptions;
+}>;
+type GetDefaultDataTypeForPlugins<TData> = DefaultDataType extends TData ? never : TData;
+type PluginHooks<TCallApiContext extends CallApiContext = DefaultCallApiContext> = HooksOrHooksArray<OverrideCallApiContext<TCallApiContext, {
+  Data: GetDefaultDataTypeForPlugins<TCallApiContext["Data"]>;
+  ErrorData: GetDefaultDataTypeForPlugins<TCallApiContext["ErrorData"]>;
+}>>;
+type PluginMiddlewares<TCallApiContext extends CallApiContext = DefaultCallApiContext> = Middlewares<OverrideCallApiContext<TCallApiContext, {
+  Data: GetDefaultDataTypeForPlugins<TCallApiContext["Data"]>;
+  ErrorData: GetDefaultDataTypeForPlugins<TCallApiContext["ErrorData"]>;
+}>>;
+interface CallApiPlugin<TCallApiContext extends CallApiContext = DefaultCallApiContext> {
   /**
-   * Array of instance-specific CallApi plugins or a function to configure plugins.
-   *
-   * Instance plugins are added to the base plugins and provide functionality
-   * specific to this particular API instance. Can be a static array or a function
-   * that receives base plugins and returns the instance plugins.
-   *
+   * A description for the plugin
    */
-  plugins?: TPluginArray | ((context: InferExtendPluginContext<TBasePluginArray>) => TPluginArray);
+  description?: string;
   /**
-   * For instance-specific validation schemas
-   *
-   * Defines validation rules specific to this API instance, extending or overriding the base schema.
-   *
-   * Can be a static schema object or a function that receives base schema context and returns instance schemas.
-   *
+   * Defines additional options that can be passed to callApi
    */
-  schema?: TSchema | ((context: InferExtendSchemaContext<TBaseSchemaRoutes, TCurrentRouteSchemaKey>) => TSchema);
+  extraOptionsDef?: ExtraOptionsWithContextTag<DefaultInferredExtraOptions>;
   /**
-   * 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.
-   *
+   * Hooks for the plugin
    */
-  schemaConfig?: TSchemaConfig | ((context: GetExtendSchemaConfigContext<TBaseSchemaConfig>) => TSchemaConfig);
-};
-type InstanceContext = {
-  initURL: string;
-  options: CallApiExtraOptions;
-  request: CallApiRequestOptions;
-};
-type BaseCallApiConfig<TBaseCallApiContext extends CallApiContext = DefaultCallApiContext, TBaseData = DefaultDataType, TBaseErrorData = DefaultDataType, TBaseResultMode extends ResultModeType = ResultModeType, TBaseThrowOnError extends ThrowOnErrorBoolean = DefaultThrowOnError, TBaseResponseType extends ResponseTypeType = ResponseTypeType, TBaseSchemaAndConfig extends BaseCallApiSchemaAndConfig = BaseCallApiSchemaAndConfig, TBasePluginArray extends CallApiPlugin[] = DefaultPluginArray, TComputedBaseConfig = BaseCallApiExtraOptions<TBaseCallApiContext, TBaseData, TBaseErrorData, TBaseResultMode, TBaseThrowOnError, TBaseResponseType, TBasePluginArray, TBaseSchemaAndConfig>> = (CallApiRequestOptions & TComputedBaseConfig) | ((context: InstanceContext) => CallApiRequestOptions & TComputedBaseConfig);
-type CallApiConfig<TCallApiContext extends CallApiContext = DefaultCallApiContext, TData = DefaultDataType, TErrorData = DefaultDataType, TResultMode extends ResultModeType = ResultModeType, TThrowOnError extends ThrowOnErrorBoolean = DefaultThrowOnError, TResponseType extends ResponseTypeType = ResponseTypeType, TBaseSchemaRoutes extends BaseCallApiSchemaRoutes = BaseCallApiSchemaRoutes, TSchema extends CallApiSchema = CallApiSchema, TBaseSchemaConfig extends CallApiSchemaConfig = CallApiSchemaConfig, TSchemaConfig extends CallApiSchemaConfig = CallApiSchemaConfig, TInitURL extends InitURLOrURLObject = InitURLOrURLObject, TCurrentRouteSchemaKey extends string = string, TBody extends InferSchemaOutput<TSchema["body"], Body> = InferSchemaOutput<TSchema["body"], Body>, TBasePluginArray extends CallApiPlugin[] = DefaultPluginArray, TPluginArray extends CallApiPlugin[] = DefaultPluginArray> = InferExtraOptions<TSchema, TBaseSchemaRoutes, TCurrentRouteSchemaKey, TCallApiContext> & InferRequestOptions<TSchema, TInitURL, TBody> & Omit<CallApiExtraOptions<TCallApiContext, TData, TErrorData, TResultMode, TThrowOnError, TResponseType, TBasePluginArray, TPluginArray, TBaseSchemaRoutes, TSchema, TBaseSchemaConfig, TSchemaConfig, TCurrentRouteSchemaKey, TBody>, keyof InferExtraOptions<CallApiSchema, BaseCallApiSchemaRoutes, string, CallApiContext>> & Omit<CallApiRequestOptions<TBody>, keyof InferRequestOptions<CallApiSchema, string, TBody>>;
-type CallApiParameters<TData = DefaultDataType, TErrorData = DefaultDataType, TResultMode extends ResultModeType = ResultModeType, TCallApiContext extends CallApiContext = DefaultCallApiContext, TThrowOnError extends ThrowOnErrorBoolean = DefaultThrowOnError, TResponseType extends ResponseTypeType = ResponseTypeType, TBaseSchemaRoutes extends BaseCallApiSchemaRoutes = BaseCallApiSchemaRoutes, TSchema extends CallApiSchema = CallApiSchema, TBaseSchemaConfig extends CallApiSchemaConfig = CallApiSchemaConfig, TSchemaConfig extends CallApiSchemaConfig = CallApiSchemaConfig, TInitURL extends InitURLOrURLObject = InitURLOrURLObject, TCurrentRouteSchemaKey extends string = string, TBody extends InferSchemaOutput<TSchema["body"], Body> = InferSchemaOutput<TSchema["body"], Body>, TBasePluginArray extends CallApiPlugin[] = DefaultPluginArray, TPluginArray extends CallApiPlugin[] = DefaultPluginArray, TComputedConfig = CallApiConfig<TCallApiContext, TData, TErrorData, TResultMode, TThrowOnError, TResponseType, TBaseSchemaRoutes, TSchema, TBaseSchemaConfig, TSchemaConfig, TInitURL, TCurrentRouteSchemaKey, TBody, TBasePluginArray, TPluginArray>, TComputedRequiredOptions = InferExtraOptions<TSchema, TBaseSchemaRoutes, TCurrentRouteSchemaKey, TCallApiContext> & InferRequestOptions<TSchema, TInitURL, TBody>> = NonNullable<unknown> extends TComputedRequiredOptions ? [initURL: TInitURL, config?: TComputedConfig] : [initURL: TInitURL, config: TComputedConfig];
-type CallApiResult<TData, TErrorData, TResultMode extends ResultModeType, TThrowOnError extends ThrowOnErrorBoolean> = InferCallApiResult<TData, TErrorData, TResultMode, TThrowOnError>;
-type CallApiResultLoose<TData, TErrorData, TResultMode extends ResultModeType = ResultModeType, TThrowOnError extends ThrowOnErrorBoolean = ThrowOnErrorBoolean> = InferCallApiResult<TData, TErrorData, TResultMode, TThrowOnError>;
-//#endregion
-//#region src/auth.d.ts
-type PossibleAuthValue = Awaitable<string | null | undefined>;
-type PossibleAuthValueOrGetter = PossibleAuthValue | (() => PossibleAuthValue);
-type BearerAuth = {
-  type: "Bearer";
-  value: PossibleAuthValueOrGetter;
-};
-type TokenAuth = {
-  type: "Token";
-  value: PossibleAuthValueOrGetter;
-};
-type BasicAuth = {
-  type: "Basic";
-  username: PossibleAuthValueOrGetter;
-  password: PossibleAuthValueOrGetter;
-};
-/**
- * Custom auth
- *
- * @param prefix - prefix of the header
- * @param authValue - value of the header
- *
- * @example
- * ```ts
- * {
- *  type: "Custom",
- *  prefix: "Token",
- *  authValue: "token"
- * }
- * ```
- */
-type CustomAuth = {
-  type: "Custom";
-  prefix: PossibleAuthValueOrGetter;
-  value: PossibleAuthValueOrGetter;
-};
-type AuthOption = PossibleAuthValueOrGetter | BearerAuth | TokenAuth | BasicAuth | CustomAuth;
-//#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 MergeBaseWithRouteKey<TBaseURLOrPrefix extends string | undefined, TRouteKey extends string> = TBaseURLOrPrefix extends string ? TRouteKey extends `${AtSymbol}${infer TMethod extends RouteKeyMethods}/${infer TRestOfRoutKey}` ? `${AtSymbol}${TMethod}/${RemoveLeadingSlash<RemoveTrailingSlash<TBaseURLOrPrefix>>}/${RemoveLeadingSlash<TRestOfRoutKey>}` : `${TBaseURLOrPrefix}${TRouteKey}` : TRouteKey;
-type ApplyURLBasedConfig<TSchemaConfig extends CallApiSchemaConfig, TSchemaRouteKeys extends string> = TSchemaConfig["prefix"] extends string ? MergeBaseWithRouteKey<TSchemaConfig["prefix"], TSchemaRouteKeys> : TSchemaConfig["baseURL"] extends string ? MergeBaseWithRouteKey<TSchemaConfig["baseURL"], TSchemaRouteKeys> : TSchemaRouteKeys;
-type ApplyStrictConfig<TSchemaConfig extends CallApiSchemaConfig, TSchemaRouteKeys extends string> = TSchemaConfig["strict"] extends true ? TSchemaRouteKeys // eslint-disable-next-line perfectionist/sort-union-types -- Don't sort union types
- : TSchemaRouteKeys | Exclude<InitURLOrURLObject, RouteKeyMethodsURLUnion>;
-type ApplySchemaConfiguration<TSchemaConfig extends CallApiSchemaConfig, TSchemaRouteKeys extends string> = ApplyStrictConfig<TSchemaConfig, ApplyURLBasedConfig<TSchemaConfig, TSchemaRouteKeys>>;
-type InferAllMainRoutes<TBaseSchemaRoutes extends BaseCallApiSchemaRoutes> = Omit<TBaseSchemaRoutes, FallBackRouteSchemaKey>;
-type InferAllMainRouteKeys<TBaseSchemaRoutes extends BaseCallApiSchemaRoutes, TSchemaConfig extends CallApiSchemaConfig> = ApplySchemaConfiguration<TSchemaConfig, Extract<keyof InferAllMainRoutes<TBaseSchemaRoutes>, string>>;
-type InferInitURL<TBaseSchemaRoutes extends BaseCallApiSchemaRoutes, TSchemaConfig extends CallApiSchemaConfig> = keyof TBaseSchemaRoutes extends never ? InitURLOrURLObject : InferAllMainRouteKeys<TBaseSchemaRoutes, TSchemaConfig>;
-type GetCurrentRouteSchemaKey<TSchemaConfig extends CallApiSchemaConfig, TPath> = TPath extends URL ? string : TSchemaConfig["prefix"] extends string ? TPath extends (`${AtSymbol}${infer TMethod extends RouteKeyMethods}/${RemoveLeadingSlash<TSchemaConfig["prefix"]>}${infer TCurrentRoute}`) ? `${AtSymbol}${TMethod}/${RemoveLeadingSlash<TCurrentRoute>}` : TPath extends `${TSchemaConfig["prefix"]}${infer TCurrentRoute}` ? TCurrentRoute : string : TSchemaConfig["baseURL"] extends string ? TPath extends (`${AtSymbol}${infer TMethod extends RouteKeyMethods}/${TSchemaConfig["baseURL"]}${infer TCurrentRoute}`) ? `${AtSymbol}${TMethod}/${RemoveLeadingSlash<TCurrentRoute>}` : TPath extends `${TSchemaConfig["baseURL"]}${infer TCurrentRoute}` ? TCurrentRoute : string : TPath;
-type GetCurrentRouteSchema<TBaseSchemaRoutes extends BaseCallApiSchemaRoutes, TCurrentRouteSchemaKey extends string, TComputedFallBackRouteSchema = TBaseSchemaRoutes[FallBackRouteSchemaKey], TComputedCurrentRouteSchema = TBaseSchemaRoutes[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 extends CallApiSchema, TBody = InferSchemaOutput<TSchema["body"], Body>> = MakeSchemaOptionRequiredIfDefined<TSchema["body"], {
+  hooks?: PluginHooks<TCallApiContext> | ((context: PluginSetupContext<TCallApiContext>) => Awaitable<PluginHooks<TCallApiContext>> | Awaitable<void>);
   /**
-   * Body of the request, can be a object or any other supported body type.
+   *  A unique id for the plugin
    */
-  body?: TBody;
-}>;
-type MethodUnion = UnmaskType<"CONNECT" | "DELETE" | "GET" | "HEAD" | "OPTIONS" | "PATCH" | "POST" | "PUT" | "TRACE" | AnyString>;
-type ExtractMethodFromURL<TInitURL> = string extends TInitURL ? MethodUnion : TInitURL extends `${AtSymbol}${infer TMethod extends RouteKeyMethods}/${string}` ? Uppercase<TMethod> : MethodUnion;
-type InferMethodOption<TSchema extends CallApiSchema, TInitURL extends InitURLOrURLObject> = MakeSchemaOptionRequiredIfDefined<TSchema["method"], {
+  id: string;
   /**
-   * HTTP method for the request.
-   * @default "GET"
+   * Defines metadata that can be passed to callApi
    */
-  method?: InferSchemaOutput<TSchema["method"], ExtractMethodFromURL<TInitURL>>;
-}>;
-type HeadersOption = UnmaskType<Headers | Record<"Authorization", CommonAuthorizationHeaders | undefined> | Record<"Content-Type", CommonContentTypes | undefined> | Record<CommonRequestHeaders, string | undefined> | Record<string, string | undefined> | Array<[string, string]>>;
-type InferHeadersOption<TSchema extends CallApiSchema> = MakeSchemaOptionRequiredIfDefined<TSchema["headers"], {
+  metaDef?: MetaWithContextTag<DefaultMetaObject>;
   /**
-   * Headers to be used in the request.
+   * Middlewares that for the plugin
    */
-  headers?: InferSchemaOutput<TSchema["headers"], HeadersOption> | ((context: {
-    baseHeaders: Extract<HeadersOption, Record<string, unknown>>;
-  }) => InferSchemaOutput<TSchema["headers"], HeadersOption>);
-}>;
-type InferRequestOptions<TSchema extends CallApiSchema, TInitURL extends InferInitURL<BaseCallApiSchemaRoutes, CallApiSchemaConfig>, TBody = InferSchemaOutput<TSchema["body"], Body>> = InferBodyOption<TSchema, TBody> & InferHeadersOption<TSchema> & InferMethodOption<TSchema, TInitURL>;
-type InferMetaOption<TSchema extends CallApiSchema, TCallApiContext extends CallApiContext> = MakeSchemaOptionRequiredIfDefined<TSchema["meta"], {
+  middlewares?: PluginMiddlewares<TCallApiContext> | ((context: PluginSetupContext<TCallApiContext>) => Awaitable<PluginMiddlewares<TCallApiContext>> | Awaitable<void>);
   /**
-   * - An optional field you can fill with additional information,
-   * to associate with the request, typically used for logging or tracing.
-   *
-   * - A good use case for this, would be to use the info to handle specific cases in any of the shared interceptors.
-   *
-   * @example
-   * ```ts
-   * const callMainApi = callApi.create({
-   * 	baseURL: "https://main-api.com",
-   * 	onResponseError: ({ response, options }) => {
-   * 		if (options.meta?.userId) {
-   * 			console.error(`User ${options.meta.userId} made an error`);
-   * 		}
-   * 	},
-   * });
-   *
-   * const response = await callMainApi({
-   * 	url: "https://example.com/api/data",
-   * 	meta: { userId: "123" },
-   * });
-   * ```
+   * A name for the plugin
    */
-  meta?: InferSchemaOutput<TSchema["meta"], TCallApiContext["Meta"]>;
-}>;
-type InferAuthOption<TSchema extends CallApiSchema> = MakeSchemaOptionRequiredIfDefined<TSchema["auth"], {
+  name: string;
   /**
-     * Automatically add an Authorization header value.
-     *
-     * Supports multiple authentication patterns:
-     * - String: Direct authorization header value
-     * - Auth object: Structured authentication configuration
-     *
-     * @example
-     * ```ts
-     * // Bearer auth
-     * const response = await callMainApi({
-     * 	url: "https://example.com/api/data",
-     * 	auth: "123456",
-     * });
-     *
-     * // Bearer auth
-     * const response = await callMainApi({
-     * 	url: "https://example.com/api/data",
-     * 	auth: {
-     * 		type: "Bearer",
-     * 		value: "123456",
-     * 	},
-     })
-     *
-     * // Token auth
-     * const response = await callMainApi({
-     * 	url: "https://example.com/api/data",
-     * 	auth: {
-     * 		type: "Token",
-     * 		value: "123456",
-     * 	},
-     * });
-     *
-     * // Basic auth
-     * const response = await callMainApi({
-     * 	url: "https://example.com/api/data",
-     * 	auth: {
-     * 		type: "Basic",
-     * 		username: "username",
-     * 		password: "password",
-     * 	},
-     * });
-     *
-     * ```
-     */
-  auth?: InferSchemaOutput<TSchema["auth"], AuthOption>;
-}>;
-type InferQueryOption<TSchema extends CallApiSchema> = MakeSchemaOptionRequiredIfDefined<TSchema["query"], {
+   * Base schema for the client.
+   */
+  schema?: BaseCallApiSchemaAndConfig;
   /**
-   * Parameters to be appended to the URL (i.e: /:id)
+   * A function that will be called when the plugin is initialized. This will be called before the any of the other internal functions.
    */
-  query?: InferSchemaOutput<TSchema["query"], Query>;
-}>;
-type EmptyString = "";
-type EmptyTuple = readonly [];
-type StringTuple = readonly string[];
-type PossibleParamNamePatterns = `${string}:${string}` | `${string}{${string}}${"" | AnyString}`;
-type ExtractRouteParamNames<TCurrentRoute, TParamNamesAccumulator extends StringTuple = EmptyTuple> = TCurrentRoute extends PossibleParamNamePatterns ? TCurrentRoute 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 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> = ExtractRouteParamNames<TCurrentRoute> extends StringTuple ? ExtractRouteParamNames<TCurrentRoute> extends EmptyTuple ? Params : ConvertParamNamesToRecord<ExtractRouteParamNames<TCurrentRoute>> | ConvertParamNamesToTuple<ExtractRouteParamNames<TCurrentRoute>> : Params;
-type MakeParamsOptionRequired<TParamsSchemaOption extends CallApiSchema["params"], TBaseSchemaRoutes extends BaseCallApiSchemaRoutes, TCurrentRouteSchemaKey extends string, TObject> = MakeSchemaOptionRequiredIfDefined<TParamsSchemaOption, Params extends InferParamsFromRoute<TCurrentRouteSchemaKey> ? TObject : TCurrentRouteSchemaKey extends Extract<keyof TBaseSchemaRoutes, TCurrentRouteSchemaKey> ? undefined extends InferSchemaOutput<TParamsSchemaOption, null> ? TObject : Required<TObject> : TObject>;
-type InferParamsOption<TSchema extends CallApiSchema, TBaseSchemaRoutes extends BaseCallApiSchemaRoutes, TCurrentRouteSchemaKey extends string> = MakeParamsOptionRequired<TSchema["params"], TBaseSchemaRoutes, TCurrentRouteSchemaKey, {
+  setup?: (context: PluginSetupContext<TCallApiContext>) => Awaitable<PluginInitResult<TCallApiContext>> | Awaitable<void>;
   /**
-   * Parameters to be appended to the URL (i.e: /:id)
+   *  A version for the plugin
    */
-  params?: InferSchemaOutput<TSchema["params"], InferParamsFromRoute<TCurrentRouteSchemaKey>>;
-}>;
-type InferExtraOptions<TSchema extends CallApiSchema, TBaseSchemaRoutes extends BaseCallApiSchemaRoutes, TCurrentRouteSchemaKey extends string, TCallApiContext extends CallApiContext> = InferAuthOption<TSchema> & InferMetaOption<TSchema, TCallApiContext> & InferParamsOption<TSchema, TBaseSchemaRoutes, TCurrentRouteSchemaKey> & InferQueryOption<TSchema>;
-type ResultModeOption<TErrorData, TResultMode extends ResultModeType> = TErrorData extends false ? {
-  resultMode: "onlyData";
-} : TErrorData extends false | undefined ? {
-  resultMode?: "onlyData";
-} : {
-  resultMode?: TResultMode;
-};
-type ThrowOnErrorBoolean = boolean;
-type ThrowOnErrorType<TErrorData, TThrowOnError extends ThrowOnErrorBoolean> = TThrowOnError | ((context: ErrorContext<{
-  ErrorData: TErrorData;
-}>) => TThrowOnError);
-type ThrowOnErrorOption<TErrorData, TThrowOnError extends ThrowOnErrorBoolean> = TErrorData extends false ? {
-  throwOnError: true;
-} : TErrorData extends false | undefined ? {
-  throwOnError?: true;
-} : {
-  throwOnError?: ThrowOnErrorType<TErrorData, TThrowOnError>;
+  version?: string;
+}
+//#endregion
+//#region src/types/callapi-context.d.ts
+interface CallApiContext {
+  Data?: DefaultDataType;
+  ErrorData?: DefaultDataType;
+  InferredExtraOptions?: DefaultInferredExtraOptions;
+  Meta?: DefaultMetaObject;
+  ResultMode?: ResultModeType;
+}
+type GetCallApiContext<TCallApiContext extends CallApiContext> = TCallApiContext;
+type GetCallApiContextRequired<TCallApiContext extends Required<CallApiContext>> = TCallApiContext;
+type OverrideCallApiContext<TFullCallApiContext extends CallApiContext, TOverrideCallApiContext extends CallApiContext> = Prettify<Omit<TFullCallApiContext, keyof TOverrideCallApiContext> & TOverrideCallApiContext>;
+declare const callApiContextSymbol: unique symbol;
+type callApiContextSymbol = typeof callApiContextSymbol;
+type ContextTag<TType, TCallApiContext extends CallApiContext> = TType & {
+  readonly [callApiContextSymbol]: TCallApiContext;
 };
+type MetaWithContextTag<TMeta extends DefaultMetaObject | undefined> = ContextTag<TMeta, {
+  Meta: TMeta;
+}>;
+type ExtraOptionsWithContextTag<TExtraOptions extends DefaultInferredExtraOptions> = ContextTag<TExtraOptions, {
+  InferredExtraOptions: TExtraOptions;
+}>;
+type InferMetaFromTag<TTaggedType, TFallback = never> = TTaggedType extends ContextTag<unknown, infer TCallApiContext extends CallApiContext> ? IsEmptyObject<TCallApiContext["Meta"]> extends true ? TFallback : TCallApiContext["Meta"] : TFallback;
+type InferExtraOptionsFromTag<TTaggedType> = TTaggedType extends ContextTag<unknown, infer TCallApiContext extends CallApiContext> ? unknown extends TCallApiContext["InferredExtraOptions"] ? never : TCallApiContext["InferredExtraOptions"] : never;
 //#endregion
-export { defineMainSchema as $, Register as A, BaseCallApiSchemaAndConfig as At, ResponseErrorContext as B, fallBackRouteSchemaKey as Bt, CallApiResultLoose as C, PossibleJavaScriptError as Ct, GetCallApiContextRequired as D, ResultModeType as Dt, GetCallApiContext as E, ResponseTypeType as Et, Hooks as F, InferSchemaInput as Ft, objectifyHeaders as G, NoInferUnMasked as Gt, SuccessContext as H, CommonContentTypes as Ht, HooksOrHooksArray as I, InferSchemaOutput as It, isJavascriptError as J, isHTTPError as K, Writeable as Kt, RequestContext as L, InferSchemaResult as Lt, CallApiExtraOptionsForHooks as M, BaseSchemaRouteKeyPrefixes as Mt, CallApiRequestOptionsForHooks as N, CallApiSchema as Nt, GlobalMeta as O, HTTPError as Ot, ErrorContext as P, CallApiSchemaConfig as Pt, defineInstanceConfig as Q, RequestStreamContext as R, URLOptions as Rt, CallApiResult as S, PossibleHTTPError as St, GetBaseSchemaRoutes as T, ResponseTypeMap as Tt, RefetchOptions as U, CommonRequestHeaders as Ut, ResponseStreamContext as V, AnyString as Vt, RetryOptions as W, DistributiveOmit as Wt, isValidationErrorInstance as X, isValidationError as Y, defineBaseConfig as Z, CallApiConfig as _, CallApiResultErrorVariant as _t, GetCurrentRouteSchemaKey as a, toQueryString as at, CallApiParameters as b, GetResponseType as bt, InferAllMainRoutes as c, DefaultDataType as ct, SerializableArray as d, PluginHooks as dt, definePlugin as et, SerializableObject as f, PluginMiddlewares as ft, BaseCallApiExtraOptions as g, Middlewares as gt, BaseCallApiConfig as h, FetchMiddlewareContext as ht, GetCurrentRouteSchema as i, toFormData as it, DedupeOptions as j, BaseCallApiSchemaRoutes as jt, InstanceContext as k, ValidationError as kt, InferInitURL as l, DefaultPluginArray as lt, AuthOption as m, FetchImpl as mt, ApplyURLBasedConfig as n, defineSchemaConfig as nt, HeadersOption as o, toSearchParams as ot, ThrowOnErrorBoolean as p, PluginSetupContext as pt, isHTTPErrorInstance as q, fetchSpecificKeys as qt, Body as r, defineSchemaRoutes as rt, InferAllMainRouteKeys as s, DefaultCallApiContext as st, ApplyStrictConfig as t, defineSchema as tt, InferParamsFromRoute as u, CallApiPlugin as ut, CallApiContext as v, CallApiResultSuccessOrErrorVariant as vt, GetBaseSchemaConfig as w, PossibleValidationError as wt, CallApiRequestOptions as x, InferCallApiResult as xt, CallApiExtraOptions as y, CallApiResultSuccessVariant as yt, ResponseContext as z, FallBackRouteSchemaKey as zt };
-//# sourceMappingURL=conditional-types-C9cMfJMZ.d.ts.map
+export { PossibleValidationError as $, DefaultCallApiContext as $t, isHTTPErrorInstance as A, ValidationError as At, defineSchema as B, FallBackRouteSchemaKey as Bt, SuccessContext as C, CallApiResult as Ct, metaHelper as D, InstanceContext as Dt, extraOptionsHelper as E, GetBaseSchemaRoutes as Et, defineFallbackRouteSchema as F, CallApiSchema as Ft, toSearchParams as G, DedupeOptions as Gt, defineSchemaRoutes as H, FetchImpl as Ht, defineInstanceConfig as I, CallApiSchemaConfig as It, CallApiResultSuccessVariant as J, CommonRequestHeaders as Jt, CallApiResultErrorVariant as K, AnyString as Kt, defineMainSchema as L, InferSchemaInput as Lt, isValidationError as M, BaseCallApiSchemaAndConfig as Mt, isValidationErrorInstance as N, BaseCallApiSchemaRoutes as Nt, objectifyHeaders as O, Register as Ot, defineBaseConfig as P, BaseSchemaRouteKeyPrefixes as Pt, PossibleJavaScriptError as Q, Writeable as Qt, definePlugin as R, InferSchemaOutput as Rt, ResponseStreamContext as S, CallApiRequestOptions as St, RetryOptions as T, GetBaseSchemaConfig as Tt, toFormData as U, FetchMiddlewareContext as Ut, defineSchemaConfig as V, fallBackRouteSchemaKey as Vt, toQueryString as W, Middlewares as Wt, InferCallApiResult as X, NoInferUnMasked as Xt, GetResponseType as Y, DistributiveOmit as Yt, PossibleHTTPError as Z, UnionToIntersection as Zt, HooksOrHooksArray as _, BaseCallApiConfig as _t, GetCallApiContextRequired as a, Body as at, ResponseContext as b, CallApiExtraOptions as bt, MetaWithContextTag as c, HeadersOption as ct, PluginMiddlewares as d, InferInitURL as dt, DefaultMetaObject as en, ResponseTypeMap as et, PluginSetupContext as f, InferParamsFromRoute as ft, Hooks as g, AuthOption as gt, ErrorContext as h, ThrowOnErrorBoolean as ht, GetCallApiContext as i, ApplyURLBasedConfig as it, isJavascriptError as j, URLOptions as jt, isHTTPError as k, HTTPError as kt, CallApiPlugin as l, InferAllMainRouteKeys as lt, CallApiRequestOptionsForHooks as m, SerializableObject as mt, ContextTag as n, fetchSpecificKeys as nn, ResultModeType as nt, InferExtraOptionsFromTag as o, GetCurrentRouteSchema as ot, CallApiExtraOptionsForHooks as p, SerializableArray as pt, CallApiResultSuccessOrErrorVariant as q, CommonContentTypes as qt, ExtraOptionsWithContextTag as r, ApplyStrictConfig as rt, InferMetaFromTag as s, GetCurrentRouteSchemaKey as st, CallApiContext as t, DefaultPluginArray as tn, ResponseTypeType as tt, PluginHooks as u, InferAllMainRoutes as ut, RequestContext as v, BaseCallApiExtraOptions as vt, RefetchOptions as w, CallApiResultLoose as wt, ResponseErrorContext as x, CallApiParameters as xt, RequestStreamContext as y, CallApiConfig as yt, definePluginWithContext as z, InferSchemaResult as zt };
+//# sourceMappingURL=callapi-context-NF0HXJwF.d.ts.map