@zayne-labs/callapi-plugins 4.0.45 → 5.0.0

package/dist/{index-BBzD4BfV.d.ts → index-BfWbLAGF.d.ts}

@@ -1,6 +1,7 @@
+import * as _zayne_labs_callapi_utils0 from "@zayne-labs/callapi/utils";
 import { AnyFunction } from "@zayne-labs/toolkit-type-helpers";
 
-//#region ../callapi/dist/index-N6YsZaGN.d.ts
+//#region ../callapi/dist/default-types-BUYTny8V.d.ts
 //#region src/constants/common.d.ts
 declare const fetchSpecificKeys: readonly (keyof RequestInit | "duplex")[]; //#endregion
 //#region src/types/type-helpers.d.ts
@@ -74,979 +75,1017 @@ type CustomAuth = {
   value: PossibleAuthValueOrGetter;
 };
 type AuthOption = PossibleAuthValueOrGetter | BearerAuth | TokenAuth | BasicAuth | CustomAuth; //#endregion
-//#region src/stream.d.ts
-type StreamProgressEvent = {
+//#region src/constants/validation.d.ts
+declare const fallBackRouteSchemaKey = "@default";
+type FallBackRouteSchemaKey = typeof fallBackRouteSchemaKey; //#endregion
+//#region src/types/standard-schema.d.ts
+/**
+ * The Standard Schema interface.
+ * @see https://github.com/standard-schema/standard-schema
+ */
+/** 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. */
+  type Types<Input = unknown, Output = Input> = 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
+type ResultVariant = "infer-input" | "infer-output";
+type InferSchemaResult<TSchema, TFallbackResult, TResultVariant extends ResultVariant> = undefined extends TSchema ? TFallbackResult : TSchema extends StandardSchemaV1 ? TResultVariant extends "infer-input" ? StandardSchemaV1.InferInput<TSchema> : StandardSchemaV1.InferOutput<TSchema> : TSchema extends AnyFunction$1<infer TResult> ? Awaited<TResult> : TFallbackResult;
+type InferSchemaOutput<TSchema, TFallbackResult = unknown> = InferSchemaResult<TSchema, TFallbackResult, "infer-output">;
+type BooleanObject = { [Key in keyof CallApiSchema]: boolean };
+interface CallApiSchemaConfig {
   /**
-   * Current chunk of data being streamed
+   * The base url of the schema. By default it's the baseURL of the callApi instance.
    */
-  chunk: Uint8Array;
+  baseURL?: "" | AnyString;
   /**
-   * Progress in percentage
+   * Disables runtime validation for the schema.
    */
-  progress: number;
+  disableRuntimeValidation?: boolean | BooleanObject;
   /**
-   * Total size of data in bytes
+   * If `true`, the original input value will be used instead of the transformed/validated output.
+   *
+   * When true, the original input is returned unchanged after validation, ignoring any schema-level
+   * transformations such as type coercion, default values, or field mapping. Only the validation
+   * step is executed; the resulting value is discarded in favor of the raw input.
    */
-  totalBytes: number;
+  disableRuntimeValidationTransform?: boolean | BooleanObject;
   /**
-   * Amount of data transferred so far
+   * Optional url prefix that will be substituted for the `baseURL` of the schemaConfig at runtime.
+   *
+   * Enables a short, stable prefix for routes while keeping the full `baseURL` centralized in config.
+   * Keeps route definitions concise and shields them from changes to the underlying base URL.
    */
-  transferredBytes: number;
-}; //#endregion
-//#region src/hooks.d.ts
-interface Hooks<TCallApiContext extends CallApiContext = DefaultCallApiContext> {
+  prefix?: "" | AnyString;
   /**
-   * Hook called when any error occurs within the request/response lifecycle.
+   * Controls the strictness of API route validation.
    *
-   * 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.
+   * 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
    *
-   * @param context - Error context containing error details, request info, and response (if available)
-   * @returns Promise or void - Hook can be async or sync
+   * When false or undefined (default):
+   * - All routes will be allowed, whether they are defined in the schema or not
    */
-  onError?: (context: ErrorContext<TCallApiContext>) => Awaitable<unknown>;
+  strict?: boolean;
+}
+type CallApiSchemaType<TInput> = StandardSchemaV1<TInput | undefined> | ((value: TInput) => Awaitable<TInput | undefined>);
+interface CallApiSchema {
+  auth?: CallApiSchemaType<AuthOption>;
   /**
-   * 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
-   *
+   *  The schema to use for validating the request body.
    */
-  onRequest?: (context: RequestContext<TCallApiContext>) => Awaitable<unknown>;
+  body?: CallApiSchemaType<Body>;
   /**
-   * 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
+   *  The schema to use for validating the response data.
    */
-  onRequestError?: (context: RequestErrorContext<TCallApiContext>) => Awaitable<unknown>;
+  data?: CallApiSchemaType<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
+   *  The schema to use for validating the response error data.
    */
-  onRequestReady?: (context: RequestContext<TCallApiContext>) => Awaitable<unknown>;
+  errorData?: CallApiSchemaType<unknown>;
   /**
-   * Hook called during upload stream progress tracking.
+   *  The schema to use for validating the request headers.
+   */
+  headers?: CallApiSchemaType<HeadersOption>;
+  /**
+   *  The schema to use for validating the meta option.
+   */
+  meta?: CallApiSchemaType<GlobalMeta>;
+  /**
+   *  The schema to use for validating the request method.
+   */
+  method?: CallApiSchemaType<MethodUnion>;
+  /**
+   *  The schema to use for validating the request url parameters.
+   */
+  params?: CallApiSchemaType<Params>;
+  /**
+   *  The schema to use for validating the request url queries.
+   */
+  query?: CallApiSchemaType<Query>;
+}
+declare const routeKeyMethods: readonly ["delete", "get", "patch", "post", "put"];
+type RouteKeyMethods = (typeof routeKeyMethods)[number];
+type RouteKeyMethodsURLUnion = `${AtSymbol}${RouteKeyMethods}/`;
+type BaseSchemaRouteKeyPrefixes = FallBackRouteSchemaKey | RouteKeyMethodsURLUnion;
+type BaseCallApiSchemaRoutes = Partial<Record<AnyString | BaseSchemaRouteKeyPrefixes, CallApiSchema>>;
+type BaseCallApiSchemaAndConfig = {
+  config?: CallApiSchemaConfig;
+  routes: BaseCallApiSchemaRoutes;
+}; //#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 Query = UnmaskType<Record<string, AllowedQueryParamValues> | URLSearchParams>;
+type InitURLOrURLObject = AnyString | RouteKeyMethodsURLUnion | URL;
+interface URLOptions {
+  /**
+   * Base URL for all API requests. Will only be prepended to relative URLs.
    *
-   * 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.
+   * Absolute URLs (starting with http/https) will not be prepended by the baseURL.
    *
-   * @param context - Request stream context with progress event and request instance
-   * @returns Promise or void - Hook can be async or sync
+   * @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"
+   * ```
    */
-  onRequestStream?: (context: RequestStreamContext<TCallApiContext>) => Awaitable<unknown>;
+  baseURL?: string;
   /**
-   * 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.
+   * Resolved request URL after processing baseURL, parameters, and query strings (readonly)
    *
-   * @param context - Response context with either success data or error information
-   * @returns Promise or void - Hook can be async or sync
+   * This is the final URL that will be used for the HTTP request, computed from
+   * baseURL, initURL, params, and query parameters.
    *
    */
-  onResponse?: (context: ResponseContext<TCallApiContext>) => Awaitable<unknown>;
+  readonly fullURL?: string;
   /**
-   * Hook called when an HTTP error response (4xx, 5xx) is received from the API.
+   * The original URL string passed to the callApi instance (readonly)
    *
-   * 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.
+   * This preserves the original URL as provided, including any method modifiers like "@get/" or "@post/".
    *
-   * @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>;
+  readonly initURL?: string;
   /**
-   * Hook called during download stream progress tracking.
+   * The URL string after normalization, with method modifiers removed(readonly)
    *
-   * 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
+   * Method modifiers like "@get/", "@post/" are stripped to create a clean URL
+   * for parameter substitution and final URL construction.
    *
    */
-  onRetry?: (response: RetryContext<TCallApiContext>) => Awaitable<unknown>;
+  readonly initURLNormalized?: string;
   /**
-   * Hook called when a successful response (2xx status) is received from the API.
-   *
-   * This hook is triggered only for successful responses and provides access to
-   * the parsed response data. Ideal for success logging, caching, or post-processing
-   * of successful API responses.
-   *
-   * @param context - Success context with parsed response data and response object
-   * @returns Promise or void - Hook can be async or sync
+   * Parameters to be substituted into URL path segments.
    *
-   */
-  onSuccess?: (context: SuccessContext<TCallApiContext>) => Awaitable<unknown>;
-  /**
-   * Hook called when a validation error occurs.
+   * Supports both object-style (named parameters) and array-style (positional parameters)
+   * for flexible URL parameter substitution.
    *
-   * 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.
+   * @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
    *
-   * @param context - Validation error context with error details and response (if available)
-   * @returns Promise or void - Hook can be async or sync
+   * // 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
+   * ```
    */
-  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 {
+  params?: Params;
   /**
-   * 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
+   * Query parameters to append to the URL as search parameters.
    *
-   * This affects how ALL hooks execute together, regardless of their source (main or plugin).
+   * These will be serialized into the URL query string using standard
+   * URL encoding practices.
    *
-   * @default "parallel"
-   */
-  hooksExecutionMode?: "parallel" | "sequential";
-}
-type RequestContext<TCallApiContext extends Pick<CallApiContext, "InferredExtraOptions" | "Meta"> = DefaultCallApiContext> = {
-  /**
-   * Base configuration object passed to createFetchClient.
+   * @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
    *
-   * Contains the foundational configuration that applies to all requests
-   * made by this client instance, such as baseURL, default headers, and
-   * global options.
+   * // 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
+   * ```
    */
-  baseConfig: Exclude<BaseCallApiConfig, AnyFunction$1>;
+  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 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 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> = MakeSchemaOptionRequiredIfDefined<TSchema["body"], {
   /**
-   * 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.
+   * Body of the request, can be a object or any other supported body type.
    */
-  config: CallApiConfig;
+  body?: InferSchemaOutput<TSchema["body"], Body>;
+}>;
+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"], {
   /**
-   * 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).
+   * HTTP method for the request.
+   * @default "GET"
    */
-  options: CallApiExtraOptionsForHooks<TCallApiContext>;
+  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"], {
   /**
-   * 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.
+   * Headers to be used in the request.
    */
-  request: CallApiRequestOptionsForHooks;
-};
-type ValidationErrorContext<TCallApiContext extends Pick<CallApiContext, "InferredExtraOptions" | "Meta"> = DefaultCallApiContext> = DistributiveOmit<Extract<CallApiResultErrorVariant<unknown>, {
-  error: PossibleValidationError;
-}>, "data"> & RequestContext<TCallApiContext>;
-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 RequestErrorContext<TCallApiContext extends Pick<CallApiContext, "InferredExtraOptions" | "Meta"> = DefaultCallApiContext> = DistributiveOmit<Extract<CallApiResultErrorVariant<unknown>, {
-  error: PossibleJavaScriptError;
-}>, "data"> & RequestContext<TCallApiContext>;
-type ErrorContext<TCallApiContext extends Pick<CallApiContext, "ErrorData" | "InferredExtraOptions" | "Meta"> = DefaultCallApiContext> = DistributiveOmit<CallApiResultErrorVariant<TCallApiContext["ErrorData"]>, "data"> & 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 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;
-}; //#endregion
-//#region src/dedupe.d.ts
-type DedupeStrategyUnion = UnmaskType<"cancel" | "defer" | "none">;
-type DedupeOptions = {
+  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>> = InferBodyOption<TSchema> & InferHeadersOption<TSchema> & InferMethodOption<TSchema, TInitURL>;
+type InferMetaOption<TSchema extends CallApiSchema, TCallApiContext extends CallApiContext> = MakeSchemaOptionRequiredIfDefined<TSchema["meta"], {
   /**
-   * 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.
-   *
+   * - An optional field you can fill with additional information,
+   * to associate with the request, typically used for logging or tracing.
    *
-   * **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
+   * - A good use case for this, would be to use the info to handle specific cases in any of the shared interceptors.
    *
    * @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 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 postClient = createFetchClient({
-   *   baseURL: "/api/posts",
-   *   dedupeCacheScope: "global",
+   *
+   * const response = await callMainApi({
+   * 	url: "https://example.com/api/data",
+   * 	meta: { userId: "123" },
    * });
-   * // These clients will share deduplication state
    * ```
-   *
-   * @default "local"
    */
-  dedupeCacheScope?: "global" | "local";
+  meta?: InferSchemaOutput<TSchema["meta"], TCallApiContext["Meta"]>;
+}>;
+type InferAuthOption<TSchema extends CallApiSchema> = MakeSchemaOptionRequiredIfDefined<TSchema["auth"], {
   /**
-   * 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
+   * Automatically add an Authorization header value.
    *
-   * **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
+   * Supports multiple authentication patterns:
+   * - String: Direct authorization header value
+   * - Auth object: Structured authentication configuration
    *
    * @example
    * ```ts
-   * // Group related API clients together
-   * const userClient = createFetchClient({
-   *   baseURL: "/api/users",
-   *   dedupeCacheScope: "global",
-   *   dedupeCacheScopeKey: "user-service"
+   * // Bearer auth
+   * const response = await callMainApi({
+   * 	url: "https://example.com/api/data",
+   * 	auth: "123456",
    * });
-   * 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}`
-   * });
+   * // Bearer auth
+   * const response = await callMainApi({
+   * 	url: "https://example.com/api/data",
+   * 	auth: {
+   * 		type: "Bearer",
+   * 		value: "123456",
+   * 	},
+   })
    *
-   * // Include specific headers in deduplication
-   * const apiCall = callApi("/api/data", {
-   *   dedupeKey: (context) => {
-   *     const authHeader = context.request.headers.get("Authorization");
-   *     return `${context.options.fullURL}-${authHeader}`;
-   *   }
+   * // Token auth
+   * const response = await callMainApi({
+   * 	url: "https://example.com/api/data",
+   * 	auth: {
+   * 		type: "Token",
+   * 		value: "123456",
+   * 	},
    * });
    *
-   * // User-specific deduplication
-   * const userSpecificCall = callApi("/api/dashboard", {
-   *   dedupeKey: (context) => {
-   *     const userId = context.options.fullURL.match(/user\/(\d+)/)?.[1];
-   *     return `dashboard-${userId}`;
-   *   }
+   * // Basic auth
+   * const response = await callMainApi({
+   * 	url: "https://example.com/api/data",
+   * 	auth: {
+   * 		type: "Basic",
+   * 		username: "username",
+   * 		password: "password",
+   * 	},
    * });
    *
-   * // 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);
+  auth?: InferSchemaOutput<TSchema["auth"], AuthOption>;
+}>;
+type InferQueryOption<TSchema extends CallApiSchema> = MakeSchemaOptionRequiredIfDefined<TSchema["query"], {
   /**
-   * 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"
+   * Parameters to be appended to the URL (i.e: /:id)
    */
-  dedupeStrategy?: DedupeStrategyUnion | ((context: RequestContext) => DedupeStrategyUnion);
-}; //#endregion
-//#region src/middlewares.d.ts
-type FetchImpl = UnmaskType<(input: string | Request | URL, init?: RequestInit) => Promise<Response>>;
-type FetchMiddlewareContext<TCallApiContext extends CallApiContext> = RequestContext<TCallApiContext> & {
-  fetchImpl: FetchImpl;
+  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, {
+  /**
+   * Parameters to be appended to the URL (i.e: /:id)
+   */
+  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;
 };
-interface Middlewares<TCallApiContext extends NoInfer<CallApiContext> = DefaultCallApiContext> {
+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/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>;
+interface RetryOptions<TErrorData> {
   /**
-   * 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);
-   * }
-   * ```
+   * 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.
    */
-  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 Schema interface.
- * @see https://github.com/standard-schema/standard-schema
- */
-/** 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. */
-  type Types<Input = unknown, Output = Input> = 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>;
+  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";
 } //#endregion
-//#region src/validation.d.ts
-type ResultVariant = "infer-input" | "infer-output";
-type InferSchemaResult<TSchema, TFallbackResult, TResultVariant extends ResultVariant> = undefined extends TSchema ? TFallbackResult : TSchema extends StandardSchemaV1 ? TResultVariant extends "infer-input" ? StandardSchemaV1.InferInput<TSchema> : StandardSchemaV1.InferOutput<TSchema> : TSchema extends AnyFunction$1<infer TResult> ? Awaited<TResult> : TFallbackResult;
-type InferSchemaOutput<TSchema, TFallbackResult = unknown> = InferSchemaResult<TSchema, TFallbackResult, "infer-output">;
-type BooleanObject = { [Key in keyof CallApiSchema]: boolean };
-interface CallApiSchemaConfig {
+//#region src/refetch.d.ts
+interface RefetchOptions {
   /**
-   * The base url of the schema. By default it's the baseURL of the callApi instance.
+   * Tracks the number of times refetch has been called
+   * @internal
+   * @deprecated **NOTE**: This property is used internally to track refetch calls. Please abstain from modifying it.
    */
-  baseURL?: "" | AnyString;
+  readonly ["~refetchCount"]?: number;
   /**
-   * Disables runtime validation for the schema.
+   * Maximum number of times refetch can be called from error hooks.
+   *
+   * Prevents infinite loops when refetch is called repeatedly in error hooks.
+   * When the limit is reached, refetch will throw an error instead of retrying.
+   *
+   * @default 1
+   *
+   * @example
+   * ```ts
+   * // Allow up to 5 refetch attempts
+   * refetchAttempts: 5
+   *
+   * // Disable refetch limit
+   * refetchAttempts: Infinity
+   *
+   * // Strict limit of 1 refetch
+   * refetchAttempts: 1
+   * ```
    */
-  disableRuntimeValidation?: boolean | BooleanObject;
+  refetchAttempts?: number;
+}
+type RefetchFn = (overrides?: Pick<RefetchOptions, "refetchAttempts">) => Promise<CallApiResultLoose<unknown, unknown> | null>; //#endregion
+//#region src/stream.d.ts
+type StreamProgressEvent = {
   /**
-   * If `true`, the original input value will be used instead of the transformed/validated output.
+   * 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;
+}; //#endregion
+//#region src/hooks.d.ts
+type CallApiRequestOptionsForHooks = Omit<CallApiRequestOptions, "headers"> & {
+  headers: Record<"Authorization" | "Content-Type" | CommonRequestHeaders, string | undefined>;
+};
+type CallApiExtraOptionsForHooks<TCallApiContext extends CallApiContext = DefaultCallApiContext> = Hooks & Omit<CallApiExtraOptions<TCallApiContext>, keyof Hooks> & {
+  refetch: RefetchFn;
+};
+interface Hooks<TCallApiContext extends CallApiContext = DefaultCallApiContext> {
+  /**
+   * Hook called when any error occurs within the request/response lifecycle.
    *
-   * When true, the original input is returned unchanged after validation, ignoring any schema-level
-   * transformations such as type coercion, default values, or field mapping. Only the validation
-   * step is executed; the resulting value is discarded in favor of the raw input.
+   * 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
    */
-  disableRuntimeValidationTransform?: boolean | BooleanObject;
+  onError?: (context: ErrorContext<TCallApiContext>) => Awaitable<unknown>;
   /**
-   * Optional url prefix that will be substituted for the `baseURL` of the schemaConfig at runtime.
+   * 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
    *
-   * Enables a short, stable prefix for routes while keeping the full `baseURL` centralized in config.
-   * Keeps route definitions concise and shields them from changes to the underlying base URL.
    */
-  prefix?: "" | AnyString;
+  onRequest?: (context: RequestContext<TCallApiContext>) => Awaitable<unknown>;
   /**
-   * Controls the strictness of API route validation.
+   * Hook called when an error occurs during the fetch request itself.
    *
-   * 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
+   * 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`.
    *
-   * When false or undefined (default):
-   * - All routes will be allowed, whether they are defined in the schema or not
+   * @param context - Request error context with error details and null response
+   * @returns Promise or void - Hook can be async or sync
    */
-  strict?: boolean;
-}
-type CallApiSchemaType<TInput> = StandardSchemaV1<TInput | undefined> | ((value: TInput) => Awaitable<TInput | undefined>);
-interface CallApiSchema {
-  auth?: CallApiSchemaType<AuthOption>;
+  onRequestError?: (context: RequestErrorContext<TCallApiContext>) => Awaitable<unknown>;
   /**
-   *  The schema to use for validating the request body.
+   * 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
    */
-  body?: CallApiSchemaType<Body>;
+  onRequestReady?: (context: RequestContext<TCallApiContext>) => Awaitable<unknown>;
   /**
-   *  The schema to use for validating the response data.
+   * 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
+   *
    */
-  data?: CallApiSchemaType<unknown>;
+  onRequestStream?: (context: RequestStreamContext<TCallApiContext>) => Awaitable<unknown>;
   /**
-   *  The schema to use for validating the response error data.
+   * 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
+   *
    */
-  errorData?: CallApiSchemaType<unknown>;
+  onResponse?: (context: ResponseContext<TCallApiContext>) => Awaitable<unknown>;
   /**
-   *  The schema to use for validating the request headers.
+   * Hook called when an HTTP error response (4xx, 5xx) is received from the API.
+   *
+   * This handles server-side errors where an HTTP response was successfully received
+   * but indicates an error condition. Different from `onRequestError` which handles
+   * network-level failures.
+   *
+   * @param context - Response error context with HTTP error details and response
+   * @returns Promise or void - Hook can be async or sync
    */
-  headers?: CallApiSchemaType<HeadersOption>;
+  onResponseError?: (context: ResponseErrorContext<TCallApiContext>) => Awaitable<unknown>;
   /**
-   *  The schema to use for validating the meta option.
+   * 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
+   *
    */
-  meta?: CallApiSchemaType<GlobalMeta>;
+  onResponseStream?: (context: ResponseStreamContext<TCallApiContext>) => Awaitable<unknown>;
   /**
-   *  The schema to use for validating the request method.
+   * 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
+   *
    */
-  method?: CallApiSchemaType<MethodUnion>;
+  onRetry?: (context: RetryContext<TCallApiContext>) => Awaitable<unknown>;
   /**
-   *  The schema to use for validating the request url parameters.
+   * 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
+   *
    */
-  params?: CallApiSchemaType<Params>;
+  onSuccess?: (context: SuccessContext<TCallApiContext>) => Awaitable<unknown>;
   /**
-   *  The schema to use for validating the request url queries.
+   * 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
+   *
    */
-  query?: CallApiSchemaType<Query>;
+  onValidationError?: (context: ValidationErrorContext<TCallApiContext>) => Awaitable<unknown>;
 }
-declare const routeKeyMethods: readonly ["delete", "get", "patch", "post", "put"];
-type RouteKeyMethods = (typeof routeKeyMethods)[number];
-type RouteKeyMethodsURLUnion = `${AtSymbol}${RouteKeyMethods}/`;
-type BaseSchemaRouteKeyPrefixes = FallBackRouteSchemaKey | RouteKeyMethodsURLUnion;
-type BaseCallApiSchemaRoutes = Partial<Record<AnyString | BaseSchemaRouteKeyPrefixes, CallApiSchema>>;
-type BaseCallApiSchemaAndConfig = {
-  config?: CallApiSchemaConfig;
-  routes: BaseCallApiSchemaRoutes;
+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).
+   *
+   * - **"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 extends Pick<CallApiContext, "InferredExtraOptions" | "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>;
+  /**
+   * 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 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;
 }; //#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 Query = UnmaskType<Record<string, AllowedQueryParamValues> | 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.).
+   *
+   * **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
-   * ```typescript
-   * // Basic query parameters
-   * const queryOptions: URLOptions = {
-   *   initURL: "/users",
-   *   query: {
-   *     page: 1,
-   *     limit: 10,
-   *     search: "john doe",
-   *     active: true
+   * ```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}`;
    *   }
-   * };
-   * // 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"
+   * // User-specific deduplication
+   * const userSpecificCall = callApi("/api/dashboard", {
+   *   dedupeKey: (context) => {
+   *     const userId = context.options.fullURL.match(/user\/(\d+)/)?.[1];
+   *     return `dashboard-${userId}`;
    *   }
-   * };
-   * // 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 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 InferAllMainRouteKeys<TBaseSchemaRoutes extends BaseCallApiSchemaRoutes, TSchemaConfig extends CallApiSchemaConfig> = ApplySchemaConfiguration<TSchemaConfig, Exclude<Extract<keyof TBaseSchemaRoutes, string>, FallBackRouteSchemaKey>>;
-type InferInitURL<TBaseSchemaRoutes extends BaseCallApiSchemaRoutes, TSchemaConfig extends CallApiSchemaConfig> = keyof TBaseSchemaRoutes extends never ? InitURLOrURLObject : InferAllMainRouteKeys<TBaseSchemaRoutes, TSchemaConfig>;
-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> = MakeSchemaOptionRequiredIfDefined<TSchema["body"], {
-  /**
-   * Body of the request, can be a object or any other supported body type.
-   */
-  body?: InferSchemaOutput<TSchema["body"], Body>;
-}>;
-type MethodUnion = UnmaskType<"CONNECT" | "DELETE" | "GET" | "HEAD" | "OPTIONS" | "PATCH" | "POST" | "PUT" | "TRACE" | AnyString>;
-type InferMethodFromURL<TInitURL> = string extends TInitURL ? MethodUnion : TInitURL extends `${AtSymbol}${infer TMethod extends RouteKeyMethods}/${string}` ? Uppercase<TMethod> : MethodUnion;
-type InferMethodOption<TSchema extends CallApiSchema, TInitURL> = MakeSchemaOptionRequiredIfDefined<TSchema["method"], {
-  /**
-   * HTTP method for the request.
-   * @default "GET"
-   */
-  method?: InferSchemaOutput<TSchema["method"], InferMethodFromURL<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.
+   * });
+   *
+   * // 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
    */
-  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>> = InferBodyOption<TSchema> & InferHeadersOption<TSchema> & InferMethodOption<TSchema, TInitURL>;
-type InferMetaOption<TSchema extends CallApiSchema, TCallApiContext extends CallApiContext> = MakeSchemaOptionRequiredIfDefined<TSchema["meta"], {
+  dedupeKey?: string | ((context: RequestContext) => string | undefined);
   /**
-   * - An optional field you can fill with additional information,
-   * to associate with the request, typically used for logging or tracing.
+   * Strategy for handling duplicate requests. Can be a static string or callback function.
    *
-   * - A good use case for this, would be to use the info to handle specific cases in any of the shared interceptors.
+   * **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
-   * 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`);
-   * 		}
-   * 	},
+   * // Static strategies
+   * const searchClient = createFetchClient({
+   *   dedupeStrategy: "cancel" // Cancel previous searches
    * });
    *
-   * const response = await callMainApi({
-   * 	url: "https://example.com/api/data",
-   * 	meta: { userId: "123" },
+   * 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"
    */
-  meta?: InferSchemaOutput<TSchema["meta"], TCallApiContext["Meta"]>;
-}>;
-type InferAuthOption<TSchema extends CallApiSchema> = MakeSchemaOptionRequiredIfDefined<TSchema["auth"], {
+  dedupeStrategy?: DedupeStrategyUnion | ((context: RequestContext) => DedupeStrategyUnion);
+}; //#endregion
+//#region src/middlewares.d.ts
+type FetchImpl = UnmaskType<(input: string | Request | URL, init?: RequestInit) => Promise<Response>>;
+type FetchMiddlewareContext<TCallApiContext extends CallApiContext> = RequestContext<TCallApiContext> & {
+  fetchImpl: FetchImpl;
+};
+interface Middlewares<TCallApiContext extends NoInfer<CallApiContext> = DefaultCallApiContext> {
   /**
-   * Automatically add an Authorization header value.
+   * Wraps the fetch implementation to intercept requests at the network layer.
    *
-   * Supports multiple authentication patterns:
-   * - String: Direct authorization header value
-   * - Auth object: Structured authentication configuration
+   * 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
-   * // Bearer auth
-   * const response = await callMainApi({
-   * 	url: "https://example.com/api/data",
-   * 	auth: "123456",
-   * });
+   * // Cache responses
+   * const cache = new Map();
    *
-   * // Bearer auth
-   * const response = await callMainApi({
-   * 	url: "https://example.com/api/data",
-   * 	auth: {
-   * 		type: "Bearer",
-   * 		value: "123456",
-   * 	},
-   })
+   * fetchMiddleware: (ctx) => async (input, init) => {
+   *   const key = input.toString();
    *
-   * // Token auth
-   * const response = await callMainApi({
-   * 	url: "https://example.com/api/data",
-   * 	auth: {
-   * 		type: "Token",
-   * 		value: "123456",
-   * 	},
-   * });
+   *   const cachedResponse = cache.get(key);
    *
-   * // Basic auth
-   * const response = await callMainApi({
-   * 	url: "https://example.com/api/data",
-   * 	auth: {
-   * 		type: "Basic",
-   * 		username: "username",
-   * 		password: "password",
-   * 	},
-   * });
+   *   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);
+   * }
    * ```
    */
-  auth?: InferSchemaOutput<TSchema["auth"], AuthOption>;
-}>;
-type InferQueryOption<TSchema extends CallApiSchema> = MakeSchemaOptionRequiredIfDefined<TSchema["query"], {
-  /**
-   * Parameters to be appended to the URL (i.e: /:id)
-   */
-  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, {
-  /**
-   * Parameters to be appended to the URL (i.e: /:id)
-   */
-  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>;
-}; //#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>;
-interface RetryOptions<TErrorData> {
-  /**
-   * 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;
-  /**
-   * 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";
+  fetchMiddleware?: (context: FetchMiddlewareContext<TCallApiContext>) => FetchImpl;
 } //#endregion
 //#region src/utils/external/error.d.ts
 type HTTPErrorDetails<TErrorData> = Pick<CallApiExtraOptions, "defaultHTTPErrorMessage"> & {
@@ -1129,15 +1168,12 @@ type CallApiRequestOptions = {
    */
   method?: MethodUnion;
 } & Pick<ModifiedRequestInit, FetchSpecificKeysUnion>;
-type CallApiRequestOptionsForHooks = Omit<CallApiRequestOptions, "headers"> & {
-  headers: Record<"Authorization" | "Content-Type" | CommonRequestHeaders, string | undefined>;
-};
 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, 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>> & ResultModeOption<TErrorData, TResultMode> & RetryOptions<TErrorData> & TComputedMergedPluginExtraOptions & ThrowOnErrorOption<TErrorData, TThrowOnError> & URLOptions & {
+}>> = DedupeOptions & HookConfigOptions & HooksOrHooksArray<NoInferUnMasked<TComputedCallApiContext>> & Middlewares<NoInferUnMasked<TComputedCallApiContext>> & RefetchOptions & ResultModeOption<TErrorData, TResultMode> & RetryOptions<TErrorData> & TComputedMergedPluginExtraOptions & ThrowOnErrorOption<TErrorData, TThrowOnError> & URLOptions & {
   /**
    * Automatically add an Authorization header value.
    *
@@ -1612,7 +1648,6 @@ type CallApiExtraOptions<TCallApiContext extends CallApiContext = DefaultCallApi
    */
   schemaConfig?: TSchemaConfig | ((context: GetExtendSchemaConfigContext<TBaseSchemaConfig>) => TSchemaConfig);
 };
-type CallApiExtraOptionsForHooks<TCallApiContext extends CallApiContext = DefaultCallApiContext> = Hooks & Omit<CallApiExtraOptions<TCallApiContext>, keyof Hooks>;
 type InstanceContext = {
   initURL: string;
   options: CallApiExtraOptions;
@@ -1620,7 +1655,7 @@ type InstanceContext = {
 };
 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, TBasePluginArray extends CallApiPlugin[] = DefaultPluginArray, TPluginArray extends CallApiPlugin[] = DefaultPluginArray> = InferExtraOptions<TSchema, TBaseSchemaRoutes, TCurrentRouteSchemaKey, TCallApiContext> & InferRequestOptions<TSchema, TInitURL> & Omit<CallApiExtraOptions<TCallApiContext, TData, TErrorData, TResultMode, TThrowOnError, TResponseType, TBasePluginArray, TPluginArray, TBaseSchemaRoutes, TSchema, TBaseSchemaConfig, TSchemaConfig, TCurrentRouteSchemaKey>, keyof InferExtraOptions<CallApiSchema, BaseCallApiSchemaRoutes, string, CallApiContext>> & Omit<CallApiRequestOptions, keyof InferRequestOptions<CallApiSchema, string>>;
-//#endregion
+type CallApiResultLoose<TData, TErrorData, TResultMode extends ResultModeType = ResultModeType, TThrowOnError extends ThrowOnErrorBoolean = ThrowOnErrorBoolean> = InferCallApiResult<TData, TErrorData, TResultMode, TThrowOnError>; //#endregion
 //#region src/result.d.ts
 type ResponseParser<TData> = (text: string) => Awaitable<TData>;
 declare const getResponseType: <TData>(response: Response, responseParser: ResponseParser<TData>) => {
@@ -1684,7 +1719,7 @@ type ResultModeMap<TData = DefaultDataType, TErrorData = DefaultDataType, TThrow
 type ResultModePlaceholder = null;
 type ResultModeUnion = keyof ResultModeMap;
 type ResultModeType = ResultModePlaceholder | ResultModeUnion;
-//#endregion
+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; //#endregion
 //#region src/plugins.d.ts
 type PluginSetupContext<TCallApiContext extends CallApiContext = DefaultCallApiContext> = RequestContext<TCallApiContext> & {
   initURL: string;
@@ -1749,7 +1784,6 @@ type DefaultMetaObject = Record<string, unknown>;
 type DefaultCallApiContext = Prettify<OverrideCallApiContext<Required<CallApiContext>, {
   Meta: GlobalMeta;
 }>>; //#endregion
-//#region src/createFetchClient.d.ts
 //#endregion
 //#region src/plugins/logger/logger.d.ts
 type ConsoleLikeObject = {
@@ -1790,53 +1824,63 @@ declare const loggerPlugin: (options?: LoggerOptions) => {
   version: "1.1.0";
   hooks: {
     onRequest: (ctx: RequestContext<Omit<{
-      Data: unknown;
-      ErrorData: unknown;
+      Data: DefaultDataType;
+      ErrorData: DefaultDataType;
       InferredExtraOptions: unknown;
       ResultMode: ResultModeType;
-      Meta: {
-        [x: string]: unknown;
-      };
+      Meta: GlobalMeta;
     }, "Data" | "ErrorData"> & {
       Data: never;
       ErrorData: never;
     }>) => void;
-    onRequestError: (ctx: Omit<{
+    onRequestError: (ctx: (Omit<{
       data: null;
       error: PossibleJavaScriptError;
       response: Response | null;
     }, "data"> & RequestContext<Omit<{
-      Data: unknown;
-      ErrorData: unknown;
+      Data: DefaultDataType;
+      ErrorData: DefaultDataType;
       InferredExtraOptions: unknown;
       ResultMode: ResultModeType;
-      Meta: {
-        [x: string]: unknown;
+      Meta: GlobalMeta;
+    }, "Data" | "ErrorData"> & {
+      Data: never;
+      ErrorData: never;
+    }>) | (Omit<{
+      data: null;
+      error: {
+        errorData: never;
+        message: string;
+        name: "HTTPError";
+        originalError: _zayne_labs_callapi_utils0.HTTPError;
       };
+      response: Response;
+    }, "data"> & RequestContext<Omit<{
+      Data: DefaultDataType;
+      ErrorData: DefaultDataType;
+      InferredExtraOptions: unknown;
+      ResultMode: ResultModeType;
+      Meta: GlobalMeta;
     }, "Data" | "ErrorData"> & {
       Data: never;
       ErrorData: never;
-    }>) => void;
+    }>)) => void;
     onResponseError: (ctx: ResponseErrorContext<Omit<{
-      Data: unknown;
-      ErrorData: unknown;
+      Data: DefaultDataType;
+      ErrorData: DefaultDataType;
       InferredExtraOptions: unknown;
       ResultMode: ResultModeType;
-      Meta: {
-        [x: string]: unknown;
-      };
+      Meta: GlobalMeta;
     }, "Data" | "ErrorData"> & {
       Data: never;
       ErrorData: never;
     }>) => void;
     onRetry: (ctx: ErrorContext<Omit<{
-      Data: unknown;
-      ErrorData: unknown;
+      Data: DefaultDataType;
+      ErrorData: DefaultDataType;
       InferredExtraOptions: unknown;
       ResultMode: ResultModeType;
-      Meta: {
-        [x: string]: unknown;
-      };
+      Meta: GlobalMeta;
     }, "Data" | "ErrorData"> & {
       Data: never;
       ErrorData: never;
@@ -1844,13 +1888,11 @@ declare const loggerPlugin: (options?: LoggerOptions) => {
       retryAttemptCount: number;
     }) => void;
     onSuccess: (ctx: SuccessContext<Omit<{
-      Data: unknown;
-      ErrorData: unknown;
+      Data: DefaultDataType;
+      ErrorData: DefaultDataType;
       InferredExtraOptions: unknown;
       ResultMode: ResultModeType;
-      Meta: {
-        [x: string]: unknown;
-      };
+      Meta: GlobalMeta;
     }, "Data" | "ErrorData"> & {
       Data: never;
       ErrorData: never;
@@ -1860,13 +1902,11 @@ declare const loggerPlugin: (options?: LoggerOptions) => {
       error: PossibleValidationError;
       response: Response | null;
     }, "data"> & RequestContext<Omit<{
-      Data: unknown;
-      ErrorData: unknown;
+      Data: DefaultDataType;
+      ErrorData: DefaultDataType;
       InferredExtraOptions: unknown;
       ResultMode: ResultModeType;
-      Meta: {
-        [x: string]: unknown;
-      };
+      Meta: GlobalMeta;
     }, "Data" | "ErrorData"> & {
       Data: never;
       ErrorData: never;
@@ -1875,4 +1915,4 @@ declare const loggerPlugin: (options?: LoggerOptions) => {
 };
 //#endregion
 export { defaultConsoleObject as n, loggerPlugin as r, LoggerOptions as t };
-//# sourceMappingURL=index-BBzD4BfV.d.ts.map
+//# sourceMappingURL=index-BfWbLAGF.d.ts.map