@zayne-labs/callapi-plugins 4.0.27 → 4.0.29

package/dist/index.d.ts

@@ -1,1855 +1,2 @@
-import * as _zayne_labs_callapi_utils0 from "@zayne-labs/callapi/utils";
-import { AnyFunction } from "@zayne-labs/toolkit-type-helpers";
-
-//#region ../callapi/dist/validation-Dq--Q5zC.d.ts
-//#region src/constants/common.d.ts
-declare const fetchSpecificKeys: readonly (keyof RequestInit | "duplex")[];
-//#endregion
-//#region src/constants/validation.d.ts
-declare const fallBackRouteSchemaKey = "@default";
-type FallBackRouteSchemaKey = typeof fallBackRouteSchemaKey;
-//#endregion
-//#endregion
-//#region ../callapi/dist/index-HHFgKKcn.d.ts
-//#region src/types/type-helpers.d.ts
-type AnyString = string & NonNullable<unknown>;
-type AnyNumber = number & NonNullable<unknown>;
-type AnyFunction$1<TResult$1 = unknown> = (...args: any[]) => TResult$1;
-type Prettify<TObject> = NonNullable<unknown> & { [Key in keyof TObject]: TObject[Key] };
-type WriteableLevel = "deep" | "shallow";
-/**
- * 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.
- * @template TObject - The object type to make writeable
- * @template TVariant - The level of writeable transformation ("shallow" | "deep")
- */
-type ArrayOrObject = Record<number | string | symbol, unknown> | unknown[] | readonly unknown[];
-type Writeable<TObject, TLevel extends WriteableLevel = "shallow"> = TObject extends ArrayOrObject ? { -readonly [Key in keyof TObject]: TLevel extends "deep" ? NonNullable<TObject[Key]> extends ArrayOrObject ? Writeable<TObject[Key], "deep"> : TObject[Key] : TObject[Key] } : TObject;
-type UnionToIntersection<TUnion> = (TUnion extends unknown ? (param: TUnion) => void : never) extends ((param: infer TParam) => void) ? TParam : never;
-type UnmaskType<TValue$1> = {
-  _: TValue$1;
-}["_"];
-type RemovePrefix<TPrefix extends "dedupe" | "retry", TKey extends string> = TKey extends `${TPrefix}${infer TRest}` ? Uncapitalize<TRest> : TKey;
-type Awaitable<TValue$1> = Promise<TValue$1> | TValue$1;
-type DistributiveOmit<TObject, TKeysToOmit extends keyof TObject> = TObject extends unknown ? Omit<TObject, TKeysToOmit> : never;
-type CommonRequestHeaders = "Access-Control-Allow-Credentials" | "Access-Control-Allow-Headers" | "Access-Control-Allow-Methods" | "Access-Control-Allow-Origin" | "Access-Control-Expose-Headers" | "Access-Control-Max-Age" | "Age" | "Allow" | "Cache-Control" | "Clear-Site-Data" | "Content-Disposition" | "Content-Encoding" | "Content-Language" | "Content-Length" | "Content-Location" | "Content-Range" | "Content-Security-Policy-Report-Only" | "Content-Security-Policy" | "Cookie" | "Cross-Origin-Embedder-Policy" | "Cross-Origin-Opener-Policy" | "Cross-Origin-Resource-Policy" | "Date" | "ETag" | "Expires" | "Last-Modified" | "Location" | "Permissions-Policy" | "Pragma" | "Retry-After" | "Save-Data" | "Sec-CH-Prefers-Color-Scheme" | "Sec-CH-Prefers-Reduced-Motion" | "Sec-CH-UA-Arch" | "Sec-CH-UA-Bitness" | "Sec-CH-UA-Form-Factor" | "Sec-CH-UA-Full-Version-List" | "Sec-CH-UA-Full-Version" | "Sec-CH-UA-Mobile" | "Sec-CH-UA-Model" | "Sec-CH-UA-Platform-Version" | "Sec-CH-UA-Platform" | "Sec-CH-UA-WoW64" | "Sec-CH-UA" | "Sec-Fetch-Dest" | "Sec-Fetch-Mode" | "Sec-Fetch-Site" | "Sec-Fetch-User" | "Sec-GPC" | "Server-Timing" | "Server" | "Service-Worker-Navigation-Preload" | "Set-Cookie" | "Strict-Transport-Security" | "Timing-Allow-Origin" | "Trailer" | "Transfer-Encoding" | "Upgrade" | "Vary" | "Warning" | "WWW-Authenticate" | "X-Content-Type-Options" | "X-DNS-Prefetch-Control" | "X-Frame-Options" | "X-Permitted-Cross-Domain-Policies" | "X-Powered-By" | "X-Robots-Tag" | "X-XSS-Protection" | AnyString;
-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/auth.d.ts
-type PossibleAuthValue = Awaitable<string | null | undefined>;
-type PossibleAuthValueOrGetter = PossibleAuthValue | (() => PossibleAuthValue);
-type BearerOrTokenAuth = {
-  type?: "Bearer";
-  bearer?: PossibleAuthValueOrGetter;
-  token?: never;
-} | {
-  type?: "Token";
-  bearer?: never;
-  token?: 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 Auth = PossibleAuthValueOrGetter | BearerOrTokenAuth | BasicAuth | CustomAuth;
-//#endregion
-//#region src/dedupe.d.ts
-type DedupeStrategyUnion = UnmaskType<"cancel" | "defer" | "none">;
-type DedupeOptionKeys = Exclude<keyof DedupeOptions, "dedupe">;
-type InnerDedupeOptions = { [Key in DedupeOptionKeys as RemovePrefix<"dedupe", Key>]?: DedupeOptions[Key] };
-type DedupeOptions = {
-  /**
-   * All dedupe options in a single object instead of separate properties
-   */
-  dedupe?: InnerDedupeOptions;
-  /**
-   * Controls the scope of request deduplication caching.
-   *
-   * - `"global"`: Shares deduplication cache across all `createFetchClient` instances with the same `dedupeCacheScopeKey`.
-   *   Useful for applications with multiple API clients that should share deduplication state.
-   * - `"local"`: Limits deduplication to requests within the same `createFetchClient` instance.
-   *   Provides better isolation and is recommended for most use cases.
-   *
-   *
-   * **Real-world Scenarios:**
-   * - Use `"global"` when you have multiple API clients (user service, auth service, etc.) that might make overlapping requests
-   * - Use `"local"` (default) for single-purpose clients or when you want strict isolation between different parts of your app
-   *
-   * @example
-   * ```ts
-   * // Local scope - each client has its own deduplication cache
-   * const userClient = createFetchClient({ baseURL: "/api/users" });
-   * const postClient = createFetchClient({ baseURL: "/api/posts" });
-   * // These clients won't share deduplication state
-   *
-   * // Global scope - share cache across related clients
-   * const userClient = createFetchClient({
-   *   baseURL: "/api/users",
-   *   dedupeCacheScope: "global",
-   * });
-   * const postClient = createFetchClient({
-   *   baseURL: "/api/posts",
-   *   dedupeCacheScope: "global",
-   * });
-   * // These clients will share deduplication state
-   * ```
-   *
-   * @default "local"
-   */
-  dedupeCacheScope?: "global" | "local";
-  /**
-   * Unique namespace for the global deduplication cache when using `dedupeCacheScope: "global"`.
-   *
-   * This creates logical groupings of deduplication caches. All instances with the same key
-   * will share the same cache namespace, allowing fine-grained control over which clients
-   * share deduplication state.
-   *
-   * **Best Practices:**
-   * - Use descriptive names that reflect the logical grouping (e.g., "user-service", "analytics-api")
-   * - Keep scope keys consistent across related API clients
-   * - Consider using different scope keys for different environments (dev, staging, prod)
-   * - Avoid overly broad scope keys that might cause unintended cache sharing
-   *
-   * **Cache Management:**
-   * - Each scope key maintains its own independent cache
-   * - Caches are automatically cleaned up when no references remain
-   * - Consider the memory implications of multiple global scopes
-   *
-   * @example
-   * ```ts
-   * // Group related API clients together
-   * const userClient = createFetchClient({
-   *   baseURL: "/api/users",
-   *   dedupeCacheScope: "global",
-   *   dedupeCacheScopeKey: "user-service"
-   * });
-   * const profileClient = createFetchClient({
-   *   baseURL: "/api/profiles",
-   *   dedupeCacheScope: "global",
-   *   dedupeCacheScopeKey: "user-service" // Same scope - will share cache
-   * });
-   *
-   * // Separate analytics client with its own cache
-   * const analyticsClient = createFetchClient({
-   *   baseURL: "/api/analytics",
-   *   dedupeCacheScope: "global",
-   *   dedupeCacheScopeKey: "analytics-service" // Different scope
-   * });
-   *
-   * // Environment-specific scoping
-   * const apiClient = createFetchClient({
-   *   dedupeCacheScope: "global",
-   *   dedupeCacheScopeKey: `api-${process.env.NODE_ENV}` // "api-development", "api-production", etc.
-   * });
-   * ```
-   *
-   * @default "default"
-   */
-  dedupeCacheScopeKey?: "default" | AnyString | ((context: RequestContext) => string | undefined);
-  /**
-   * Custom key generator for request deduplication.
-   *
-   * Override the default key generation strategy to control exactly which requests
-   * are considered duplicates. The default key combines URL, method, body, and
-   * relevant headers (excluding volatile ones like 'Date', 'Authorization', etc.).
-   *
-   * **Default Key Generation:**
-   * The auto-generated key includes:
-   * - Full request URL (including query parameters)
-   * - HTTP method (GET, POST, etc.)
-   * - Request body (for POST/PUT/PATCH requests)
-   * - Stable headers (excludes Date, Authorization, User-Agent, etc.)
-   *
-   * **Custom Key Best Practices:**
-   * - Include only the parts of the request that should affect deduplication
-   * - Avoid including volatile data (timestamps, random IDs, etc.)
-   * - Consider performance - simpler keys are faster to compute and compare
-   * - Ensure keys are deterministic for the same logical request
-   * - Use consistent key formats across your application
-   *
-   * **Performance Considerations:**
-   * - Function-based keys are computed on every request - keep them lightweight
-   * - String keys are fastest but least flexible
-   * - Consider caching expensive key computations if needed
-   *
-   * @example
-   * ```ts
-   * import { callApi } from "@zayne-labs/callapi";
-   *
-   * // Simple static key - useful for singleton requests
-   * const config = callApi("/api/config", {
-   *   dedupeKey: "app-config",
-   *   dedupeStrategy: "defer" // Share the same config across all requests
-   * });
-   *
-   * // URL and method only - ignore headers and body
-   * const userData = callApi("/api/user/123", {
-   *   dedupeKey: (context) => `${context.options.method}:${context.options.fullURL}`
-   * });
-   *
-   * // Include specific headers in deduplication
-   * const apiCall = callApi("/api/data", {
-   *   dedupeKey: (context) => {
-   *     const authHeader = context.request.headers.get("Authorization");
-   *     return `${context.options.fullURL}-${authHeader}`;
-   *   }
-   * });
-   *
-   * // User-specific deduplication
-   * const userSpecificCall = callApi("/api/dashboard", {
-   *   dedupeKey: (context) => {
-   *     const userId = context.options.fullURL.match(/user\/(\d+)/)?.[1];
-   *     return `dashboard-${userId}`;
-   *   }
-   * });
-   *
-   * // Ignore certain query parameters
-   * const searchCall = callApi("/api/search?q=test&timestamp=123456", {
-   *   dedupeKey: (context) => {
-   *     const url = new URL(context.options.fullURL);
-   *     url.searchParams.delete("timestamp"); // Remove volatile param
-   *     return `search:${url.toString()}`;
-   *   }
-   * });
-   * ```
-   *
-   * @default Auto-generated from request details
-   */
-  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);
-   *   }
-   * };
-   *
-   * ```
-   *
-   * @default "cancel"
-   */
-  dedupeStrategy?: DedupeStrategyUnion | ((context: RequestContext) => DedupeStrategyUnion);
-};
-//#endregion
-//#region src/middlewares.d.ts
-type FetchImpl = UnmaskType<(input: string | Request | URL, init?: RequestInit) => Promise<Response>>;
-interface Middlewares {
-  /**
-   * 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();
-   *   if (cache.has(key)) return cache.get(key).clone();
-   *
-   *   const response = await ctx.fetchImpl(input, init);
-   *   cache.set(key, response.clone());
-   *   return response;
-   * }
-   *
-   * // Handle offline
-   * fetchMiddleware: (ctx) => async (input, init) => {
-   *   if (!navigator.onLine) {
-   *     return new Response('{"error": "offline"}', { status: 503 });
-   *   }
-   *   return ctx.fetchImpl(input, init);
-   * }
-   * ```
-   */
-  fetchMiddleware?: (context: RequestContext & {
-    fetchImpl: FetchImpl;
-  }) => FetchImpl;
-}
-//#endregion
-//#region src/url.d.ts
-type AllowedQueryParamValues = UnmaskType<boolean | number | string>;
-type RecordStyleParams = UnmaskType<Record<string, AllowedQueryParamValues>>;
-type TupleStyleParams = UnmaskType<AllowedQueryParamValues[]>;
-type Params = UnmaskType<RecordStyleParams | TupleStyleParams>;
-type Query = UnmaskType<Record<string, AllowedQueryParamValues>>;
-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/types/conditional-types.d.ts
-/**
- * @description Makes a type partial if the output type of TSchema is not provided or has undefined in the union, otherwise makes it required
- */
-type MakeSchemaOptionRequiredIfDefined<TSchemaOption extends CallApiSchema[keyof CallApiSchema], TObject> = undefined extends InferSchemaOutput<TSchemaOption, undefined> ? TObject : Required<TObject>;
-type ApplyURLBasedConfig<TSchemaConfig$1 extends CallApiSchemaConfig, TSchemaRouteKeys extends string> = TSchemaConfig$1["prefix"] extends string ? `${TSchemaConfig$1["prefix"]}${TSchemaRouteKeys}` : TSchemaConfig$1["baseURL"] extends string ? `${TSchemaConfig$1["baseURL"]}${TSchemaRouteKeys}` : TSchemaRouteKeys;
-type ApplyStrictConfig<TSchemaConfig$1 extends CallApiSchemaConfig, TSchemaRouteKeys extends string> = TSchemaConfig$1["strict"] extends true ? TSchemaRouteKeys :
-// eslint-disable-next-line perfectionist/sort-union-types -- Don't sort union types
-TSchemaRouteKeys | Exclude<InitURLOrURLObject, RouteKeyMethodsURLUnion>;
-type ApplySchemaConfiguration<TSchemaConfig$1 extends CallApiSchemaConfig, TSchemaRouteKeys extends string> = ApplyStrictConfig<TSchemaConfig$1, ApplyURLBasedConfig<TSchemaConfig$1, TSchemaRouteKeys>>;
-type InferAllRouteKeys<TBaseSchemaRoutes$1 extends BaseCallApiSchemaRoutes, TSchemaConfig$1 extends CallApiSchemaConfig> = ApplySchemaConfiguration<TSchemaConfig$1, Exclude<Extract<keyof TBaseSchemaRoutes$1, string>, FallBackRouteSchemaKey>>;
-type InferInitURL<TBaseSchemaRoutes$1 extends BaseCallApiSchemaRoutes, TSchemaConfig$1 extends CallApiSchemaConfig> = keyof TBaseSchemaRoutes$1 extends never ? InitURLOrURLObject : InferAllRouteKeys<TBaseSchemaRoutes$1, TSchemaConfig$1>;
-type GetCurrentRouteSchema<TBaseSchemaRoutes$1 extends BaseCallApiSchemaRoutes, TCurrentRouteSchemaKey$1 extends string, TComputedFallBackRouteSchema = TBaseSchemaRoutes$1[FallBackRouteSchemaKey], TComputedCurrentRouteSchema = TBaseSchemaRoutes$1[TCurrentRouteSchemaKey$1], TComputedRouteSchema extends CallApiSchema = NonNullable<Omit<TComputedFallBackRouteSchema, keyof TComputedCurrentRouteSchema> & TComputedCurrentRouteSchema>> = TComputedRouteSchema extends CallApiSchema ? Writeable<TComputedRouteSchema, "deep"> : CallApiSchema;
-type JsonPrimitive = boolean | number | string | null | undefined;
-type SerializableObject = Record<PropertyKey, unknown>;
-type SerializableArray = Array<JsonPrimitive | SerializableObject> | ReadonlyArray<JsonPrimitive | SerializableObject>;
-type Body = UnmaskType<Exclude<RequestInit["body"], undefined> | SerializableArray | SerializableObject>;
-type InferBodyOption<TSchema$1 extends CallApiSchema> = MakeSchemaOptionRequiredIfDefined<TSchema$1["body"], {
-  /**
-   * Body of the request, can be a object or any other supported body type.
-   */
-  body?: InferSchemaOutput<TSchema$1["body"], Body>;
-}>;
-type MethodUnion = UnmaskType<"CONNECT" | "DELETE" | "GET" | "HEAD" | "OPTIONS" | "PATCH" | "POST" | "PUT" | "TRACE" | AnyString>;
-type InferMethodFromURL<TInitURL$1> = string extends TInitURL$1 ? MethodUnion : TInitURL$1 extends `@${infer TMethod extends RouteKeyMethods}/${string}` ? Uppercase<TMethod> : MethodUnion;
-type InferMethodOption<TSchema$1 extends CallApiSchema, TInitURL$1> = MakeSchemaOptionRequiredIfDefined<TSchema$1["method"], {
-  /**
-   * HTTP method for the request.
-   * @default "GET"
-   */
-  method?: InferSchemaOutput<TSchema$1["method"], InferMethodFromURL<TInitURL$1>>;
-}>;
-type HeadersOption = UnmaskType<Record<"Authorization", CommonAuthorizationHeaders | undefined> | Record<"Content-Type", CommonContentTypes | undefined> | Record<CommonRequestHeaders, string | undefined> | Record<string, string | undefined> | Array<[string, string]>>;
-type InferHeadersOption<TSchema$1 extends CallApiSchema> = MakeSchemaOptionRequiredIfDefined<TSchema$1["headers"], {
-  /**
-   * Headers to be used in the request.
-   */
-  headers?: InferSchemaOutput<TSchema$1["headers"], HeadersOption> | ((context: {
-    baseHeaders: NonNullable<HeadersOption>;
-  }) => InferSchemaOutput<TSchema$1["headers"], HeadersOption>);
-}>;
-type InferRequestOptions<TSchema$1 extends CallApiSchema, TInitURL$1 extends InferInitURL<BaseCallApiSchemaRoutes, CallApiSchemaConfig>> = InferBodyOption<TSchema$1> & InferHeadersOption<TSchema$1> & InferMethodOption<TSchema$1, TInitURL$1>;
-type InferMetaOption<TSchema$1 extends CallApiSchema, TCallApiContext$1 extends CallApiContext> = MakeSchemaOptionRequiredIfDefined<TSchema$1["meta"], {
-  /**
-   * - 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" },
-   * });
-   * ```
-   */
-  meta?: InferSchemaOutput<TSchema$1["meta"], TCallApiContext$1["Meta"]>;
-}>;
-type InferQueryOption<TSchema$1 extends CallApiSchema> = MakeSchemaOptionRequiredIfDefined<TSchema$1["query"], {
-  /**
-   * Parameters to be appended to the URL (i.e: /:id)
-   */
-  query?: InferSchemaOutput<TSchema$1["query"], Query>;
-}>;
-type EmptyString = "";
-type EmptyTuple = readonly [];
-type StringTuple = readonly string[];
-type PossibleParamNamePatterns = `${string}:${string}` | `${string}{${string}}${"" | AnyString}`;
-type ExtractRouteParamNames<TCurrentRoute$1, TParamNamesAccumulator extends StringTuple = EmptyTuple> = TCurrentRoute$1 extends PossibleParamNamePatterns ? TCurrentRoute$1 extends `${infer TRoutePrefix}:${infer TParamAndRemainingRoute}` ? TParamAndRemainingRoute extends `${infer TCurrentParam}/${infer TRemainingRoute}` ? TCurrentParam extends EmptyString ? ExtractRouteParamNames<`${TRoutePrefix}/${TRemainingRoute}`, TParamNamesAccumulator> : ExtractRouteParamNames<`${TRoutePrefix}/${TRemainingRoute}`, [...TParamNamesAccumulator, TCurrentParam]> : TParamAndRemainingRoute extends `${infer TCurrentParam}` ? TCurrentParam extends EmptyString ? ExtractRouteParamNames<TRoutePrefix, TParamNamesAccumulator> : ExtractRouteParamNames<TRoutePrefix, [...TParamNamesAccumulator, TCurrentParam]> : ExtractRouteParamNames<TRoutePrefix, TParamNamesAccumulator> : TCurrentRoute$1 extends `${infer TRoutePrefix}{${infer TCurrentParam}}${infer TRemainingRoute}` ? TCurrentParam extends EmptyString ? ExtractRouteParamNames<`${TRoutePrefix}${TRemainingRoute}`, TParamNamesAccumulator> : ExtractRouteParamNames<`${TRoutePrefix}${TRemainingRoute}`, [...TParamNamesAccumulator, TCurrentParam]> : TParamNamesAccumulator : TParamNamesAccumulator;
-type ConvertParamNamesToRecord<TParamNames extends StringTuple> = Prettify<TParamNames extends (readonly [infer TFirstParamName extends string, ...infer TRemainingParamNames extends StringTuple]) ? Record<TFirstParamName, AllowedQueryParamValues> & ConvertParamNamesToRecord<TRemainingParamNames> : NonNullable<unknown>>;
-type ConvertParamNamesToTuple<TParamNames extends StringTuple> = TParamNames extends readonly [string, ...infer TRemainingParamNames extends StringTuple] ? [AllowedQueryParamValues, ...ConvertParamNamesToTuple<TRemainingParamNames>] : [];
-type InferParamsFromRoute<TCurrentRoute$1> = ExtractRouteParamNames<TCurrentRoute$1> extends StringTuple ? ExtractRouteParamNames<TCurrentRoute$1> extends EmptyTuple ? Params : ConvertParamNamesToRecord<ExtractRouteParamNames<TCurrentRoute$1>> | ConvertParamNamesToTuple<ExtractRouteParamNames<TCurrentRoute$1>> : Params;
-type MakeParamsOptionRequired<TParamsSchemaOption extends CallApiSchema["params"], TBaseSchemaRoutes$1 extends BaseCallApiSchemaRoutes, TCurrentRouteSchemaKey$1 extends string, TObject> = MakeSchemaOptionRequiredIfDefined<TParamsSchemaOption, Params extends InferParamsFromRoute<TCurrentRouteSchemaKey$1> ? TObject : TCurrentRouteSchemaKey$1 extends Extract<keyof TBaseSchemaRoutes$1, TCurrentRouteSchemaKey$1> ? undefined extends InferSchemaOutput<TParamsSchemaOption, null> ? TObject : Required<TObject> : TObject>;
-type InferParamsOption<TSchema$1 extends CallApiSchema, TBaseSchemaRoutes$1 extends BaseCallApiSchemaRoutes, TCurrentRouteSchemaKey$1 extends string> = MakeParamsOptionRequired<TSchema$1["params"], TBaseSchemaRoutes$1, TCurrentRouteSchemaKey$1, {
-  /**
-   * Parameters to be appended to the URL (i.e: /:id)
-   */
-  params?: InferSchemaOutput<TSchema$1["params"], InferParamsFromRoute<TCurrentRouteSchemaKey$1>>;
-}>;
-type InferExtraOptions<TSchema$1 extends CallApiSchema, TBaseSchemaRoutes$1 extends BaseCallApiSchemaRoutes, TCurrentRouteSchemaKey$1 extends string, TCallApiContext$1 extends CallApiContext> = InferMetaOption<TSchema$1, TCallApiContext$1> & InferParamsOption<TSchema$1, TBaseSchemaRoutes$1, TCurrentRouteSchemaKey$1> & InferQueryOption<TSchema$1>;
-type InferPluginOptions<TPluginArray$1 extends CallApiPlugin[]> = UnionToIntersection<TPluginArray$1 extends Array<infer TPlugin> ? TPlugin extends CallApiPlugin ? TPlugin["defineExtraOptions"] extends AnyFunction$1<infer TReturnedSchema> ? InferSchemaOutput<TReturnedSchema> : never : never : never>;
-type ResultModeOption<TErrorData$1, TResultMode$1 extends ResultModeType> = TErrorData$1 extends false ? {
-  resultMode: "onlyData";
-} : TErrorData$1 extends false | undefined ? {
-  resultMode?: "onlyData";
-} : {
-  resultMode?: TResultMode$1;
-};
-type ThrowOnErrorUnion = boolean;
-type ThrowOnErrorType<TErrorData$1, TThrowOnError$1 extends ThrowOnErrorUnion> = TThrowOnError$1 | ((context: ErrorContext<{
-  ErrorData: TErrorData$1;
-}>) => TThrowOnError$1);
-type ThrowOnErrorOption<TErrorData$1, TThrowOnError$1 extends ThrowOnErrorUnion> = TErrorData$1 extends false ? {
-  throwOnError: true;
-} : TErrorData$1 extends false | undefined ? {
-  throwOnError?: true;
-} : {
-  throwOnError?: ThrowOnErrorType<TErrorData$1, TThrowOnError$1>;
-};
-//#endregion
-//#region src/types/standard-schema.d.ts
-/**
- * The Standard Schema interface.
- * @see https://github.com/standard-schema/standard-schema
- */
-interface StandardSchemaV1<Input$1 = unknown, Output$1 = Input$1> {
-  /**
-   * The Standard Schema properties.
-   */
-  readonly "~standard": StandardSchemaV1.Props<Input$1, Output$1>;
-}
-declare namespace StandardSchemaV1 {
-  /**
-   * The Standard Schema properties interface.
-   */
-  interface Props<Input = unknown, Output = Input> {
-    /**
-     * Inferred types associated with the schema.
-     */
-    readonly types?: Types<Input, Output> | undefined;
-    /**
-     * Validates unknown input values.
-     */
-    readonly validate: (value: unknown) => Promise<Result<Output>> | Result<Output>;
-    /**
-     * The vendor name of the schema library.
-     */
-    readonly vendor: string;
-    /**
-     * The version number of the standard.
-     */
-    readonly version: 1;
-  }
-  /**
-   * The result interface of the validate function.
-   */
-  type Result<Output> = FailureResult | SuccessResult<Output>;
-  /**
-   * The result interface if validation succeeds.
-   */
-  interface SuccessResult<Output> {
-    /**
-     * The non-existent issues.
-     */
-    readonly issues?: undefined;
-    /**
-     * The typed output value.
-     */
-    readonly value: Output;
-  }
-  /**
-   * The result interface if validation fails.
-   */
-  interface FailureResult {
-    /**
-     * The issues of failed validation.
-     */
-    readonly issues: readonly Issue[];
-  }
-  /**
-   * The issue interface of the failure output.
-   */
-  interface Issue {
-    /**
-     * The error message of the issue.
-     */
-    readonly message: string;
-    /**
-     * The path of the issue, if any.
-     */
-    readonly path?: ReadonlyArray<PathSegment | PropertyKey> | undefined;
-  }
-  /**
-   * The path segment interface of the issue.
-   */
-  interface PathSegment {
-    /**
-     * The key representing a path segment.
-     */
-    readonly key: PropertyKey;
-  }
-  /**
-   * The Standard Schema types interface.
-   */
-  interface Types<Input = unknown, Output = Input> {
-    /** The input type of the schema. */
-    readonly input: Input;
-    /** The output type of the schema. */
-    readonly output: Output;
-  }
-  /**
-   * Infers the input type of a Standard Schema.
-   */
-  type InferInput<Schema extends StandardSchemaV1> = NonNullable<Schema["~standard"]["types"]>["input"];
-  /**
-   * Infers the output type of a Standard Schema.
-   */
-  type InferOutput<Schema extends StandardSchemaV1> = NonNullable<Schema["~standard"]["types"]>["output"];
-}
-//#endregion
-//#region src/utils/external/error.d.ts
-type HTTPErrorDetails<TErrorData$1> = Pick<CallApiExtraOptions, "defaultHTTPErrorMessage"> & {
-  errorData: TErrorData$1;
-  response: Response;
-};
-declare class HTTPError<TErrorData$1 = Record<string, unknown>> extends Error {
-  errorData: HTTPErrorDetails<TErrorData$1>["errorData"];
-  readonly httpErrorSymbol: symbol;
-  name: "HTTPError";
-  response: HTTPErrorDetails<TErrorData$1>["response"];
-  constructor(errorDetails: HTTPErrorDetails<TErrorData$1>, errorOptions?: ErrorOptions);
-  /**
-   * @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$1>;
-}
-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.
-   */
-  issueCause: "unknown" | `schemaConfig-(${SafeExtract<keyof CallApiSchemaConfig, "strict">})` | keyof CallApiSchema;
-  /**
-   * The issues that caused the validation error.
-   */
-  issues: readonly StandardSchemaV1.Issue[];
-  /**
-   * The response from server, if any.
-   */
-  response: Response | null;
-};
-declare class ValidationError extends Error {
-  errorData: ValidationErrorDetails["issues"];
-  issueCause: ValidationErrorDetails["issueCause"];
-  name: "ValidationError";
-  response: ValidationErrorDetails["response"];
-  readonly validationErrorSymbol: symbol;
-  constructor(details: ValidationErrorDetails, errorOptions?: ErrorOptions);
-  /**
-   * @description Checks if the given error is an instance of ValidationError
-   * @param error - The error to check
-   * @returns true if the error is an instance of ValidationError, false otherwise
-   */
-  static isError(error: unknown): error is ValidationError;
-}
-//#endregion
-//#region src/result.d.ts
-type Parser<TData$1> = (responseString: string) => Awaitable<TData$1>;
-declare const getResponseType: <TResponse>(response: Response, parser: Parser<TResponse>) => {
-  arrayBuffer: () => Promise<ArrayBuffer>;
-  blob: () => Promise<Blob>;
-  formData: () => Promise<FormData>;
-  json: () => Promise<TResponse>;
-  stream: () => ReadableStream<Uint8Array<ArrayBuffer>> | null;
-  text: () => Promise<string>;
-};
-type InitResponseTypeMap<TResponse$1 = unknown> = ReturnType<typeof getResponseType<TResponse$1>>;
-type ResponseTypeUnion = keyof InitResponseTypeMap;
-type ResponseTypePlaceholder = null;
-type ResponseTypeType = ResponseTypePlaceholder | ResponseTypeUnion;
-type ResponseTypeMap<TResponse$1> = { [Key in keyof InitResponseTypeMap<TResponse$1>]: Awaited<ReturnType<InitResponseTypeMap<TResponse$1>[Key]>> };
-type GetResponseType<TResponse$1, TResponseType$1 extends ResponseTypeType, TComputedResponseTypeMap extends ResponseTypeMap<TResponse$1> = ResponseTypeMap<TResponse$1>> = null extends TResponseType$1 ? TComputedResponseTypeMap["json"] : TResponseType$1 extends NonNullable<ResponseTypeType> ? TComputedResponseTypeMap[TResponseType$1] : never;
-type CallApiResultSuccessVariant<TData$1> = {
-  data: NoInfer<TData$1>;
-  error: null;
-  response: Response;
-};
-type PossibleJavaScriptError = UnmaskType<{
-  errorData: false;
-  message: string;
-  name: "AbortError" | "Error" | "SyntaxError" | "TimeoutError" | "TypeError" | AnyString;
-  originalError: DOMException | Error | SyntaxError | TypeError;
-}>;
-type PossibleHTTPError<TErrorData$1> = UnmaskType<{
-  errorData: NoInfer<TErrorData$1>;
-  message: string;
-  name: "HTTPError";
-  originalError: HTTPError;
-}>;
-type PossibleValidationError = UnmaskType<{
-  errorData: ValidationError["errorData"];
-  issueCause: ValidationError["issueCause"];
-  message: string;
-  name: "ValidationError";
-  originalError: ValidationError;
-}>;
-type PossibleJavaScriptOrValidationError = UnmaskType<PossibleJavaScriptError | PossibleValidationError>;
-type CallApiResultErrorVariant<TErrorData$1> = {
-  data: null;
-  error: PossibleHTTPError<TErrorData$1>;
-  response: Response;
-} | {
-  data: null;
-  error: PossibleJavaScriptOrValidationError;
-  response: Response | null;
-};
-type CallApiSuccessOrErrorVariant<TData$1, TError> = CallApiResultErrorVariant<TError> | CallApiResultSuccessVariant<TData$1>;
-type ResultModeMapWithoutException<TData$1, TErrorData$1, TResponseType$1 extends ResponseTypeType, TComputedData = GetResponseType<TData$1, TResponseType$1>, TComputedErrorData = GetResponseType<TErrorData$1, TResponseType$1>, TComputedResult$1 extends CallApiSuccessOrErrorVariant<TComputedData, TComputedErrorData> = CallApiSuccessOrErrorVariant<TComputedData, TComputedErrorData>> = UnmaskType<{
-  all: TComputedResult$1;
-  onlyData: TComputedResult$1["data"];
-  onlyResponse: TComputedResult$1["response"];
-  withoutResponse: DistributiveOmit<TComputedResult$1, "response">;
-}>;
-type ResultModeMapWithException<TData$1, TResponseType$1 extends ResponseTypeType, TComputedData = GetResponseType<TData$1, TResponseType$1>, TComputedResult$1 extends CallApiResultSuccessVariant<TComputedData> = CallApiResultSuccessVariant<TComputedData>> = {
-  all: TComputedResult$1;
-  onlyData: TComputedResult$1["data"];
-  onlyResponse: TComputedResult$1["response"];
-  withoutResponse: DistributiveOmit<TComputedResult$1, "response">;
-};
-type ResultModeMap<TData$1 = DefaultDataType, TErrorData$1 = DefaultDataType, TResponseType$1 extends ResponseTypeType = ResponseTypeType, TThrowOnError$1 extends ThrowOnErrorUnion = DefaultThrowOnError> = TThrowOnError$1 extends true ? ResultModeMapWithException<TData$1, TResponseType$1> : ResultModeMapWithoutException<TData$1, TErrorData$1, TResponseType$1>;
-type ResultModePlaceholder = null;
-type ResultModeUnion = keyof ResultModeMap;
-type ResultModeType = ResultModePlaceholder | ResultModeUnion;
-//#endregion
-//#region src/retry.d.ts
-declare const defaultRetryStatusCodesLookup: () => Readonly<{
-  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$1> = (context: ErrorContext<{
-  ErrorData: TErrorData$1;
-}>) => Awaitable<boolean>;
-type RetryOptionKeys<TErrorData$1> = Exclude<keyof RetryOptions<TErrorData$1>, "~retryAttemptCount" | "retry">;
-type InnerRetryOptions<TErrorData$1> = { [Key in RetryOptionKeys<TErrorData$1> as RemovePrefix<"retry", Key>]?: RetryOptions<TErrorData$1>[Key] };
-interface RetryOptions<TErrorData$1> {
-  /**
-   * Keeps track of the number of times the request has already been retried
-   * @internal
-   * @deprecated **NOTE**: This property is used internally to track retries. Please abstain from modifying it.
-   */
-  readonly ["~retryAttemptCount"]?: number;
-  /**
-   * All retry options in a single object instead of separate properties
-   */
-  retry?: InnerRetryOptions<TErrorData$1>;
-  /**
-   * 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$1>;
-  /**
-   * 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";
-}
-//#endregion
-//#region src/types/common.d.ts
-interface Register {}
-type GlobalMeta = Register extends {
-  meta?: infer TMeta extends DefaultMetaObject;
-} ? TMeta : DefaultMetaObject;
-type CallApiContext = {
-  Data?: DefaultDataType;
-  ErrorData?: DefaultDataType;
-  InferredPluginOptions?: unknown;
-  Meta?: DefaultMetaObject;
-  ResultMode?: ResultModeType;
-};
-type FetchSpecificKeysUnion = Exclude<(typeof fetchSpecificKeys)[number], "body" | "headers" | "method">;
-type ModifiedRequestInit = RequestInit & {
-  duplex?: "half";
-};
-type CallApiRequestOptions = Prettify<{
-  /**
-   * Body of the request, can be a object or any other supported body type.
-   */
-  body?: Body;
-  /**
-   * Headers to be used in the request.
-   */
-  headers?: HeadersOption;
-  /**
-   * HTTP method for the request.
-   * @default "GET"
-   */
-  method?: MethodUnion;
-} & Pick<ModifiedRequestInit, FetchSpecificKeysUnion>>;
-type CallApiRequestOptionsForHooks = Omit<CallApiRequestOptions, "headers"> & {
-  headers: Record<string, string | undefined>;
-};
-type SharedExtraOptions<TCallApiContext$1 extends CallApiContext = DefaultCallApiContext, TData$1 = DefaultDataType, TErrorData$1 = DefaultDataType, TResultMode$1 extends ResultModeType = ResultModeType, TThrowOnError$1 extends ThrowOnErrorUnion = DefaultThrowOnError, TResponseType$1 extends ResponseTypeType = ResponseTypeType, TPluginArray$1 extends CallApiPlugin[] = DefaultPluginArray, TComputedPluginOptions = InferPluginOptions<TPluginArray$1> & TCallApiContext$1["InferredPluginOptions"], TComputedInferredPluginOptions extends Pick<Required<CallApiContext>, "InferredPluginOptions"> = {
-  InferredPluginOptions: TComputedPluginOptions;
-}> = DedupeOptions & HookConfigOptions & HooksOrHooksArray<TComputedInferredPluginOptions, TData$1, TErrorData$1> & Middlewares & Partial<TComputedInferredPluginOptions["InferredPluginOptions"]> & ResultModeOption<TErrorData$1, TResultMode$1> & RetryOptions<TErrorData$1> & ThrowOnErrorOption<TErrorData$1, TThrowOnError$1> & URLOptions & {
-  /**
-   * Automatically add an Authorization header value.
-   *
-   * Supports multiple authentication patterns:
-   * - String: Direct authorization header value
-   * - Auth object: Structured authentication configuration
-   *
-   * ```
-   */
-  auth?: Auth;
-  /**
-   * Custom function to serialize request body objects into strings.
-   *
-   * Useful for custom serialization formats or when the default JSON
-   * serialization doesn't meet your needs.
-   *
-   * @example
-   * ```ts
-   * // Custom form data serialization
-   * bodySerializer: (data) => {
-   *   const formData = new URLSearchParams();
-   *   Object.entries(data).forEach(([key, value]) => {
-   *     formData.append(key, String(value));
-   *   });
-   *   return formData.toString();
-   * }
-   *
-   * // XML serialization
-   * bodySerializer: (data) => {
-   *   return `<request>${Object.entries(data)
-   *     .map(([key, value]) => `<${key}>${value}</${key}>`)
-   *     .join('')}</request>`;
-   * }
-   *
-   * // Custom JSON with specific formatting
-   * bodySerializer: (data) => JSON.stringify(data, null, 2)
-   * ```
-   */
-  bodySerializer?: (bodyData: Record<string, unknown>) => string;
-  /**
-   * Whether to clone the response so it can be read multiple times.
-   *
-   * By default, response streams can only be consumed once. Enable this when you need
-   * to read the response in multiple places (e.g., in hooks and main code).
-   *
-   * @see https://developer.mozilla.org/en-US/docs/Web/API/Response/clone
-   * @default false
-   */
-  cloneResponse?: boolean;
-  /**
-   * Custom fetch implementation to replace the default fetch function.
-   *
-   * Useful for testing, adding custom behavior, or using alternative HTTP clients
-   * that implement the fetch API interface.
-   *
-   * @example
-   * ```ts
-   * // Use node-fetch in Node.js environments
-   * import fetch from 'node-fetch';
-   *
-   * // Mock fetch for testing
-   * customFetchImpl: async (url, init) => {
-   *   return new Response(JSON.stringify({ mocked: true }), {
-   *     status: 200,
-   *     headers: { 'Content-Type': 'application/json' }
-   *   });
-   * }
-   *
-   * // Add custom logging to all requests
-   * customFetchImpl: async (url, init) => {
-   *   console.log(`Fetching: ${url}`);
-   *   const response = await fetch(url, init);
-   *   console.log(`Response: ${response.status}`);
-   *   return response;
-   * }
-   *
-   * // Use with custom HTTP client
-   * customFetchImpl: async (url, init) => {
-   *   // Convert to your preferred HTTP client format
-   *   return await customHttpClient.request({
-   *     url: url.toString(),
-   *     method: init?.method || 'GET',
-   *     headers: init?.headers,
-   *     body: init?.body
-   *   });
-   * }
-   * ```
-   */
-  customFetchImpl?: FetchImpl;
-  /**
-   * Default HTTP error message when server doesn't provide one.
-   *
-   * Can be a static string or a function that receives error context
-   * to generate dynamic error messages based on the response.
-   *
-   * @default "Failed to fetch data from server!"
-   *
-   * @example
-   * ```ts
-   * // Static error message
-   * defaultHTTPErrorMessage: "API request failed. Please try again."
-   *
-   * // Dynamic error message based on status code
-   * defaultHTTPErrorMessage: ({ response }) => {
-   *   switch (response.status) {
-   *     case 401: return "Authentication required. Please log in.";
-   *     case 403: return "Access denied. Insufficient permissions.";
-   *     case 404: return "Resource not found.";
-   *     case 429: return "Too many requests. Please wait and try again.";
-   *     case 500: return "Server error. Please contact support.";
-   *     default: return `Request failed with status ${response.status}`;
-   *   }
-   * }
-   *
-   * // Include error data in message
-   * defaultHTTPErrorMessage: ({ errorData, response }) => {
-   *   const userMessage = errorData?.message || "Unknown error occurred";
-   *   return `${userMessage} (Status: ${response.status})`;
-   * }
-   * ```
-   */
-  defaultHTTPErrorMessage?: string | ((context: Pick<HTTPError<TErrorData$1>, "errorData" | "response">) => string);
-  /**
-   * Forces calculation of total byte size from request/response body streams.
-   *
-   * Useful when the Content-Length header is missing or incorrect, and you need
-   * accurate size information for progress tracking or bandwidth monitoring.
-   *
-   * @default false
-   *
-   */
-  forcefullyCalculateStreamSize?: boolean | {
-    request?: boolean;
-    response?: boolean;
-  };
-  /**
-   * Optional metadata field for associating additional information with requests.
-   *
-   * Useful for logging, tracing, or handling specific cases in shared interceptors.
-   * The meta object is passed through to all hooks and can be accessed in error handlers.
-   *
-   * @example
-   * ```ts
-   * const callMainApi = callApi.create({
-   * 	baseURL: "https://main-api.com",
-   * 	onResponseError: ({ response, options }) => {
-   * 		if (options.meta?.userId) {
-   * 			console.error(`User ${options.meta.userId} made an error`);
-   * 		}
-   * 	},
-   * });
-   *
-   * const response = await callMainApi({
-   * 	url: "https://example.com/api/data",
-   * 	meta: { userId: "123" },
-   * });
-   *
-   * // Use case: Request tracking
-   * const result = await callMainApi({
-   *   url: "https://example.com/api/data",
-   *   meta: {
-   *     requestId: generateId(),
-   *     source: "user-dashboard",
-   *     priority: "high"
-   *   }
-   * });
-   *
-   * // Use case: Feature flags
-   * const client = callApi.create({
-   *   baseURL: "https://api.example.com",
-   *   meta: {
-   *     features: ["newUI", "betaFeature"],
-   *     experiment: "variantA"
-   *   }
-   * });
-   * ```
-   */
-  meta?: TCallApiContext$1["Meta"] extends DefaultMetaObject ? TCallApiContext$1["Meta"] : DefaultCallApiContext["Meta"];
-  /**
-   * Custom function to parse response strings into actual value instead of the default response.json().
-   *
-   * Useful when you need custom parsing logic for specific response formats.
-   *
-   * @example
-   * ```ts
-   * responseParser: (responseString) => {
-   *   return JSON.parse(responseString);
-   * }
-   *
-   * // Parse XML responses
-   * responseParser: (responseString) => {
-   *   const parser = new DOMParser();
-   *   const doc = parser.parseFromString(responseString, "text/xml");
-   *   return xmlToObject(doc);
-   * }
-   *
-   * // Parse CSV responses
-   * responseParser: (responseString) => {
-   *   const lines = responseString.split('\n');
-   *   const headers = lines[0].split(',');
-   *   const data = lines.slice(1).map(line => {
-   *     const values = line.split(',');
-   *     return headers.reduce((obj, header, index) => {
-   *       obj[header] = values[index];
-   *       return obj;
-   *     }, {});
-   *   });
-   *   return data;
-   * }
-   *
-   * ```
-   */
-  responseParser?: (responseString: string) => Awaitable<TData$1>;
-  /**
-   * 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" });
-   * ```
-   */
-  responseType?: TResponseType$1;
-  /**
-   * Controls what data is included in the returned result object.
-   *
-   * Different modes return different combinations of data, error, and response:
-   * - **"all"**: Returns { data, error, response } - complete result information
-   * - **"onlyData"**: Returns only data (null for errors)
-   *
-   * When combined with throwOnError: true, null/error variants are automatically removed:
-   * - **"all" + throwOnError: true**: Returns { data, error: null, response } (error property is null, throws instead)
-   * - **"onlyData" + throwOnError: true**: Returns data (never null, throws on error)
-   *
-   * @default "all"
-   *
-   * @example
-   * ```ts
-   * // Complete result with all information (default)
-   * const { data, error, response } = await callApi("/users", { resultMode: "all" });
-   * if (error) {
-   *   console.error("Request failed:", error);
-   * } else {
-   *   console.log("Users:", data);
-   * }
-   *
-   * // Complete result but throws on errors (throwOnError removes error from type)
-   * try {
-   *   const { data, response } = await callApi("/users", {
-   *     resultMode: "all",
-   *     throwOnError: true
-   *   });
-   *   console.log("Users:", data); // data is never null here
-   * } catch (error) {
-   *   console.error("Request failed:", error);
-   * }
-   *
-   * // Only data, returns null on errors
-   * const users = await callApi("/users", { resultMode: "onlyData" });
-   * if (users) {
-   *   console.log("Users:", users);
-   * } else {
-   *   console.log("Request failed");
-   * }
-   *
-   * // Only data, throws on errors (throwOnError removes null from type)
-   * try {
-   *   const users = await callApi("/users", {
-   *     resultMode: "onlyData",
-   *     throwOnError: true
-   *   });
-   *   console.log("Users:", users); // users is never null here
-   * } catch (error) {
-   *   console.error("Request failed:", error);
-   * }
-   * ```
-   */
-  resultMode?: TResultMode$1;
-  /**
-   * Controls whether errors are thrown as exceptions or returned in the result.
-   *
-   * Can be a boolean or a function that receives the error and decides whether to throw.
-   * When true, errors are thrown as exceptions instead of being returned in the result object.
-   *
-   * @default false
-   *
-   * @example
-   * ```ts
-   * // Always throw errors
-   * throwOnError: true
-   * try {
-   *   const data = await callApi("/users");
-   *   console.log("Users:", data);
-   * } catch (error) {
-   *   console.error("Request failed:", error);
-   * }
-   *
-   * // Never throw errors (default)
-   * throwOnError: false
-   * const { data, error } = await callApi("/users");
-   * if (error) {
-   *   console.error("Request failed:", error);
-   * }
-   *
-   * // Conditionally throw based on error type
-   * throwOnError: (error) => {
-   *   // Throw on client errors (4xx) but not server errors (5xx)
-   *   return error.response?.status >= 400 && error.response?.status < 500;
-   * }
-   *
-   * // Throw only on specific status codes
-   * throwOnError: (error) => {
-   *   const criticalErrors = [401, 403, 404];
-   *   return criticalErrors.includes(error.response?.status);
-   * }
-   *
-   * // Throw on validation errors but not network errors
-   * throwOnError: (error) => {
-   *   return error.type === "validation";
-   * }
-   * ```
-   */
-  throwOnError?: ThrowOnErrorType<TErrorData$1, TThrowOnError$1>;
-  /**
-   * Request timeout in milliseconds. Request will be aborted if it takes longer.
-   *
-   * Useful for preventing requests from hanging indefinitely and providing
-   * better user experience with predictable response times.
-   *
-   * @example
-   * ```ts
-   * // 5 second timeout
-   * timeout: 5000
-   *
-   * // Different timeouts for different endpoints
-   * const quickApi = createFetchClient({ timeout: 3000 }); // 3s for fast endpoints
-   * const slowApi = createFetchClient({ timeout: 30000 }); // 30s for slow operations
-   *
-   * // Per-request timeout override
-   * await callApi("/quick-data", { timeout: 1000 });
-   * await callApi("/slow-report", { timeout: 60000 });
-   *
-   * // No timeout (use with caution)
-   * timeout: 0
-   * ```
-   */
-  timeout?: number;
-};
-type BaseCallApiExtraOptions<TBaseCallApiContext$1 extends CallApiContext = DefaultCallApiContext, TBaseData$1 = DefaultDataType, TBaseErrorData$1 = DefaultDataType, TBaseResultMode$1 extends ResultModeType = ResultModeType, TBaseThrowOnError$1 extends ThrowOnErrorUnion = DefaultThrowOnError, TBaseResponseType$1 extends ResponseTypeType = ResponseTypeType, TBasePluginArray$1 extends CallApiPlugin[] = DefaultPluginArray, TBaseSchemaAndConfig$1 extends BaseCallApiSchemaAndConfig = BaseCallApiSchemaAndConfig> = SharedExtraOptions<TBaseCallApiContext$1, TBaseData$1, TBaseErrorData$1, TBaseResultMode$1, TBaseThrowOnError$1, TBaseResponseType$1, TBasePluginArray$1> & {
-  /**
-   * Array of base CallApi plugins to extend library functionality.
-   *
-   * Base plugins are applied to all instances created from this base configuration
-   * and provide foundational functionality like authentication, logging, or caching.
-   *
-   * @example
-   * ```ts
-   * // Add logging plugin
-   *
-   * // Create base client with common plugins
-   * const callApi = createFetchClient({
-   *   baseURL: "https://api.example.com",
-   *   plugins: [loggerPlugin({ enabled: true })]
-   * });
-   *
-   * // All requests inherit base plugins
-   * await callApi("/users");
-   * await callApi("/posts");
-   *
-   * ```
-   */
-  plugins?: TBasePluginArray$1;
-  /**
-   * Base validation schemas for the client configuration.
-   *
-   * Defines validation rules for requests and responses that apply to all
-   * instances created from this base configuration. Provides type safety
-   * and runtime validation for API interactions.
-   */
-  schema?: TBaseSchemaAndConfig$1;
-  /**
-   * Controls which configuration parts skip automatic merging between base and instance configs.
-   *
-   * By default, CallApi automatically merges base configuration with instance configuration.
-   * This option allows you to disable automatic merging for specific parts when you need
-   * manual control over how configurations are combined.
-   *
-   * @enum
-   * - **"all"**: Disables automatic merging for both request options and extra options
-   * - **"options"**: Disables automatic merging of extra options only (hooks, plugins, etc.)
-   * - **"request"**: Disables automatic merging of request options only (headers, body, etc.)
-   *
-   * @example
-   * ```ts
-   * // Skip all automatic merging - full manual control
-   * const client = callApi.create((ctx) => ({
-   *   skipAutoMergeFor: "all",
-   *
-   *   // Manually decide what to merge
-   *   baseURL: ctx.options.baseURL, // Keep base URL
-   *   timeout: 5000, // Override timeout
-   *   headers: {
-   *     ...ctx.request.headers, // Merge headers manually
-   *     "X-Custom": "value" // Add custom header
-   *   }
-   * }));
-   *
-   * // Skip options merging - manual plugin/hook control
-   * const client = callApi.create((ctx) => ({
-   *   skipAutoMergeFor: "options",
-   *
-   *   // Manually control which plugins to use
-   *   plugins: [
-   *     ...ctx.options.plugins?.filter(p => p.name !== "unwanted") || [],
-   *     customPlugin
-   *   ],
-   *
-   *   // Request options still auto-merge
-   *   method: "POST"
-   * }));
-   *
-   * // Skip request merging - manual request control
-   * const client = callApi.create((ctx) => ({
-   *   skipAutoMergeFor: "request",
-   *
-   *   // Extra options still auto-merge (plugins, hooks, etc.)
-   *
-   *   // Manually control request options
-   *   headers: {
-   *     "Content-Type": "application/json",
-   *     // Don't merge base headers
-   *   },
-   *   method: ctx.request.method || "GET"
-   * }));
-   *
-   * // Use case: Conditional merging based on request
-   * const client = createFetchClient((ctx) => ({
-   *   skipAutoMergeFor: "options",
-   *
-   *   // Only use auth plugin for protected routes
-   *   plugins: ctx.initURL.includes("/protected/")
-   *     ? [...(ctx.options.plugins || []), authPlugin]
-   *     : ctx.options.plugins?.filter(p => p.name !== "auth") || []
-   * }));
-   * ```
-   */
-  skipAutoMergeFor?: "all" | "options" | "request";
-};
-type InferExtendSchemaContext<TBaseSchemaRoutes$1 extends BaseCallApiSchemaRoutes, TCurrentRouteSchemaKey$1 extends string> = {
-  baseSchemaRoutes: TBaseSchemaRoutes$1;
-  currentRouteSchema: GetCurrentRouteSchema<TBaseSchemaRoutes$1, TCurrentRouteSchemaKey$1>;
-};
-type GetExtendSchemaConfigContext<TBaseSchemaConfig extends CallApiSchemaConfig> = {
-  baseSchemaConfig: TBaseSchemaConfig;
-};
-type InferExtendPluginContext<TBasePluginArray$1 extends CallApiPlugin[]> = {
-  basePlugins: TBasePluginArray$1;
-};
-type CallApiExtraOptions<TCallApiContext$1 extends CallApiContext = DefaultCallApiContext, TData$1 = DefaultDataType, TErrorData$1 = DefaultDataType, TResultMode$1 extends ResultModeType = ResultModeType, TThrowOnError$1 extends ThrowOnErrorUnion = DefaultThrowOnError, TResponseType$1 extends ResponseTypeType = ResponseTypeType, TBasePluginArray$1 extends CallApiPlugin[] = DefaultPluginArray, TPluginArray$1 extends CallApiPlugin[] = DefaultPluginArray, TBaseSchemaRoutes$1 extends BaseCallApiSchemaRoutes = BaseCallApiSchemaRoutes, TSchema$1 extends CallApiSchema = CallApiSchema, TBaseSchemaConfig extends CallApiSchemaConfig = CallApiSchemaConfig, TSchemaConfig$1 extends CallApiSchemaConfig = CallApiSchemaConfig, TCurrentRouteSchemaKey$1 extends string = string, TComputedPluginContext = InferExtendPluginContext<TBasePluginArray$1>, TComputedSchemaContext = InferExtendSchemaContext<TBaseSchemaRoutes$1, TCurrentRouteSchemaKey$1>, TComputedSchemaConfigContext = GetExtendSchemaConfigContext<TBaseSchemaConfig>> = SharedExtraOptions<TCallApiContext$1, TData$1, TErrorData$1, TResultMode$1, TThrowOnError$1, TResponseType$1, TPluginArray$1> & {
-  /**
-   * Array of instance-specific CallApi plugins or a function to configure plugins.
-   *
-   * Instance plugins are added to the base plugins and provide functionality
-   * specific to this particular API instance. Can be a static array or a function
-   * that receives base plugins and returns the instance plugins.
-   *
-   */
-  plugins?: TPluginArray$1 | ((context: TComputedPluginContext) => TPluginArray$1);
-  /**
-   * For instance-specific validation schemas
-   *
-   * Defines validation rules specific to this API instance, extending or overriding the base schema.
-   *
-   * Can be a static schema object or a function that receives base schema context and returns instance schemas.
-   *
-   */
-  schema?: TSchema$1 | ((context: TComputedSchemaContext) => TSchema$1);
-  /**
-   * Instance-specific schema configuration or a function to configure schema behavior.
-   *
-   * Controls how validation schemas are applied and behave for this specific API instance.
-   * Can override base schema configuration or extend it with instance-specific validation rules.
-   *
-   */
-  schemaConfig?: TSchemaConfig$1 | ((context: TComputedSchemaConfigContext) => TSchemaConfig$1);
-};
-type CallApiExtraOptionsForHooks<TCallApiContext$1 extends CallApiContext = DefaultCallApiContext> = Hooks & Omit<CallApiExtraOptions<TCallApiContext$1>, keyof Hooks>;
-type InstanceContext = {
-  initURL: string;
-  options: CallApiExtraOptions;
-  request: CallApiRequestOptions;
-};
-type BaseCallApiConfig<TBaseCallApiContext$1 extends CallApiContext = DefaultCallApiContext, TBaseData$1 = DefaultDataType, TBaseErrorData$1 = DefaultDataType, TBaseResultMode$1 extends ResultModeType = ResultModeType, TBaseThrowOnError$1 extends ThrowOnErrorUnion = DefaultThrowOnError, TBaseResponseType$1 extends ResponseTypeType = ResponseTypeType, TBaseSchemaAndConfig$1 extends BaseCallApiSchemaAndConfig = BaseCallApiSchemaAndConfig, TBasePluginArray$1 extends CallApiPlugin[] = DefaultPluginArray, TComputedBaseConfig = BaseCallApiExtraOptions<TBaseCallApiContext$1, TBaseData$1, TBaseErrorData$1, TBaseResultMode$1, TBaseThrowOnError$1, TBaseResponseType$1, TBasePluginArray$1, TBaseSchemaAndConfig$1>> = (CallApiRequestOptions & TComputedBaseConfig) | ((context: InstanceContext) => CallApiRequestOptions & TComputedBaseConfig);
-type CallApiConfig<TCallApiContext$1 extends CallApiContext = DefaultCallApiContext, TData$1 = DefaultDataType, TErrorData$1 = DefaultDataType, TResultMode$1 extends ResultModeType = ResultModeType, TThrowOnError$1 extends ThrowOnErrorUnion = DefaultThrowOnError, TResponseType$1 extends ResponseTypeType = ResponseTypeType, TBaseSchemaRoutes$1 extends BaseCallApiSchemaRoutes = BaseCallApiSchemaRoutes, TSchema$1 extends CallApiSchema = CallApiSchema, TBaseSchemaConfig extends CallApiSchemaConfig = CallApiSchemaConfig, TSchemaConfig$1 extends CallApiSchemaConfig = CallApiSchemaConfig, TInitURL$1 extends InitURLOrURLObject = InitURLOrURLObject, TCurrentRouteSchemaKey$1 extends string = string, TBasePluginArray$1 extends CallApiPlugin[] = DefaultPluginArray, TPluginArray$1 extends CallApiPlugin[] = DefaultPluginArray> = InferExtraOptions<TSchema$1, TBaseSchemaRoutes$1, TCurrentRouteSchemaKey$1, TCallApiContext$1> & InferRequestOptions<TSchema$1, TInitURL$1> & Omit<CallApiExtraOptions<TCallApiContext$1, TData$1, TErrorData$1, TResultMode$1, TThrowOnError$1, TResponseType$1, TBasePluginArray$1, TPluginArray$1, TBaseSchemaRoutes$1, TSchema$1, TBaseSchemaConfig, TSchemaConfig$1, TCurrentRouteSchemaKey$1>, keyof InferExtraOptions<CallApiSchema, BaseCallApiSchemaRoutes, string, CallApiContext>> & Omit<CallApiRequestOptions, keyof InferRequestOptions<CallApiSchema, string>>;
-//#endregion
-//#region src/stream.d.ts
-type StreamProgressEvent = {
-  /**
-   * Current chunk of data being streamed
-   */
-  chunk: Uint8Array;
-  /**
-   * Progress in percentage
-   */
-  progress: number;
-  /**
-   * Total size of data in bytes
-   */
-  totalBytes: number;
-  /**
-   * Amount of data transferred so far
-   */
-  transferredBytes: number;
-};
-declare global {
-  interface ReadableStream<R> {
-    [Symbol.asyncIterator]: () => AsyncIterableIterator<R>;
-  }
-}
-//#endregion
-//#region src/hooks.d.ts
-interface Hooks<TCallApiContext$1 extends Pick<CallApiContext, "Data" | "ErrorData" | "InferredPluginOptions" | "Meta"> = DefaultCallApiContext, TData$1 = TCallApiContext$1["Data"], TErrorData$1 = TCallApiContext$1["ErrorData"]> {
-  /**
-   * Hook called when any error occurs within the request/response lifecycle.
-   *
-   * This is a unified error handler that catches both request errors (network failures,
-   * timeouts, etc.) and response errors (HTTP error status codes). It's essentially
-   * a combination of `onRequestError` and `onResponseError` hooks.
-   *
-   * @param context - Error context containing error details, request info, and response (if available)
-   * @returns Promise or void - Hook can be async or sync
-   */
-  onError?: (context: ErrorContext<TCallApiContext$1, TErrorData$1>) => Awaitable<unknown>;
-  /**
-   * Hook called before the HTTP request is sent and before any internal processing of the request object begins.
-   *
-   * This is the ideal place to modify request headers, add authentication,
-   * implement request logging, or perform any setup before the network call.
-   *
-   * @param context - Request context with mutable request object and configuration
-   * @returns Promise or void - Hook can be async or sync
-   *
-   */
-  onRequest?: (context: RequestContext<TCallApiContext$1>) => Awaitable<unknown>;
-  /**
-   * Hook called when an error occurs during the fetch request itself.
-   *
-   * This handles network-level errors like connection failures, timeouts,
-   * DNS resolution errors, or other issues that prevent getting an HTTP response.
-   * Note that HTTP error status codes (4xx, 5xx) are handled by `onResponseError`.
-   *
-   * @param context - Request error context with error details and null response
-   * @returns Promise or void - Hook can be async or sync
-   */
-  onRequestError?: (context: RequestErrorContext<TCallApiContext$1>) => Awaitable<unknown>;
-  /**
-   * Hook called just before the HTTP request is sent and after the request has been processed.
-   *
-   * @param context - Request context with mutable request object and configuration
-   */
-  onRequestReady?: (context: RequestContext<TCallApiContext$1>) => Awaitable<unknown>;
-  /**
-   * 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$1>) => 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$1, TData$1, TErrorData$1>) => 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$1, TErrorData$1>) => 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$1>) => 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
-   *
-   */
-  onRetry?: (response: RetryContext<TCallApiContext$1, TErrorData$1>) => Awaitable<unknown>;
-  /**
-   * Hook called when a successful response (2xx status) is received from the API.
-   *
-   * This hook is triggered only for successful responses and provides access to
-   * the parsed response data. Ideal for success logging, caching, or post-processing
-   * of successful API responses.
-   *
-   * @param context - Success context with parsed response data and response object
-   * @returns Promise or void - Hook can be async or sync
-   *
-   */
-  onSuccess?: (context: SuccessContext<TCallApiContext$1, TData$1>) => Awaitable<unknown>;
-  /**
-   * Hook called when a validation error occurs.
-   *
-   * This hook is triggered when request or response data fails validation against
-   * a defined schema. It provides access to the validation error details and can
-   * be used for custom error handling, logging, or fallback behavior.
-   *
-   * @param context - Validation error context with error details and response (if available)
-   * @returns Promise or void - Hook can be async or sync
-   *
-   */
-  onValidationError?: (context: ValidationErrorContext<TCallApiContext$1>) => Awaitable<unknown>;
-}
-type HooksOrHooksArray<TCallApiContext$1 extends CallApiContext = DefaultCallApiContext, TData$1 = TCallApiContext$1["Data"], TErrorData$1 = TCallApiContext$1["ErrorData"]> = { [Key in keyof Hooks<TCallApiContext$1, TData$1, TErrorData$1>]: Hooks<TCallApiContext$1, TData$1, TErrorData$1>[Key] | Array<Hooks<TCallApiContext$1, TData$1, TErrorData$1>[Key]> };
-interface HookConfigOptions {
-  /**
-   * Controls the execution mode of all composed hooks (main + plugin hooks).
-   *
-   * - **"parallel"**: All hooks execute simultaneously via Promise.all() for better performance
-   * - **"sequential"**: All hooks execute one by one in registration order via await in a loop
-   *
-   * This affects how ALL hooks execute together, regardless of their source (main or plugin).
-   *
-   * @default "parallel"
-   */
-  hooksExecutionMode?: "parallel" | "sequential";
-}
-type RequestContext<TCallApiContext$1 extends Pick<CallApiContext, "InferredPluginOptions" | "Meta"> = DefaultCallApiContext> = {
-  /**
-   * Base configuration object passed to createFetchClient.
-   *
-   * Contains the foundational configuration that applies to all requests
-   * made by this client instance, such as baseURL, default headers, and
-   * global options.
-   */
-  baseConfig: Exclude<BaseCallApiConfig, AnyFunction$1>;
-  /**
-   * Instance-specific configuration object passed to the callApi instance.
-   *
-   * Contains configuration specific to this particular API call, which
-   * can override or extend the base configuration.
-   */
-  config: CallApiConfig;
-  /**
-   * Merged options combining base config, instance config, and default options.
-   *
-   * This is the final resolved configuration that will be used for the request,
-   * with proper precedence applied (instance > base > defaults).
-   */
-  options: CallApiExtraOptionsForHooks<TCallApiContext$1>;
-  /**
-   * Merged request object ready to be sent.
-   *
-   * Contains the final request configuration including URL, method, headers,
-   * body, and other fetch options. This object can be modified in onRequest
-   * hooks to customize the outgoing request.
-   */
-  request: CallApiRequestOptionsForHooks;
-};
-type ValidationErrorContext<TCallApiContext$1 extends Pick<CallApiContext, "InferredPluginOptions" | "Meta"> = DefaultCallApiContext> = UnmaskType<RequestContext<TCallApiContext$1> & {
-  error: PossibleValidationError;
-  response: Response | null;
-}>;
-type SuccessContext<TCallApiContext$1 extends Pick<CallApiContext, "Data" | "InferredPluginOptions" | "Meta"> = DefaultCallApiContext, TData$1 = TCallApiContext$1["Data"]> = UnmaskType<RequestContext<TCallApiContext$1> & {
-  data: NoInfer<TData$1>;
-  response: Response;
-}>;
-type ResponseContext<TCallApiContext$1 extends Pick<CallApiContext, "Data" | "ErrorData" | "InferredPluginOptions" | "Meta"> = DefaultCallApiContext, TData$1 = TCallApiContext$1["Data"], TErrorData$1 = TCallApiContext$1["ErrorData"]> = UnmaskType<RequestContext<TCallApiContext$1> & (Prettify<CallApiResultSuccessVariant<TData$1>> | Prettify<Extract<CallApiResultErrorVariant<TErrorData$1>, {
-  error: PossibleHTTPError<TErrorData$1>;
-}>>)>;
-type RequestErrorContext<TCallApiContext$1 extends Pick<CallApiContext, "InferredPluginOptions" | "Meta"> = DefaultCallApiContext> = RequestContext<TCallApiContext$1> & {
-  error: PossibleJavaScriptError;
-  response: null;
-};
-type ErrorContext<TCallApiContext$1 extends Pick<CallApiContext, "ErrorData" | "InferredPluginOptions" | "Meta"> = DefaultCallApiContext, TErrorData$1 = TCallApiContext$1["ErrorData"]> = UnmaskType<RequestContext<TCallApiContext$1> & ({
-  error: PossibleHTTPError<TErrorData$1>;
-  response: Response;
-} | {
-  error: PossibleJavaScriptOrValidationError;
-  response: Response | null;
-})>;
-type ResponseErrorContext<TCallApiContext$1 extends Pick<CallApiContext, "ErrorData" | "InferredPluginOptions" | "Meta"> = DefaultCallApiContext, TErrorData$1 = TCallApiContext$1["ErrorData"]> = UnmaskType<Extract<ErrorContext<TCallApiContext$1, TErrorData$1>, {
-  error: PossibleHTTPError<TErrorData$1>;
-}> & RequestContext<TCallApiContext$1>>;
-type RetryContext<TCallApiContext$1 extends Pick<CallApiContext, "ErrorData" | "InferredPluginOptions" | "Meta"> = DefaultCallApiContext, TErrorData$1 = TCallApiContext$1["ErrorData"]> = UnmaskType<ErrorContext<TCallApiContext$1, TErrorData$1> & {
-  retryAttemptCount: number;
-}>;
-type RequestStreamContext<TCallApiContext$1 extends Pick<CallApiContext, "InferredPluginOptions" | "Meta"> = DefaultCallApiContext> = UnmaskType<RequestContext<TCallApiContext$1> & {
-  event: StreamProgressEvent;
-  requestInstance: Request;
-}>;
-type ResponseStreamContext<TCallApiContext$1 extends Pick<CallApiContext, "InferredPluginOptions" | "Meta"> = DefaultCallApiContext> = UnmaskType<RequestContext<TCallApiContext$1> & {
-  event: StreamProgressEvent;
-  response: Response;
-}>;
-//#endregion
-//#region src/plugins.d.ts
-type PluginSetupContext<TCallApiContext$1 extends CallApiContext = DefaultCallApiContext> = RequestContext<TCallApiContext$1> & {
-  initURL: string;
-};
-type PluginInitResult = Partial<Omit<PluginSetupContext, "initURL" | "request"> & {
-  initURL: InitURLOrURLObject;
-  request: CallApiRequestOptions;
-}>;
-type PluginHooks<TCallApiContext$1 extends CallApiContext = DefaultCallApiContext, TData$1 = (unknown extends TCallApiContext$1["Data"] ? never : TCallApiContext$1["Data"]), TErrorData$1 = (unknown extends TCallApiContext$1["ErrorData"] ? never : TCallApiContext$1["ErrorData"])> = HooksOrHooksArray<TCallApiContext$1, TData$1, TErrorData$1>;
-interface CallApiPlugin {
-  /**
-   * Defines additional options that can be passed to callApi
-   */
-  defineExtraOptions?: (...params: never[]) => unknown;
-  /**
-   * A description for the plugin
-   */
-  description?: string;
-  /**
-   * Hooks for the plugin
-   */
-  hooks?: PluginHooks | ((context: PluginSetupContext) => Awaitable<PluginHooks>);
-  /**
-   *  A unique id for the plugin
-   */
-  id: string;
-  /**
-   * Middlewares that for the plugin
-   */
-  middlewares?: Middlewares | ((context: PluginSetupContext) => Awaitable<Middlewares>);
-  /**
-   * A name for the plugin
-   */
-  name: string;
-  /**
-   * Base schema for the client.
-   */
-  schema?: BaseCallApiSchemaAndConfig;
-  /**
-   * A function that will be called when the plugin is initialized. This will be called before the any of the other internal functions.
-   */
-  setup?: (context: PluginSetupContext) => Awaitable<PluginInitResult> | Awaitable<void>;
-  /**
-   *  A version for the plugin
-   */
-  version?: string;
-}
-//#endregion
-//#region src/types/default-types.d.ts
-type DefaultDataType = unknown;
-type DefaultPluginArray = CallApiPlugin[];
-type DefaultThrowOnError = boolean;
-type DefaultMetaObject = Record<string, unknown>;
-type DefaultCallApiContext = Omit<Required<CallApiContext>, "Meta"> & {
-  Meta: GlobalMeta;
-};
-//#endregion
-//#region src/validation.d.ts
-type ResultVariant = "infer-input" | "infer-output";
-type InferSchemaResult<TSchema$1, TFallbackResult, TResultVariant extends ResultVariant> = undefined extends TSchema$1 ? TFallbackResult : TSchema$1 extends StandardSchemaV1 ? TResultVariant extends "infer-input" ? StandardSchemaV1.InferInput<TSchema$1> : StandardSchemaV1.InferOutput<TSchema$1> : TSchema$1 extends AnyFunction$1<infer TResult> ? Awaited<TResult> : TFallbackResult;
-type InferSchemaOutput<TSchema$1, TFallbackResult = unknown> = InferSchemaResult<TSchema$1, TFallbackResult, "infer-output">;
-interface CallApiSchemaConfig {
-  /**
-   * The base url of the schema. By default it's the baseURL of the callApi instance.
-   */
-  baseURL?: string;
-  /**
-   * Disables runtime validation for the schema.
-   */
-  disableRuntimeValidation?: boolean;
-  /**
-   * If `true`, the original input value will be used instead of the transformed/validated output.
-   *
-   * This is useful when you want to validate the input but don't want any transformations
-   * applied by the validation schema (e.g., type coercion, default values, etc).
-   */
-  disableValidationOutputApplication?: boolean;
-  /**
-   * Optional url prefix that will be substituted for the `baseURL` of the schemaConfig at runtime.
-   *
-   * This allows you to reuse the same schema against different base URLs (for example,
-   * swapping between `/api/v1` and `/api/v2`) without redefining the entire schema.
-   */
-  prefix?: string;
-  /**
-   * Controls the strictness of API route validation.
-   *
-   * When true:
-   * - Only routes explicitly defined in the schema will be considered valid to typescript and the runtime.
-   * - Attempting to call routes not defined in the schema will result in both type errors and runtime validation errors.
-   * - Useful for ensuring API calls conform exactly to your schema definition
-   *
-   * When false or undefined (default):
-   * - All routes will be allowed, whether they are defined in the schema or not
-   */
-  strict?: boolean;
-}
-interface CallApiSchema {
-  /**
-   *  The schema to use for validating the request body.
-   */
-  body?: StandardSchemaV1<Body | undefined> | ((body: Body) => Awaitable<Body | undefined>);
-  /**
-   *  The schema to use for validating the response data.
-   */
-  data?: StandardSchemaV1 | ((data: unknown) => unknown);
-  /**
-   *  The schema to use for validating the response error data.
-   */
-  errorData?: StandardSchemaV1 | ((errorData: unknown) => unknown);
-  /**
-   *  The schema to use for validating the request headers.
-   */
-  headers?: StandardSchemaV1<HeadersOption | undefined> | ((headers: HeadersOption) => Awaitable<HeadersOption | undefined>);
-  /**
-   *  The schema to use for validating the meta option.
-   */
-  meta?: StandardSchemaV1<GlobalMeta | undefined> | ((meta: GlobalMeta) => Awaitable<GlobalMeta | undefined>);
-  /**
-   *  The schema to use for validating the request method.
-   */
-  method?: StandardSchemaV1<MethodUnion | undefined> | ((method: MethodUnion) => Awaitable<MethodUnion | undefined>);
-  /**
-   *  The schema to use for validating the request url parameters.
-   */
-  params?: StandardSchemaV1<Params | undefined> | ((params: Params) => Awaitable<Params | undefined>);
-  /**
-   *  The schema to use for validating the request url queries.
-   */
-  query?: StandardSchemaV1<Query | undefined> | ((query: Query) => Awaitable<Query | undefined>);
-}
-declare const routeKeyMethods: readonly ["delete", "get", "patch", "post", "put"];
-type RouteKeyMethods = (typeof routeKeyMethods)[number];
-type RouteKeyMethodsURLUnion = `@${RouteKeyMethods}/`;
-type BaseSchemaRouteKeyPrefixes = FallBackRouteSchemaKey | RouteKeyMethodsURLUnion;
-type BaseCallApiSchemaRoutes = Partial<Record<AnyString | BaseSchemaRouteKeyPrefixes, CallApiSchema>>;
-type BaseCallApiSchemaAndConfig = {
-  config?: CallApiSchemaConfig;
-  routes: BaseCallApiSchemaRoutes;
-};
-//#endregion
-//#region src/createFetchClient.d.ts
-//#endregion
-//#region src/logger/logger.d.ts
-type ConsoleLikeObject = {
-  error: AnyFunction<void>;
-  fail?: AnyFunction<void>;
-  log: AnyFunction<void>;
-  success?: AnyFunction<void>;
-  warn?: AnyFunction<void>;
-};
-type LoggerOptions = {
-  /**
-   * Custom console object
-   */
-  consoleObject?: ConsoleLikeObject;
-  /**
-   * Enable or disable the logger
-   * @default true
-   */
-  enabled?: boolean | {
-    onError?: boolean;
-    onRequest?: boolean;
-    onRequestError?: boolean;
-    onResponse?: boolean;
-    onResponseError?: boolean;
-    onRetry?: boolean;
-    onSuccess?: boolean;
-    onValidationError?: boolean;
-  };
-  /**
-   * Enable or disable verbose mode
-   */
-  mode?: "basic" | "verbose";
-};
-declare const defaultConsoleObject: ConsoleLikeObject;
-declare const loggerPlugin: (options?: LoggerOptions) => {
-  id: "logger";
-  name: "Logger";
-  version: "1.1.0";
-  hooks: {
-    onRequest: (ctx: RequestContext<DefaultCallApiContext>) => void;
-    onRequestError: (ctx: RequestContext<DefaultCallApiContext> & {
-      error: PossibleJavaScriptError;
-      response: null;
-    }) => void;
-    onResponseError: (ctx: RequestContext<DefaultCallApiContext> & {
-      error: {
-        errorData: never;
-        message: string;
-        name: "HTTPError";
-        originalError: _zayne_labs_callapi_utils0.HTTPError;
-      };
-      response: Response;
-    }) => void;
-    onRetry: (ctx: (RequestContext<DefaultCallApiContext> & ({
-      error: PossibleJavaScriptOrValidationError;
-      response: Response | null;
-    } | {
-      error: {
-        errorData: never;
-        message: string;
-        name: "HTTPError";
-        originalError: _zayne_labs_callapi_utils0.HTTPError;
-      };
-      response: Response;
-    })) & {
-      retryAttemptCount: number;
-    }) => void;
-    onSuccess: (ctx: RequestContext<DefaultCallApiContext> & {
-      data: never;
-      response: Response;
-    }) => void;
-    onValidationError: (ctx: RequestContext<DefaultCallApiContext> & {
-      error: PossibleValidationError;
-      response: Response | null;
-    }) => void;
-  };
-};
-//#endregion
-export { LoggerOptions, defaultConsoleObject, loggerPlugin };
-//# sourceMappingURL=index.d.ts.map
+import { n as defaultConsoleObject, r as loggerPlugin, t as LoggerOptions } from "./index-BiLuTHUF.js";
+export { LoggerOptions, defaultConsoleObject, loggerPlugin };