@zayne-labs/callapi 1.11.35 → 1.11.36

package/dist/{index-BEp4V3_c.d.ts → index-CGn8h_Ai.d.ts}

@@ -92,457 +92,435 @@ type StreamProgressEvent = {
   transferredBytes: number;
 };
 //#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<infer TResult> ? Awaited<TResult> : TFallbackResult;
-type InferSchemaOutput<TSchema, TFallbackResult = unknown> = InferSchemaResult<TSchema, TFallbackResult, "infer-output">;
-type InferSchemaInput<TSchema, TFallbackResult = unknown> = InferSchemaResult<TSchema, TFallbackResult, "infer-input">;
-type BooleanObject = { [Key in keyof CallApiSchema]: boolean };
-interface CallApiSchemaConfig {
-  /**
-   * The base url of the schema. By default it's the baseURL of the callApi instance.
-   */
-  baseURL?: "" | AnyString;
-  /**
-   * Disables runtime validation for the schema.
-   */
-  disableRuntimeValidation?: boolean | BooleanObject;
+//#region src/hooks.d.ts
+interface Hooks<TCallApiContext extends CallApiContext = DefaultCallApiContext> {
   /**
-   * If `true`, the original input value will be used instead of the transformed/validated output.
+   * 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.
-   */
-  disableRuntimeValidationTransform?: boolean | BooleanObject;
-  /**
-   * Optional url prefix that will be substituted for the `baseURL` of the schemaConfig at runtime.
+   * 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.
    *
-   * 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.
+   * @param context - Error context containing error details, request info, and response (if available)
+   * @returns Promise or void - Hook can be async or sync
    */
-  prefix?: "" | AnyString;
+  onError?: (context: ErrorContext<TCallApiContext>) => Awaitable<unknown>;
   /**
-   * Controls the strictness of API route validation.
+   * Hook called before the HTTP request is sent and before any internal processing of the request object begins.
    *
-   * 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 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
    *
-   * When false or undefined (default):
-   * - All routes will be allowed, whether they are defined in the schema or not
-   */
-  strict?: boolean;
-}
-interface CallApiSchema {
-  auth?: StandardSchemaV1<AuthOption | undefined> | ((auth: AuthOption) => Awaitable<AuthOption | undefined>);
-  /**
-   *  The schema to use for validating the request body.
-   */
-  body?: StandardSchemaV1<Body | undefined> | ((body: Body) => Awaitable<Body | undefined>);
-  /**
-   *  The schema to use for validating the response data.
-   */
-  data?: StandardSchemaV1 | ((data: unknown) => unknown);
-  /**
-   *  The schema to use for validating the response error data.
-   */
-  errorData?: StandardSchemaV1 | ((errorData: unknown) => unknown);
-  /**
-   *  The schema to use for validating the request headers.
-   */
-  headers?: StandardSchemaV1<HeadersOption | undefined> | ((headers: HeadersOption) => Awaitable<HeadersOption | undefined>);
-  /**
-   *  The schema to use for validating the meta option.
-   */
-  meta?: StandardSchemaV1<GlobalMeta | undefined> | ((meta: GlobalMeta) => Awaitable<GlobalMeta | undefined>);
-  /**
-   *  The schema to use for validating the request method.
    */
-  method?: StandardSchemaV1<MethodUnion | undefined> | ((method: MethodUnion) => Awaitable<MethodUnion | undefined>);
+  onRequest?: (context: RequestContext<TCallApiContext>) => Awaitable<unknown>;
   /**
-   *  The schema to use for validating the request url parameters.
+   * 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
    */
-  params?: StandardSchemaV1<Params | undefined> | ((params: Params) => Awaitable<Params | undefined>);
+  onRequestError?: (context: RequestErrorContext<TCallApiContext>) => Awaitable<unknown>;
   /**
-   *  The schema to use for validating the request url queries.
+   * 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
    */
-  query?: StandardSchemaV1<Query | undefined> | ((query: Query) => Awaitable<Query | undefined>);
-}
-declare const routeKeyMethods: readonly ["delete", "get", "patch", "post", "put"];
-type RouteKeyMethods = (typeof routeKeyMethods)[number];
-type RouteKeyMethodsURLUnion = `@${RouteKeyMethods}/`;
-type BaseSchemaRouteKeyPrefixes = FallBackRouteSchemaKey | RouteKeyMethodsURLUnion;
-type BaseCallApiSchemaRoutes = Partial<Record<AnyString | BaseSchemaRouteKeyPrefixes, CallApiSchema>>;
-type BaseCallApiSchemaAndConfig = {
-  config?: CallApiSchemaConfig;
-  routes: BaseCallApiSchemaRoutes;
-};
-//#endregion
-//#region src/url.d.ts
-type AllowedQueryParamValues = UnmaskType<boolean | number | string>;
-type RecordStyleParams = UnmaskType<Record<string, AllowedQueryParamValues>>;
-type TupleStyleParams = UnmaskType<AllowedQueryParamValues[]>;
-type Params = UnmaskType<RecordStyleParams | TupleStyleParams>;
-type Query = UnmaskType<Record<string, AllowedQueryParamValues>>;
-type InitURLOrURLObject = AnyString | RouteKeyMethodsURLUnion | URL;
-interface URLOptions {
+  onRequestReady?: (context: RequestContext<TCallApiContext>) => Awaitable<unknown>;
   /**
-   * Base URL for all API requests. Will only be prepended to relative URLs.
-   *
-   * Absolute URLs (starting with http/https) will not be prepended by the baseURL.
+   * Hook called during upload stream progress tracking.
    *
-   * @example
-   * ```ts
-   * // Set base URL for all requests
-   * baseURL: "https://api.example.com/v1"
+   * 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.
    *
-   * // Then use relative URLs in requests
-   * callApi("/users") // → https://api.example.com/v1/users
-   * callApi("/posts/123") // → https://api.example.com/v1/posts/123
+   * @param context - Request stream context with progress event and request instance
+   * @returns Promise or void - Hook can be async or sync
    *
-   * // Environment-specific base URLs
-   * baseURL: process.env.NODE_ENV === "production"
-   *   ? "https://api.example.com"
-   *   : "http://localhost:3000/api"
-   * ```
    */
-  baseURL?: string;
+  onRequestStream?: (context: RequestStreamContext<TCallApiContext>) => Awaitable<unknown>;
   /**
-   * Resolved request URL after processing baseURL, parameters, and query strings (readonly)
+   * Hook called when any HTTP response is received from the API.
    *
-   * This is the final URL that will be used for the HTTP request, computed from
-   * baseURL, initURL, params, and query parameters.
+   * 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
    *
    */
-  readonly fullURL?: string;
+  onResponse?: (context: ResponseContext<TCallApiContext>) => Awaitable<unknown>;
   /**
-   * The original URL string passed to the callApi instance (readonly)
+   * Hook called when an HTTP error response (4xx, 5xx) is received from the API.
    *
-   * This preserves the original URL as provided, including any method modifiers like "@get/" or "@post/".
+   * 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
    */
-  readonly initURL?: string;
+  onResponseError?: (context: ResponseErrorContext<TCallApiContext>) => Awaitable<unknown>;
   /**
-   * The URL string after normalization, with method modifiers removed(readonly)
+   * Hook called during download stream progress tracking.
    *
-   * Method modifiers like "@get/", "@post/" are stripped to create a clean URL
-   * for parameter substitution and final URL construction.
+   * 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
    *
    */
-  readonly initURLNormalized?: string;
+  onResponseStream?: (context: ResponseStreamContext<TCallApiContext>) => Awaitable<unknown>;
   /**
-   * Parameters to be substituted into URL path segments.
-   *
-   * Supports both object-style (named parameters) and array-style (positional parameters)
-   * for flexible URL parameter substitution.
+   * Hook called when a request is being retried.
    *
-   * @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
+   * 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.
    *
-   * // 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
+   * @param context - Retry context with error details and retry attempt count
+   * @returns Promise or void - Hook can be async or sync
    *
-   * // Single parameter
-   * const singleParam: URLOptions = {
-   *   initURL: "/users/:id",
-   *   params: { id: "user-123" }
-   * };
-   * // Results in: /users/user-123
-   * ```
    */
-  params?: Params;
+  onRetry?: (response: RetryContext<TCallApiContext>) => Awaitable<unknown>;
   /**
-   * Query parameters to append to the URL as search parameters.
+   * Hook called when a successful response (2xx status) is received from the API.
    *
-   * These will be serialized into the URL query string using standard
-   * URL encoding practices.
+   * 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.
    *
-   * @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
+   * @param context - Success context with parsed response data and response object
+   * @returns Promise or void - Hook can be async or sync
    *
-   * // Filtering and sorting
-   * const filterOptions: URLOptions = {
-   *   initURL: "/products",
-   *   query: {
-   *     category: "electronics",
-   *     minPrice: 100,
-   *     maxPrice: 500,
-   *     sortBy: "price",
-   *     order: "asc"
-   *   }
-   * };
-   * // Results in: /products?category=electronics&minPrice=100&maxPrice=500&sortBy=price&order=asc
-   * ```
    */
-  query?: Query;
+  onSuccess?: (context: SuccessContext<TCallApiContext>) => Awaitable<unknown>;
+  /**
+   * Hook called when a validation error occurs.
+   *
+   * This hook is triggered when request or response data fails validation against
+   * a defined schema. It provides access to the validation error details and can
+   * be used for custom error handling, logging, or fallback behavior.
+   *
+   * @param context - Validation error context with error details and response (if available)
+   * @returns Promise or void - Hook can be async or sync
+   *
+   */
+  onValidationError?: (context: ValidationErrorContext<TCallApiContext>) => Awaitable<unknown>;
 }
-//#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 MergePrefixWithRouteKey<TPrefix extends string, TRouteKey extends string> = TRouteKey extends `@${infer TMethod extends RouteKeyMethods}/${infer TRestOfRoutKey}` ? `@${TMethod}/${TPrefix extends `/${infer TPrefixWithoutSlash}` ? TPrefixWithoutSlash : TPrefix}${TRestOfRoutKey}` : `${TPrefix}${TRouteKey}`;
-type ApplyURLBasedConfig<TSchemaConfig extends CallApiSchemaConfig, TSchemaRouteKeys extends string> = TSchemaConfig["prefix"] extends string ? MergePrefixWithRouteKey<TSchemaConfig["prefix"], TSchemaRouteKeys> : TSchemaConfig["baseURL"] extends string ? MergePrefixWithRouteKey<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 InferAllRouteKeys<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 : InferAllRouteKeys<TBaseSchemaRoutes, TSchemaConfig>;
-type GetCurrentRouteSchemaKey<TSchemaConfig extends CallApiSchemaConfig, TPath> = TPath extends URL ? string : TSchemaConfig["baseURL"] extends string ? TPath extends `${TSchemaConfig["baseURL"]}${infer TCurrentRoute}` ? TCurrentRoute extends string ? TCurrentRoute : string : TPath extends `${TSchemaConfig["prefix"]}${infer TCurrentRoute}` ? TCurrentRoute extends string ? TCurrentRoute : string : string : TPath;
-type GetCurrentRouteSchema<TBaseSchemaRoutes extends BaseCallApiSchemaRoutes, TCurrentRouteSchemaKey extends string, TComputedFallBackRouteSchema = TBaseSchemaRoutes[FallBackRouteSchemaKey], TComputedCurrentRouteSchema = TBaseSchemaRoutes[TCurrentRouteSchemaKey], TComputedRouteSchema extends CallApiSchema = NonNullable<Omit<TComputedFallBackRouteSchema, keyof TComputedCurrentRouteSchema> & TComputedCurrentRouteSchema>> = TComputedRouteSchema extends CallApiSchema ? Writeable<TComputedRouteSchema, "deep"> : CallApiSchema;
-type JsonPrimitive = boolean | number | string | null | undefined;
-type SerializableObject = Record<PropertyKey, unknown>;
-type SerializableArray = Array<JsonPrimitive | SerializableObject> | ReadonlyArray<JsonPrimitive | SerializableObject>;
-type Body = UnmaskType<Exclude<RequestInit["body"], undefined> | SerializableArray | SerializableObject>;
-type InferBodyOption<TSchema extends CallApiSchema> = MakeSchemaOptionRequiredIfDefined<TSchema["body"], {
+type HooksOrHooksArray<TCallApiContext extends NoInfer<CallApiContext> = DefaultCallApiContext> = { [Key in keyof Hooks<TCallApiContext>]: Hooks<TCallApiContext>[Key] | Array<Hooks<TCallApiContext>[Key]> };
+interface HookConfigOptions {
   /**
-   * Body of the request, can be a object or any other supported body type.
+   * 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"
    */
-  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 `@${infer TMethod extends RouteKeyMethods}/${string}` ? Uppercase<TMethod> : MethodUnion;
-type InferMethodOption<TSchema extends CallApiSchema, TInitURL> = MakeSchemaOptionRequiredIfDefined<TSchema["method"], {
+  hooksExecutionMode?: "parallel" | "sequential";
+}
+type RequestContext<TCallApiContext extends Pick<CallApiContext, "InferredExtraOptions" | "Meta"> = DefaultCallApiContext> = {
   /**
-   * HTTP method for the request.
-   * @default "GET"
+   * 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.
    */
-  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"], {
+  baseConfig: Exclude<BaseCallApiConfig, AnyFunction>;
   /**
-   * Headers to be used in the request.
+   * 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.
    */
-  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"], {
+  config: CallApiConfig;
   /**
-   * - An optional field you can fill with additional information,
-   * to associate with the request, typically used for logging or tracing.
+   * Merged options combining base config, instance config, and default options.
    *
-   * - A good use case for this, would be to use the info to handle specific cases in any of the shared interceptors.
+   * 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 ValidationErrorContext<TCallApiContext extends Pick<CallApiContext, "InferredExtraOptions" | "Meta"> = DefaultCallApiContext> = RequestContext<TCallApiContext> & {
+  error: PossibleValidationError;
+  response: Response | null;
+};
+type SuccessContext<TCallApiContext extends Pick<CallApiContext, "Data" | "InferredExtraOptions" | "Meta"> = DefaultCallApiContext> = RequestContext<TCallApiContext> & {
+  data: TCallApiContext["Data"];
+  response: Response;
+};
+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> = RequestContext<TCallApiContext> & {
+  error: PossibleJavaScriptError;
+  response: null;
+};
+type ErrorContext<TCallApiContext extends Pick<CallApiContext, "ErrorData" | "InferredExtraOptions" | "Meta"> = DefaultCallApiContext> = RequestContext<TCallApiContext> & ({
+  error: PossibleHTTPError<TCallApiContext["ErrorData"]>;
+  response: Response;
+} | {
+  error: PossibleJavaScriptOrValidationError;
+  response: Response | null;
+});
+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 DedupeOptionKeys = Exclude<keyof DedupeOptions, "dedupe">;
+type InnerDedupeOptions = { [Key in DedupeOptionKeys as RemovePrefix<"dedupe", Key>]?: DedupeOptions[Key] };
+type DedupeOptions = {
+  /**
+   * All dedupe options in a single object instead of separate properties
+   */
+  dedupe?: InnerDedupeOptions;
+  /**
+   * Controls the scope of request deduplication caching.
+   *
+   * - `"global"`: Shares deduplication cache across all `createFetchClient` instances with the same `dedupeCacheScopeKey`.
+   *   Useful for applications with multiple API clients that should share deduplication state.
+   * - `"local"`: Limits deduplication to requests within the same `createFetchClient` instance.
+   *   Provides better isolation and is recommended for most use cases.
+   *
+   *
+   * **Real-world Scenarios:**
+   * - Use `"global"` when you have multiple API clients (user service, auth service, etc.) that might make overlapping requests
+   * - Use `"local"` (default) for single-purpose clients or when you want strict isolation between different parts of your app
    *
    * @example
    * ```ts
-   * 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`);
-   * 		}
-   * 	},
-   * });
+   * // 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
    *
-   * const response = await callMainApi({
-   * 	url: "https://example.com/api/data",
-   * 	meta: { userId: "123" },
+   * // Global scope - share cache across related clients
+   * const userClient = createFetchClient({
+   *   baseURL: "/api/users",
+   *   dedupeCacheScope: "global",
+   * });
+   * const postClient = createFetchClient({
+   *   baseURL: "/api/posts",
+   *   dedupeCacheScope: "global",
    * });
+   * // These clients will share deduplication state
    * ```
+   *
+   * @default "local"
    */
-  meta?: InferSchemaOutput<TSchema["meta"], TCallApiContext["Meta"]>;
-}>;
-type InferAuthOption<TSchema extends CallApiSchema> = MakeSchemaOptionRequiredIfDefined<TSchema["auth"], {
+  dedupeCacheScope?: "global" | "local";
   /**
-   * Automatically add an Authorization header value.
+   * Unique namespace for the global deduplication cache when using `dedupeCacheScope: "global"`.
    *
-   * Supports multiple authentication patterns:
-   * - String: Direct authorization header value
-   * - Auth object: Structured authentication configuration
+   * This creates logical groupings of deduplication caches. All instances with the same key
+   * will share the same cache namespace, allowing fine-grained control over which clients
+   * share deduplication state.
    *
-   * @example
-   * ```ts
-   * // Bearer auth
-   * const response = await callMainApi({
-   * 	url: "https://example.com/api/data",
-   * 	auth: "123456",
-   * });
+   * **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
    *
-   * // Bearer auth
-   * const response = await callMainApi({
-   * 	url: "https://example.com/api/data",
-   * 	auth: {
-   * 		type: "Bearer",
-   * 		value: "123456",
-   * 	},
-   })
+   * **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
    *
-   * // Token auth
-   * const response = await callMainApi({
-   * 	url: "https://example.com/api/data",
-   * 	auth: {
-   * 		type: "Token",
-   * 		value: "123456",
-   * 	},
+   * @example
+   * ```ts
+   * // Group related API clients together
+   * const userClient = createFetchClient({
+   *   baseURL: "/api/users",
+   *   dedupeCacheScope: "global",
+   *   dedupeCacheScopeKey: "user-service"
+   * });
+   * const profileClient = createFetchClient({
+   *   baseURL: "/api/profiles",
+   *   dedupeCacheScope: "global",
+   *   dedupeCacheScopeKey: "user-service" // Same scope - will share cache
    * });
    *
-   * // Basic auth
-   * const response = await callMainApi({
-   * 	url: "https://example.com/api/data",
-   * 	auth: {
-   * 		type: "Basic",
-   * 		username: "username",
-   * 		password: "password",
-   * 	},
+   * // 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"
    */
-  auth?: InferSchemaOutput<TSchema["auth"], AuthOption>;
-}>;
-type InferQueryOption<TSchema extends CallApiSchema> = MakeSchemaOptionRequiredIfDefined<TSchema["query"], {
+  dedupeCacheScopeKey?: "default" | AnyString | ((context: RequestContext) => string | undefined);
   /**
-   * Parameters to be appended to the URL (i.e: /:id)
+   * Custom key generator for request deduplication.
+   *
+   * Override the default key generation strategy to control exactly which requests
+   * are considered duplicates. The default key combines URL, method, body, and
+   * relevant headers (excluding volatile ones like 'Date', 'Authorization', etc.).
+   *
+   * **Default Key Generation:**
+   * The auto-generated key includes:
+   * - Full request URL (including query parameters)
+   * - HTTP method (GET, POST, etc.)
+   * - Request body (for POST/PUT/PATCH requests)
+   * - Stable headers (excludes Date, Authorization, User-Agent, etc.)
+   *
+   * **Custom Key Best Practices:**
+   * - Include only the parts of the request that should affect deduplication
+   * - Avoid including volatile data (timestamps, random IDs, etc.)
+   * - Consider performance - simpler keys are faster to compute and compare
+   * - Ensure keys are deterministic for the same logical request
+   * - Use consistent key formats across your application
+   *
+   * **Performance Considerations:**
+   * - Function-based keys are computed on every request - keep them lightweight
+   * - String keys are fastest but least flexible
+   * - Consider caching expensive key computations if needed
+   *
+   * @example
+   * ```ts
+   * import { callApi } from "@zayne-labs/callapi";
+   *
+   * // Simple static key - useful for singleton requests
+   * const config = callApi("/api/config", {
+   *   dedupeKey: "app-config",
+   *   dedupeStrategy: "defer" // Share the same config across all requests
+   * });
+   *
+   * // URL and method only - ignore headers and body
+   * const userData = callApi("/api/user/123", {
+   *   dedupeKey: (context) => `${context.options.method}:${context.options.fullURL}`
+   * });
+   *
+   * // Include specific headers in deduplication
+   * const apiCall = callApi("/api/data", {
+   *   dedupeKey: (context) => {
+   *     const authHeader = context.request.headers.get("Authorization");
+   *     return `${context.options.fullURL}-${authHeader}`;
+   *   }
+   * });
+   *
+   * // User-specific deduplication
+   * const userSpecificCall = callApi("/api/dashboard", {
+   *   dedupeKey: (context) => {
+   *     const userId = context.options.fullURL.match(/user\/(\d+)/)?.[1];
+   *     return `dashboard-${userId}`;
+   *   }
+   * });
+   *
+   * // Ignore certain query parameters
+   * const searchCall = callApi("/api/search?q=test&timestamp=123456", {
+   *   dedupeKey: (context) => {
+   *     const url = new URL(context.options.fullURL);
+   *     url.searchParams.delete("timestamp"); // Remove volatile param
+   *     return `search:${url.toString()}`;
+   *   }
+   * });
+   * ```
+   *
+   * @default Auto-generated from request details
    */
-  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, {
+  dedupeKey?: string | ((context: RequestContext) => string | undefined);
   /**
-   * Parameters to be appended to the URL (i.e: /:id)
+   * 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"
    */
-  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 InferPluginExtraOptions<TPluginArray extends CallApiPlugin[]> = UnionToIntersection<TPluginArray extends Array<infer TPlugin> ? TPlugin extends CallApiPlugin ? TPlugin["defineExtraOptions"] extends AnyFunction<infer TReturnedSchema> ? InferSchemaOutput<TReturnedSchema> : never : never : never>;
-type ResultModeOption<TErrorData, TResultMode extends ResultModeType> = TErrorData extends false ? {
-  resultMode: "onlyData";
-} : TErrorData extends false | undefined ? {
-  resultMode?: "onlyData";
-} : {
-  resultMode?: TResultMode;
-};
-type ThrowOnErrorUnion = boolean;
-type ThrowOnErrorType<TErrorData, TThrowOnError extends ThrowOnErrorUnion> = TThrowOnError | ((context: ErrorContext<{
-  ErrorData: TErrorData;
-}>) => TThrowOnError);
-type ThrowOnErrorOption<TErrorData, TThrowOnError extends ThrowOnErrorUnion> = TErrorData extends false ? {
-  throwOnError: true;
-} : TErrorData extends false | undefined ? {
-  throwOnError?: true;
-} : {
-  throwOnError?: ThrowOnErrorType<TErrorData, TThrowOnError>;
+  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> {
   /**
    * Wraps the fetch implementation to intercept requests at the network layer.
@@ -560,509 +538,478 @@ interface Middlewares<TCallApiContext extends NoInfer<CallApiContext> = DefaultC
    *
    * fetchMiddleware: (ctx) => async (input, init) => {
    *   const key = input.toString();
-   *   if (cache.has(key)) return cache.get(key).clone();
+   *
+   *   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 (input, init) => {
+   * fetchMiddleware: (ctx) => async (...parameters) => {
    *   if (!navigator.onLine) {
    *     return new Response('{"error": "offline"}', { status: 503 });
    *   }
-   *   return ctx.fetchImpl(input, init);
+   *
+   *   return ctx.fetchImpl(...parameters);
    * }
    * ```
    */
-  fetchMiddleware?: (context: RequestContext<TCallApiContext> & {
-    fetchImpl: FetchImpl;
-  }) => FetchImpl;
+  fetchMiddleware?: (context: FetchMiddlewareContext<TCallApiContext>) => FetchImpl;
 }
 //#endregion
-//#region src/plugins.d.ts
-type PluginSetupContext<TCallApiContext extends CallApiContext = DefaultCallApiContext> = RequestContext<TCallApiContext> & {
-  initURL: string;
-};
-type PluginInitResult<TCallApiContext extends CallApiContext = DefaultCallApiContext> = Partial<Omit<PluginSetupContext<TCallApiContext>, "initURL" | "request"> & {
-  initURL: InitURLOrURLObject;
-  request: CallApiRequestOptions;
-}>;
-type PluginHooks<TCallApiContext extends CallApiContext = DefaultCallApiContext> = HooksOrHooksArray<OverrideCallApiContext<TCallApiContext, {
-  Data: DefaultDataType extends TCallApiContext["Data"] ? never : TCallApiContext["Data"];
-  ErrorData: DefaultDataType extends TCallApiContext["ErrorData"] ? never : TCallApiContext["ErrorData"];
-}>>;
-interface CallApiPlugin<TCallApiContext extends CallApiContext = DefaultCallApiContext> {
-  /**
-   * Defines additional options that can be passed to callApi
-   */
-  defineExtraOptions?: (...params: never[]) => unknown;
-  /**
-   * A description for the plugin
-   */
-  description?: string;
-  /**
-   * Hooks for the plugin
-   */
-  hooks?: PluginHooks<TCallApiContext> | ((context: PluginSetupContext<TCallApiContext>) => Awaitable<PluginHooks<TCallApiContext>>);
-  /**
-   *  A unique id for the plugin
-   */
-  id: string;
-  /**
-   * Middlewares that for the plugin
-   */
-  middlewares?: Middlewares<TCallApiContext> | ((context: PluginSetupContext<TCallApiContext>) => Awaitable<Middlewares<TCallApiContext>>);
-  /**
-   * A name for the plugin
-   */
-  name: string;
+//#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<infer TResult> ? Awaited<TResult> : TFallbackResult;
+type InferSchemaOutput<TSchema, TFallbackResult = unknown> = InferSchemaResult<TSchema, TFallbackResult, "infer-output">;
+type InferSchemaInput<TSchema, TFallbackResult = unknown> = InferSchemaResult<TSchema, TFallbackResult, "infer-input">;
+type BooleanObject = { [Key in keyof CallApiSchema]: boolean };
+interface CallApiSchemaConfig {
   /**
-   * Base schema for the client.
+   * The base url of the schema. By default it's the baseURL of the callApi instance.
    */
-  schema?: BaseCallApiSchemaAndConfig;
+  baseURL?: "" | AnyString;
   /**
-   * A function that will be called when the plugin is initialized. This will be called before the any of the other internal functions.
+   * Disables runtime validation for the schema.
    */
-  setup?: (context: PluginSetupContext<TCallApiContext>) => Awaitable<PluginInitResult<TCallApiContext>> | Awaitable<void>;
+  disableRuntimeValidation?: boolean | BooleanObject;
   /**
-   *  A version for the plugin
+   * 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.
    */
-  version?: string;
-}
-//#endregion
-//#region src/types/default-types.d.ts
-type DefaultDataType = unknown;
-type DefaultPluginArray = CallApiPlugin[];
-type DefaultThrowOnError = boolean;
-type DefaultMetaObject = Record<string, unknown>;
-type DefaultCallApiContext = Omit<Required<CallApiContext>, "Meta"> & {
-  Meta: GlobalMeta;
-};
-//#endregion
-//#region src/hooks.d.ts
-interface Hooks<TCallApiContext extends CallApiContext = DefaultCallApiContext> {
+  disableRuntimeValidationTransform?: boolean | BooleanObject;
   /**
-   * Hook called when any error occurs within the request/response lifecycle.
-   *
-   * This is a unified error handler that catches both request errors (network failures,
-   * timeouts, etc.) and response errors (HTTP error status codes). It's essentially
-   * a combination of `onRequestError` and `onResponseError` hooks.
+   * Optional url prefix that will be substituted for the `baseURL` of the schemaConfig at runtime.
    *
-   * @param context - Error context containing error details, request info, and response (if available)
-   * @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.
    */
-  onError?: (context: ErrorContext<TCallApiContext>) => Awaitable<unknown>;
+  prefix?: "" | AnyString;
   /**
-   * 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.
+   * Controls the strictness of API route validation.
    *
-   * @param context - Request context with mutable request object and configuration
-   * @returns Promise or void - Hook can be async or sync
+   * When true:
+   * - Only routes explicitly defined in the schema will be considered valid to typescript and the runtime.
+   * - Attempting to call routes not defined in the schema will result in both type errors and runtime validation errors.
+   * - Useful for ensuring API calls conform exactly to your schema definition
    *
+   * When false or undefined (default):
+   * - All routes will be allowed, whether they are defined in the schema or not
    */
-  onRequest?: (context: RequestContext<TCallApiContext>) => Awaitable<unknown>;
+  strict?: boolean;
+}
+interface CallApiSchema {
+  auth?: StandardSchemaV1<AuthOption | undefined> | ((auth: AuthOption) => Awaitable<AuthOption | undefined>);
   /**
-   * 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 request body.
    */
-  onRequestError?: (context: RequestErrorContext<TCallApiContext>) => Awaitable<unknown>;
+  body?: StandardSchemaV1<Body | undefined> | ((body: Body) => Awaitable<Body | undefined>);
   /**
-   * 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 data.
    */
-  onRequestReady?: (context: RequestContext<TCallApiContext>) => Awaitable<unknown>;
+  data?: StandardSchemaV1 | ((data: unknown) => unknown);
   /**
-   * Hook called during upload stream progress tracking.
+   *  The schema to use for validating the response error data.
+   */
+  errorData?: StandardSchemaV1 | ((errorData: unknown) => unknown);
+  /**
+   *  The schema to use for validating the request headers.
+   */
+  headers?: StandardSchemaV1<HeadersOption | undefined> | ((headers: HeadersOption) => Awaitable<HeadersOption | undefined>);
+  /**
+   *  The schema to use for validating the meta option.
+   */
+  meta?: StandardSchemaV1<GlobalMeta | undefined> | ((meta: GlobalMeta) => Awaitable<GlobalMeta | undefined>);
+  /**
+   *  The schema to use for validating the request method.
+   */
+  method?: StandardSchemaV1<MethodUnion | undefined> | ((method: MethodUnion) => Awaitable<MethodUnion | undefined>);
+  /**
+   *  The schema to use for validating the request url parameters.
+   */
+  params?: StandardSchemaV1<Params | undefined> | ((params: Params) => Awaitable<Params | undefined>);
+  /**
+   *  The schema to use for validating the request url queries.
+   */
+  query?: StandardSchemaV1<Query | undefined> | ((query: Query) => Awaitable<Query | undefined>);
+}
+declare const routeKeyMethods: readonly ["delete", "get", "patch", "post", "put"];
+type RouteKeyMethods = (typeof routeKeyMethods)[number];
+type RouteKeyMethodsURLUnion = `@${RouteKeyMethods}/`;
+type BaseSchemaRouteKeyPrefixes = FallBackRouteSchemaKey | RouteKeyMethodsURLUnion;
+type BaseCallApiSchemaRoutes = Partial<Record<AnyString | BaseSchemaRouteKeyPrefixes, CallApiSchema>>;
+type BaseCallApiSchemaAndConfig = {
+  config?: CallApiSchemaConfig;
+  routes: BaseCallApiSchemaRoutes;
+};
+//#endregion
+//#region src/url.d.ts
+type AllowedQueryParamValues = UnmaskType<boolean | number | string>;
+type RecordStyleParams = UnmaskType<Record<string, AllowedQueryParamValues>>;
+type TupleStyleParams = UnmaskType<AllowedQueryParamValues[]>;
+type Params = UnmaskType<RecordStyleParams | TupleStyleParams>;
+type Query = UnmaskType<Record<string, AllowedQueryParamValues>>;
+type InitURLOrURLObject = AnyString | RouteKeyMethodsURLUnion | URL;
+interface URLOptions {
+  /**
+   * Base URL for all API requests. Will only be prepended to relative URLs.
    *
-   * 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).
+   * Query parameters to append to the URL as search parameters.
    *
-   * - **"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
+   * These will be serialized into the URL query string using standard
+   * URL encoding practices.
    *
-   * This affects how ALL hooks execute together, regardless of their source (main or plugin).
+   * @example
+   * ```typescript
+   * // Basic query parameters
+   * const queryOptions: URLOptions = {
+   *   initURL: "/users",
+   *   query: {
+   *     page: 1,
+   *     limit: 10,
+   *     search: "john doe",
+   *     active: true
+   *   }
+   * };
+   * // Results in: /users?page=1&limit=10&search=john%20doe&active=true
    *
-   * @default "parallel"
+   * // 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
+   * ```
    */
-  hooksExecutionMode?: "parallel" | "sequential";
+  query?: Query;
 }
-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>;
-  /**
-   * 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 ValidationErrorContext<TCallApiContext extends Pick<CallApiContext, "InferredExtraOptions" | "Meta"> = DefaultCallApiContext> = RequestContext<TCallApiContext> & {
-  error: PossibleValidationError;
-  response: Response | null;
-};
-type SuccessContext<TCallApiContext extends Pick<CallApiContext, "Data" | "InferredExtraOptions" | "Meta"> = DefaultCallApiContext> = RequestContext<TCallApiContext> & {
-  data: TCallApiContext["Data"];
-  response: Response;
-};
-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> = RequestContext<TCallApiContext> & {
-  error: PossibleJavaScriptError;
-  response: null;
-};
-type ErrorContext<TCallApiContext extends Pick<CallApiContext, "ErrorData" | "InferredExtraOptions" | "Meta"> = DefaultCallApiContext> = RequestContext<TCallApiContext> & ({
-  error: PossibleHTTPError<TCallApiContext["ErrorData"]>;
-  response: Response;
-} | {
-  error: PossibleJavaScriptOrValidationError;
-  response: Response | null;
-});
-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 DedupeOptionKeys = Exclude<keyof DedupeOptions, "dedupe">;
-type InnerDedupeOptions = { [Key in DedupeOptionKeys as RemovePrefix<"dedupe", Key>]?: DedupeOptions[Key] };
-type DedupeOptions = {
+//#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 MergePrefixWithRouteKey<TPrefix extends string, TRouteKey extends string> = TRouteKey extends `@${infer TMethod extends RouteKeyMethods}/${infer TRestOfRoutKey}` ? `@${TMethod}/${TPrefix extends `/${infer TPrefixWithoutSlash}` ? TPrefixWithoutSlash : TPrefix}${TRestOfRoutKey}` : `${TPrefix}${TRouteKey}`;
+type ApplyURLBasedConfig<TSchemaConfig extends CallApiSchemaConfig, TSchemaRouteKeys extends string> = TSchemaConfig["prefix"] extends string ? MergePrefixWithRouteKey<TSchemaConfig["prefix"], TSchemaRouteKeys> : TSchemaConfig["baseURL"] extends string ? MergePrefixWithRouteKey<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 InferAllRouteKeys<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 : InferAllRouteKeys<TBaseSchemaRoutes, TSchemaConfig>;
+type GetCurrentRouteSchemaKey<TSchemaConfig extends CallApiSchemaConfig, TPath> = TPath extends URL ? string : TSchemaConfig["baseURL"] extends string ? TPath extends `${TSchemaConfig["baseURL"]}${infer TCurrentRoute}` ? TCurrentRoute extends string ? TCurrentRoute : string : TPath extends `${TSchemaConfig["prefix"]}${infer TCurrentRoute}` ? TCurrentRoute extends string ? TCurrentRoute : string : string : TPath;
+type GetCurrentRouteSchema<TBaseSchemaRoutes extends BaseCallApiSchemaRoutes, TCurrentRouteSchemaKey extends string, TComputedFallBackRouteSchema = TBaseSchemaRoutes[FallBackRouteSchemaKey], TComputedCurrentRouteSchema = TBaseSchemaRoutes[TCurrentRouteSchemaKey], TComputedRouteSchema extends CallApiSchema = NonNullable<Omit<TComputedFallBackRouteSchema, keyof TComputedCurrentRouteSchema> & TComputedCurrentRouteSchema>> = TComputedRouteSchema extends CallApiSchema ? Writeable<TComputedRouteSchema, "deep"> : CallApiSchema;
+type JsonPrimitive = boolean | number | string | null | undefined;
+type SerializableObject = Record<PropertyKey, unknown>;
+type SerializableArray = Array<JsonPrimitive | SerializableObject> | ReadonlyArray<JsonPrimitive | SerializableObject>;
+type Body = UnmaskType<Exclude<RequestInit["body"], undefined> | SerializableArray | SerializableObject>;
+type InferBodyOption<TSchema extends CallApiSchema> = MakeSchemaOptionRequiredIfDefined<TSchema["body"], {
   /**
-   * All dedupe options in a single object instead of separate properties
+   * Body of the request, can be a object or any other supported body type.
    */
-  dedupe?: InnerDedupeOptions;
+  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 `@${infer TMethod extends RouteKeyMethods}/${string}` ? Uppercase<TMethod> : MethodUnion;
+type InferMethodOption<TSchema extends CallApiSchema, TInitURL> = MakeSchemaOptionRequiredIfDefined<TSchema["method"], {
   /**
-   * Controls the scope of request deduplication caching.
-   *
-   * - `"global"`: Shares deduplication cache across all `createFetchClient` instances with the same `dedupeCacheScopeKey`.
-   *   Useful for applications with multiple API clients that should share deduplication state.
-   * - `"local"`: Limits deduplication to requests within the same `createFetchClient` instance.
-   *   Provides better isolation and is recommended for most use cases.
-   *
-   *
-   * **Real-world Scenarios:**
-   * - Use `"global"` when you have multiple API clients (user service, auth service, etc.) that might make overlapping requests
-   * - Use `"local"` (default) for single-purpose clients or when you want strict isolation between different parts of your app
-   *
-   * @example
-   * ```ts
-   * // Local scope - each client has its own deduplication cache
-   * const userClient = createFetchClient({ baseURL: "/api/users" });
-   * const postClient = createFetchClient({ baseURL: "/api/posts" });
-   * // These clients won't share deduplication state
-   *
-   * // Global scope - share cache across related clients
-   * const userClient = createFetchClient({
-   *   baseURL: "/api/users",
-   *   dedupeCacheScope: "global",
-   * });
-   * const postClient = createFetchClient({
-   *   baseURL: "/api/posts",
-   *   dedupeCacheScope: "global",
-   * });
-   * // These clients will share deduplication state
-   * ```
-   *
-   * @default "local"
+   * HTTP method for the request.
+   * @default "GET"
    */
-  dedupeCacheScope?: "global" | "local";
-  /**
-   * Unique namespace for the global deduplication cache when using `dedupeCacheScope: "global"`.
-   *
-   * This creates logical groupings of deduplication caches. All instances with the same key
-   * will share the same cache namespace, allowing fine-grained control over which clients
-   * share deduplication state.
-   *
-   * **Best Practices:**
-   * - Use descriptive names that reflect the logical grouping (e.g., "user-service", "analytics-api")
-   * - Keep scope keys consistent across related API clients
-   * - Consider using different scope keys for different environments (dev, staging, prod)
-   * - Avoid overly broad scope keys that might cause unintended cache sharing
-   *
-   * **Cache Management:**
-   * - Each scope key maintains its own independent cache
-   * - Caches are automatically cleaned up when no references remain
-   * - Consider the memory implications of multiple global scopes
-   *
-   * @example
-   * ```ts
-   * // Group related API clients together
-   * const userClient = createFetchClient({
-   *   baseURL: "/api/users",
-   *   dedupeCacheScope: "global",
-   *   dedupeCacheScopeKey: "user-service"
-   * });
-   * const profileClient = createFetchClient({
-   *   baseURL: "/api/profiles",
-   *   dedupeCacheScope: "global",
-   *   dedupeCacheScopeKey: "user-service" // Same scope - will share cache
-   * });
-   *
-   * // Separate analytics client with its own cache
-   * const analyticsClient = createFetchClient({
-   *   baseURL: "/api/analytics",
-   *   dedupeCacheScope: "global",
-   *   dedupeCacheScopeKey: "analytics-service" // Different scope
-   * });
-   *
-   * // Environment-specific scoping
-   * const apiClient = createFetchClient({
-   *   dedupeCacheScope: "global",
-   *   dedupeCacheScopeKey: `api-${process.env.NODE_ENV}` // "api-development", "api-production", etc.
-   * });
-   * ```
-   *
-   * @default "default"
+  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.
    */
-  dedupeCacheScopeKey?: "default" | AnyString | ((context: RequestContext) => string | undefined);
+  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"], {
   /**
-   * 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
+   * - An optional field you can fill with additional information,
+   * to associate with the request, typically used for logging or tracing.
    *
-   * **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
+   * - A good use case for this, would be to use the info to handle specific cases in any of the shared interceptors.
    *
    * @example
    * ```ts
-   * import { callApi } from "@zayne-labs/callapi";
-   *
-   * // Simple static key - useful for singleton requests
-   * const config = callApi("/api/config", {
-   *   dedupeKey: "app-config",
-   *   dedupeStrategy: "defer" // Share the same config across all requests
-   * });
-   *
-   * // URL and method only - ignore headers and body
-   * const userData = callApi("/api/user/123", {
-   *   dedupeKey: (context) => `${context.options.method}:${context.options.fullURL}`
-   * });
-   *
-   * // Include specific headers in deduplication
-   * const apiCall = callApi("/api/data", {
-   *   dedupeKey: (context) => {
-   *     const authHeader = context.request.headers.get("Authorization");
-   *     return `${context.options.fullURL}-${authHeader}`;
-   *   }
-   * });
-   *
-   * // User-specific deduplication
-   * const userSpecificCall = callApi("/api/dashboard", {
-   *   dedupeKey: (context) => {
-   *     const userId = context.options.fullURL.match(/user\/(\d+)/)?.[1];
-   *     return `dashboard-${userId}`;
-   *   }
+   * 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`);
+   * 		}
+   * 	},
    * });
    *
-   * // 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()}`;
-   *   }
+   * const response = await callMainApi({
+   * 	url: "https://example.com/api/data",
+   * 	meta: { userId: "123" },
    * });
    * ```
-   *
-   * @default Auto-generated from request details
    */
-  dedupeKey?: string | ((context: RequestContext) => string | undefined);
+  meta?: InferSchemaOutput<TSchema["meta"], TCallApiContext["Meta"]>;
+}>;
+type InferAuthOption<TSchema extends CallApiSchema> = MakeSchemaOptionRequiredIfDefined<TSchema["auth"], {
   /**
-   * Strategy for handling duplicate requests. Can be a static string or callback function.
+   * Automatically add an Authorization header value.
    *
-   * **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
+   * Supports multiple authentication patterns:
+   * - String: Direct authorization header value
+   * - Auth object: Structured authentication configuration
    *
    * @example
    * ```ts
-   * // Static strategies
-   * const searchClient = createFetchClient({
-   *   dedupeStrategy: "cancel" // Cancel previous searches
+   * // Bearer auth
+   * const response = await callMainApi({
+   * 	url: "https://example.com/api/data",
+   * 	auth: "123456",
    * });
    *
-   * const configClient = createFetchClient({
-   *   dedupeStrategy: "defer" // Share config across components
-   * });
+   * // Bearer auth
+   * const response = await callMainApi({
+   * 	url: "https://example.com/api/data",
+   * 	auth: {
+   * 		type: "Bearer",
+   * 		value: "123456",
+   * 	},
+   })
    *
-   * // Dynamic strategy based on request
-   * const smartClient = createFetchClient({
-   *   dedupeStrategy: (context) => {
-   *     return context.options.method === "GET" ? "defer" : "cancel";
-   *   }
+   * // Token auth
+   * const response = await callMainApi({
+   * 	url: "https://example.com/api/data",
+   * 	auth: {
+   * 		type: "Token",
+   * 		value: "123456",
+   * 	},
    * });
    *
-   * // 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);
-   *   }
-   * };
+   * // Basic auth
+   * const response = await callMainApi({
+   * 	url: "https://example.com/api/data",
+   * 	auth: {
+   * 		type: "Basic",
+   * 		username: "username",
+   * 		password: "password",
+   * 	},
+   * });
    *
    * ```
-   *
-   * @default "cancel"
    */
-  dedupeStrategy?: DedupeStrategyUnion | ((context: RequestContext) => DedupeStrategyUnion);
+  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 ThrowOnErrorUnion = boolean;
+type ThrowOnErrorType<TErrorData, TThrowOnError extends ThrowOnErrorUnion> = TThrowOnError | ((context: ErrorContext<{
+  ErrorData: TErrorData;
+}>) => TThrowOnError);
+type ThrowOnErrorOption<TErrorData, TThrowOnError extends ThrowOnErrorUnion> = TErrorData extends false ? {
+  throwOnError: true;
+} : TErrorData extends false | undefined ? {
+  throwOnError?: true;
+} : {
+  throwOnError?: ThrowOnErrorType<TErrorData, TThrowOnError>;
 };
 //#endregion
 //#region src/retry.d.ts
@@ -1213,7 +1160,7 @@ type CallApiRequestOptions = Prettify<{
 type CallApiRequestOptionsForHooks = Omit<CallApiRequestOptions, "headers"> & {
   headers: Record<string, string | undefined>;
 };
-type SharedExtraOptions<TCallApiContext extends CallApiContext = DefaultCallApiContext, TData = DefaultDataType, TErrorData = DefaultDataType, TResultMode extends ResultModeType = ResultModeType, TThrowOnError extends ThrowOnErrorUnion = DefaultThrowOnError, TResponseType extends ResponseTypeType = ResponseTypeType, TPluginArray extends CallApiPlugin[] = DefaultPluginArray, TComputedMergedPluginExtraOptions = Partial<InferPluginExtraOptions<TPluginArray> & TCallApiContext["InferredExtraOptions"]>, TComputedCallApiContext extends CallApiContext = OverrideCallApiContext<TCallApiContext, {
+type SharedExtraOptions<TCallApiContext extends CallApiContext = DefaultCallApiContext, TData = DefaultDataType, TErrorData = DefaultDataType, TResultMode extends ResultModeType = ResultModeType, TThrowOnError extends ThrowOnErrorUnion = 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;
@@ -1806,9 +1753,81 @@ type ResultModeUnion = keyof ResultModeMap;
 type ResultModeType = ResultModePlaceholder | ResultModeUnion;
 type InferCallApiResult<TData, TErrorData, TResultMode extends ResultModeType, TThrowOnError extends ThrowOnErrorUnion, 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;
+};
+type PluginInitResult<TCallApiContext extends CallApiContext = DefaultCallApiContext> = Partial<Omit<PluginSetupContext<TCallApiContext>, "initURL" | "request"> & {
+  initURL: InitURLOrURLObject;
+  request: CallApiRequestOptions;
+}>;
+type GetDefaultDataTypeForPlugins<TData> = DefaultDataType extends TData ? never : TData;
+type PluginHooks<TCallApiContext extends CallApiContext = DefaultCallApiContext> = HooksOrHooksArray<OverrideCallApiContext<TCallApiContext, {
+  Data: GetDefaultDataTypeForPlugins<TCallApiContext["Data"]>;
+  ErrorData: GetDefaultDataTypeForPlugins<TCallApiContext["ErrorData"]>;
+}>>;
+type PluginMiddlewares<TCallApiContext extends CallApiContext = DefaultCallApiContext> = Middlewares<OverrideCallApiContext<TCallApiContext, {
+  Data: GetDefaultDataTypeForPlugins<TCallApiContext["Data"]>;
+  ErrorData: GetDefaultDataTypeForPlugins<TCallApiContext["ErrorData"]>;
+}>>;
+interface CallApiPlugin<TCallApiContext extends CallApiContext = DefaultCallApiContext> {
+  /**
+   * Defines additional options that can be passed to callApi
+   */
+  defineExtraOptions?: () => TCallApiContext["InferredExtraOptions"];
+  /**
+   * A description for the plugin
+   */
+  description?: string;
+  /**
+   * Hooks for the plugin
+   */
+  hooks?: PluginHooks<TCallApiContext> | ((context: PluginSetupContext<TCallApiContext>) => Awaitable<PluginHooks<TCallApiContext>>);
+  /**
+   *  A unique id for the plugin
+   */
+  id: string;
+  /**
+   * Middlewares that for the plugin
+   */
+  middlewares?: PluginMiddlewares<TCallApiContext> | ((context: PluginSetupContext<TCallApiContext>) => Awaitable<PluginMiddlewares<TCallApiContext>>);
+  /**
+   * A name for the plugin
+   */
+  name: string;
+  /**
+   * Base schema for the client.
+   */
+  schema?: BaseCallApiSchemaAndConfig;
+  /**
+   * A function that will be called when the plugin is initialized. This will be called before the any of the other internal functions.
+   */
+  setup?: (context: PluginSetupContext<TCallApiContext>) => Awaitable<PluginInitResult<TCallApiContext>> | Awaitable<void>;
+  /**
+   *  A version for the plugin
+   */
+  version?: string;
+}
+type InferPluginExtraOptions<TPluginArray extends CallApiPlugin[]> = UnionToIntersection<TPluginArray extends Array<infer TPlugin> ? TPlugin extends CallApiPlugin ? TPlugin["defineExtraOptions"] extends AnyFunction<infer TResult> ? InferSchemaOutput<TResult, TResult> : never : never : never>;
+//#endregion
+//#region src/types/default-types.d.ts
+type DefaultDataType = unknown;
+type DefaultPluginArray = CallApiPlugin[];
+type DefaultThrowOnError = boolean;
+type DefaultMetaObject = Record<string, unknown>;
+type DefaultCallApiContext = Prettify<Required<Omit<CallApiContext, "Meta">> & {
+  Meta: GlobalMeta;
+}>;
+//#endregion
 //#region src/createFetchClient.d.ts
 declare const createFetchClientWithContext: <TOuterCallApiContext extends CallApiContext = DefaultCallApiContext>() => <TBaseCallApiContext extends CallApiContext = TOuterCallApiContext, TBaseData = TBaseCallApiContext["Data"], TBaseErrorData = TBaseCallApiContext["ErrorData"], TBaseResultMode extends ResultModeType = (TBaseCallApiContext["ResultMode"] extends ResultModeType ? TBaseCallApiContext["ResultMode"] : ResultModeType), TBaseThrowOnError extends ThrowOnErrorUnion = boolean, TBaseResponseType extends ResponseTypeType = ResponseTypeType, const TBaseSchemaAndConfig extends BaseCallApiSchemaAndConfig = BaseCallApiSchemaAndConfig, const TBasePluginArray extends CallApiPlugin[] = DefaultPluginArray, TComputedBaseSchemaConfig extends CallApiSchemaConfig = GetBaseSchemaConfig<TBaseSchemaAndConfig>, TComputedBaseSchemaRoutes extends BaseCallApiSchemaRoutes = GetBaseSchemaRoutes<TBaseSchemaAndConfig>>(initBaseConfig?: BaseCallApiConfig<TBaseCallApiContext, TBaseData, TBaseErrorData, TBaseResultMode, TBaseThrowOnError, TBaseResponseType, TBaseSchemaAndConfig, TBasePluginArray>) => <TData = TBaseData, TErrorData = TBaseErrorData, TResultMode extends ResultModeType = TBaseResultMode, TCallApiContext extends CallApiContext = TBaseCallApiContext, TThrowOnError extends ThrowOnErrorUnion = TBaseThrowOnError, TResponseType extends ResponseTypeType = TBaseResponseType, const TSchemaConfig extends CallApiSchemaConfig = TComputedBaseSchemaConfig, TInitURL extends InferInitURL<TComputedBaseSchemaRoutes, TSchemaConfig> = InferInitURL<TComputedBaseSchemaRoutes, TSchemaConfig>, TCurrentRouteSchemaKey extends GetCurrentRouteSchemaKey<TSchemaConfig, TInitURL> = GetCurrentRouteSchemaKey<TSchemaConfig, TInitURL>, const TSchema extends CallApiSchema = GetCurrentRouteSchema<TComputedBaseSchemaRoutes, TCurrentRouteSchemaKey>, const TPluginArray extends CallApiPlugin[] = TBasePluginArray, TComputedData = InferSchemaOutput<TSchema["data"], GetResponseType<TData, TResponseType>>, TComputedErrorData = InferSchemaOutput<TSchema["errorData"], GetResponseType<TErrorData, TResponseType>>, TComputedResult = CallApiResult<TComputedData, TComputedErrorData, TResultMode, TThrowOnError>>(initURL: TInitURL, initConfig?: CallApiConfig<TCallApiContext, TComputedData, TComputedErrorData, TResultMode, TThrowOnError, TResponseType, TComputedBaseSchemaRoutes, TSchema, TComputedBaseSchemaConfig, TSchemaConfig, TInitURL, TCurrentRouteSchemaKey, TBasePluginArray, TPluginArray>) => Promise<TComputedResult>;
-declare const createFetchClient: <TBaseCallApiContext extends CallApiContext = DefaultCallApiContext, TBaseData = TBaseCallApiContext["Data"], TBaseErrorData = TBaseCallApiContext["ErrorData"], TBaseResultMode extends ResultModeType = (TBaseCallApiContext["ResultMode"] extends ResultModeType ? TBaseCallApiContext["ResultMode"] : ResultModeType), TBaseThrowOnError extends ThrowOnErrorUnion = boolean, TBaseResponseType extends ResponseTypeType = ResponseTypeType, const TBaseSchemaAndConfig extends BaseCallApiSchemaAndConfig = BaseCallApiSchemaAndConfig, const TBasePluginArray extends CallApiPlugin[] = DefaultPluginArray, TComputedBaseSchemaConfig extends CallApiSchemaConfig = Writeable<NonNullable<TBaseSchemaAndConfig["config"]>, "deep">, TComputedBaseSchemaRoutes extends BaseCallApiSchemaRoutes = Writeable<TBaseSchemaAndConfig["routes"], "deep">>(initBaseConfig?: BaseCallApiConfig<TBaseCallApiContext, TBaseData, TBaseErrorData, TBaseResultMode, TBaseThrowOnError, TBaseResponseType, TBaseSchemaAndConfig, TBasePluginArray>) => <TData = TBaseData, TErrorData = TBaseErrorData, TResultMode extends ResultModeType = TBaseResultMode, TCallApiContext extends CallApiContext = TBaseCallApiContext, TThrowOnError extends ThrowOnErrorUnion = TBaseThrowOnError, TResponseType extends ResponseTypeType = TBaseResponseType, const TSchemaConfig extends CallApiSchemaConfig = TComputedBaseSchemaConfig, TInitURL extends InferInitURL<TComputedBaseSchemaRoutes, TSchemaConfig> = InferInitURL<TComputedBaseSchemaRoutes, TSchemaConfig>, TCurrentRouteSchemaKey extends GetCurrentRouteSchemaKey<TSchemaConfig, TInitURL> = GetCurrentRouteSchemaKey<TSchemaConfig, TInitURL>, const TSchema extends CallApiSchema = GetCurrentRouteSchema<TComputedBaseSchemaRoutes, TCurrentRouteSchemaKey, TComputedBaseSchemaRoutes["@default"], TComputedBaseSchemaRoutes[TCurrentRouteSchemaKey], NonNullable<Omit<TComputedBaseSchemaRoutes["@default"], keyof TComputedBaseSchemaRoutes[TCurrentRouteSchemaKey]> & TComputedBaseSchemaRoutes[TCurrentRouteSchemaKey]>>, const TPluginArray extends CallApiPlugin[] = TBasePluginArray, TComputedData = InferSchemaResult<TSchema["data"], GetResponseType<TData, TResponseType, ResponseTypeMap<TData>>, "infer-output">, TComputedErrorData = InferSchemaResult<TSchema["errorData"], GetResponseType<TErrorData, TResponseType, ResponseTypeMap<TErrorData>>, "infer-output">, TComputedResult = InferCallApiResult<TComputedData, TComputedErrorData, TResultMode, TThrowOnError, {
+declare const createFetchClient: <TBaseCallApiContext extends CallApiContext = {
+  Data: DefaultDataType;
+  ErrorData: DefaultDataType;
+  InferredExtraOptions: unknown;
+  ResultMode: ResultModeType;
+  Meta: GlobalMeta;
+}, TBaseData = TBaseCallApiContext["Data"], TBaseErrorData = TBaseCallApiContext["ErrorData"], TBaseResultMode extends ResultModeType = (TBaseCallApiContext["ResultMode"] extends ResultModeType ? TBaseCallApiContext["ResultMode"] : ResultModeType), TBaseThrowOnError extends ThrowOnErrorUnion = boolean, TBaseResponseType extends ResponseTypeType = ResponseTypeType, const TBaseSchemaAndConfig extends BaseCallApiSchemaAndConfig = BaseCallApiSchemaAndConfig, const TBasePluginArray extends CallApiPlugin[] = DefaultPluginArray, TComputedBaseSchemaConfig extends CallApiSchemaConfig = Writeable<NonNullable<TBaseSchemaAndConfig["config"]>, "deep">, TComputedBaseSchemaRoutes extends BaseCallApiSchemaRoutes = Writeable<TBaseSchemaAndConfig["routes"], "deep">>(initBaseConfig?: BaseCallApiConfig<TBaseCallApiContext, TBaseData, TBaseErrorData, TBaseResultMode, TBaseThrowOnError, TBaseResponseType, TBaseSchemaAndConfig, TBasePluginArray>) => <TData = TBaseData, TErrorData = TBaseErrorData, TResultMode extends ResultModeType = TBaseResultMode, TCallApiContext extends CallApiContext = TBaseCallApiContext, TThrowOnError extends ThrowOnErrorUnion = TBaseThrowOnError, TResponseType extends ResponseTypeType = TBaseResponseType, const TSchemaConfig extends CallApiSchemaConfig = TComputedBaseSchemaConfig, TInitURL extends InferInitURL<TComputedBaseSchemaRoutes, TSchemaConfig> = InferInitURL<TComputedBaseSchemaRoutes, TSchemaConfig>, TCurrentRouteSchemaKey extends GetCurrentRouteSchemaKey<TSchemaConfig, TInitURL> = GetCurrentRouteSchemaKey<TSchemaConfig, TInitURL>, const TSchema extends CallApiSchema = GetCurrentRouteSchema<TComputedBaseSchemaRoutes, TCurrentRouteSchemaKey, TComputedBaseSchemaRoutes["@default"], TComputedBaseSchemaRoutes[TCurrentRouteSchemaKey], NonNullable<Omit<TComputedBaseSchemaRoutes["@default"], keyof TComputedBaseSchemaRoutes[TCurrentRouteSchemaKey]> & TComputedBaseSchemaRoutes[TCurrentRouteSchemaKey]>>, const TPluginArray extends CallApiPlugin[] = TBasePluginArray, TComputedData = InferSchemaResult<TSchema["data"], GetResponseType<TData, TResponseType, ResponseTypeMap<TData>>, "infer-output">, TComputedErrorData = InferSchemaResult<TSchema["errorData"], GetResponseType<TErrorData, TResponseType, ResponseTypeMap<TErrorData>>, "infer-output">, TComputedResult = InferCallApiResult<TComputedData, TComputedErrorData, TResultMode, TThrowOnError, {
   all: CallApiResultSuccessVariant<TComputedData>;
   onlyData: NoInferUnMasked<TComputedData>;
   onlyResponse: Response;
@@ -1822,7 +1841,13 @@ declare const createFetchClient: <TBaseCallApiContext extends CallApiContext = D
   onlyResponse: (TThrowOnError extends true ? CallApiResultSuccessVariant<TComputedData> : CallApiResultSuccessOrErrorVariant<TComputedData, TComputedErrorData>)["response"];
   withoutResponse: DistributiveOmit<TThrowOnError extends true ? CallApiResultSuccessVariant<TComputedData> : CallApiResultSuccessOrErrorVariant<TComputedData, TComputedErrorData>, "response"> extends infer T ? { [Key in keyof T]: T[Key] } : never;
 }>>(initURL: TInitURL, initConfig?: CallApiConfig<TCallApiContext, TComputedData, TComputedErrorData, TResultMode, TThrowOnError, TResponseType, TComputedBaseSchemaRoutes, TSchema, TComputedBaseSchemaConfig, TSchemaConfig, TInitURL, TCurrentRouteSchemaKey, TBasePluginArray, TPluginArray>) => Promise<TComputedResult>;
-declare const callApi: <TData = unknown, TErrorData = unknown, TResultMode extends ResultModeType = ResultModeType, TCallApiContext extends CallApiContext = DefaultCallApiContext, TThrowOnError extends ThrowOnErrorUnion = boolean, TResponseType extends ResponseTypeType = ResponseTypeType, const TSchemaConfig extends CallApiSchemaConfig = CallApiSchemaConfig, TInitURL extends ApplyStrictConfig<TSchemaConfig, ApplyURLBasedConfig<TSchemaConfig, AnyString | "@delete/" | "@get/" | "@patch/" | "@post/" | "@put/">> = ApplyStrictConfig<TSchemaConfig, ApplyURLBasedConfig<TSchemaConfig, AnyString | "@delete/" | "@get/" | "@patch/" | "@post/" | "@put/">>, TCurrentRouteSchemaKey extends GetCurrentRouteSchemaKey<TSchemaConfig, TInitURL> = GetCurrentRouteSchemaKey<TSchemaConfig, TInitURL>, const TSchema extends CallApiSchema = GetCurrentRouteSchema<{
+declare const callApi: <TData = unknown, TErrorData = unknown, TResultMode extends ResultModeType = ResultModeType, TCallApiContext extends CallApiContext = {
+  Data: DefaultDataType;
+  ErrorData: DefaultDataType;
+  InferredExtraOptions: unknown;
+  ResultMode: ResultModeType;
+  Meta: GlobalMeta;
+}, TThrowOnError extends ThrowOnErrorUnion = boolean, TResponseType extends ResponseTypeType = ResponseTypeType, const TSchemaConfig extends CallApiSchemaConfig = CallApiSchemaConfig, TInitURL extends ApplyStrictConfig<TSchemaConfig, ApplyURLBasedConfig<TSchemaConfig, AnyString | "@delete/" | "@get/" | "@patch/" | "@post/" | "@put/">> = ApplyStrictConfig<TSchemaConfig, ApplyURLBasedConfig<TSchemaConfig, AnyString | "@delete/" | "@get/" | "@patch/" | "@post/" | "@put/">>, TCurrentRouteSchemaKey extends GetCurrentRouteSchemaKey<TSchemaConfig, TInitURL> = GetCurrentRouteSchemaKey<TSchemaConfig, TInitURL>, const TSchema extends CallApiSchema = GetCurrentRouteSchema<{
   [x: AnyString]: CallApiSchema | undefined;
   "@default"?: CallApiSchema | undefined;
   "@delete/"?: CallApiSchema | undefined;
@@ -1877,5 +1902,5 @@ declare const callApi: <TData = unknown, TErrorData = unknown, TResultMode exten
   "@put/"?: CallApiSchema | undefined;
 }, TSchema, CallApiSchemaConfig, TSchemaConfig, TInitURL, TCurrentRouteSchemaKey, DefaultPluginArray, TPluginArray>) => Promise<TComputedResult>;
 //#endregion
-export { Writeable as $, ErrorContext as A, CallApiPlugin as B, InferExtendSchemaContext as C, ValidationError as D, HTTPError as E, ResponseContext as F, BaseCallApiSchemaRoutes as G, PluginSetupContext as H, ResponseErrorContext as I, CallApiSchemaConfig as J, BaseSchemaRouteKeyPrefixes as K, ResponseStreamContext as L, HooksOrHooksArray as M, RequestContext as N, RetryOptions as O, RequestStreamContext as P, Satisfies as Q, SuccessContext as R, GetExtendSchemaConfigContext as S, Register as T, InferParamsFromRoute as U, PluginHooks as V, URLOptions as W, InferSchemaOutput as X, InferSchemaInput as Y, AnyFunction as Z, CallApiExtraOptionsForHooks as _, CallApiResultSuccessOrErrorVariant as a, CallApiRequestOptionsForHooks as b, PossibleJavaScriptError as c, ResponseTypeType as d, ResultModeType as f, CallApiExtraOptions as g, CallApiConfig as h, CallApiResultErrorVariant as i, Hooks as j, DedupeOptions as k, PossibleJavaScriptOrValidationError as l, BaseCallApiExtraOptions as m, createFetchClient as n, CallApiResultSuccessVariant as o, BaseCallApiConfig as p, CallApiSchema as q, createFetchClientWithContext as r, PossibleHTTPError as s, callApi as t, PossibleValidationError as u, CallApiParameters as v, InstanceContext as w, CallApiResultLoose as x, CallApiRequestOptions as y, DefaultCallApiContext as z };
-//# sourceMappingURL=index-BEp4V3_c.d.ts.map
+export { ResponseStreamContext as $, Register as A, InferSchemaInput as B, CallApiParameters as C, GetExtendSchemaConfigContext as D, CallApiResultLoose as E, URLOptions as F, DedupeOptions as G, FetchImpl as H, BaseCallApiSchemaRoutes as I, HooksOrHooksArray as J, ErrorContext as K, BaseSchemaRouteKeyPrefixes as L, ValidationError as M, RetryOptions as N, InferExtendSchemaContext as O, InferParamsFromRoute as P, ResponseErrorContext as Q, CallApiSchema as R, CallApiExtraOptionsForHooks as S, CallApiRequestOptionsForHooks as T, FetchMiddlewareContext as U, InferSchemaOutput as V, Middlewares as W, RequestStreamContext as X, RequestContext as Y, ResponseContext as Z, ResultModeType as _, CallApiPlugin as a, CallApiConfig as b, PluginSetupContext as c, CallApiResultSuccessVariant as d, SuccessContext as et, PossibleHTTPError as f, ResponseTypeType as g, PossibleValidationError as h, DefaultCallApiContext as i, HTTPError as j, InstanceContext as k, CallApiResultErrorVariant as l, PossibleJavaScriptOrValidationError as m, createFetchClient as n, Satisfies as nt, PluginHooks as o, PossibleJavaScriptError as p, Hooks as q, createFetchClientWithContext as r, Writeable as rt, PluginMiddlewares as s, callApi as t, AnyFunction as tt, CallApiResultSuccessOrErrorVariant as u, BaseCallApiConfig as v, CallApiRequestOptions as w, CallApiExtraOptions as x, BaseCallApiExtraOptions as y, CallApiSchemaConfig as z };
+//# sourceMappingURL=index-CGn8h_Ai.d.ts.map