@zayne-labs/callapi 1.7.2 → 1.7.5

package/README.md

@@ -1,7 +1,7 @@
 <h1 align="center">CallApi - Advanced Fetch Client</h1>
 
 <p align="center">
-   <img src="https://github.com/zayne-labs/call-api/blob/main/packages/callapi/assets/logo.png" alt="CallApi Logo" width="30%">
+   <img src="https://res.cloudinary.com/djvestif4/image/upload/v1745621399/call-api/logo_unyvnx.jpg" alt="CallApi Logo" width="30%">
 </p>
 
 <p align="center">

package/dist/cjs/{error-By05WYGj.d.cts → common-BUhBcx_C.d.cts}

@@ -65,6 +65,58 @@ type CommonRequestHeaders = "Access-Control-Allow-Credentials" | "Access-Control
 type CommonAuthorizationHeaders = `${"Basic" | "Bearer" | "Token"} ${string}`;
 type CommonContentTypes = "application/epub+zip" | "application/gzip" | "application/json" | "application/ld+json" | "application/octet-stream" | "application/ogg" | "application/pdf" | "application/rtf" | "application/vnd.ms-fontobject" | "application/wasm" | "application/xhtml+xml" | "application/xml" | "application/zip" | "audio/aac" | "audio/mpeg" | "audio/ogg" | "audio/opus" | "audio/webm" | "audio/x-midi" | "font/otf" | "font/ttf" | "font/woff" | "font/woff2" | "image/avif" | "image/bmp" | "image/gif" | "image/jpeg" | "image/png" | "image/svg+xml" | "image/tiff" | "image/webp" | "image/x-icon" | "model/gltf-binary" | "model/gltf+json" | "text/calendar" | "text/css" | "text/csv" | "text/html" | "text/javascript" | "text/plain" | "video/3gpp" | "video/3gpp2" | "video/av1" | "video/mp2t" | "video/mp4" | "video/mpeg" | "video/ogg" | "video/webm" | "video/x-msvideo" | AnyString;
 
+type ErrorDetails<TErrorResponse> = {
+    defaultErrorMessage: string;
+    errorData: TErrorResponse;
+    response: Response;
+};
+type ErrorOptions = {
+    cause?: unknown;
+};
+declare class HTTPError<TErrorResponse = Record<string, unknown>> {
+    cause: ErrorOptions["cause"];
+    errorData: ErrorDetails<TErrorResponse>["errorData"];
+    isHTTPError: boolean;
+    message: string;
+    name: "HTTPError";
+    response: ErrorDetails<TErrorResponse>["response"];
+    constructor(errorDetails: ErrorDetails<TErrorResponse>, errorOptions?: ErrorOptions);
+}
+type PossibleJavaScriptError = UnmaskType<{
+    errorData: DOMException | Error | SyntaxError | TypeError;
+    message: string;
+    name: "AbortError" | "Error" | "SyntaxError" | "TimeoutError" | "TypeError" | (`${string}Error` & {});
+}>;
+type PossibleHTTPError<TErrorData> = UnmaskType<{
+    errorData: TErrorData;
+    message: string;
+    name: "HTTPError";
+}>;
+
+type StreamProgressEvent = {
+    /**
+     * Current chunk of data being streamed
+     */
+    chunk: Uint8Array;
+    /**
+     * Progress in percentage
+     */
+    progress: number;
+    /**
+     * Total size of data in bytes
+     */
+    totalBytes: number;
+    /**
+     * Amount of data transferred so far
+     */
+    transferredBytes: number;
+};
+declare global {
+    interface ReadableStream<R> {
+        [Symbol.asyncIterator]: () => AsyncIterableIterator<R>;
+    }
+}
+
 /**
  * The Standard Schema interface.
  * @see https://github.com/standard-schema/standard-schema
@@ -233,151 +285,215 @@ interface UrlOptions<TSchemas extends CallApiSchemas> {
     query?: InferSchemaResult<TSchemas["query"], Query>;
 }
 
-type RetryCondition<TErrorData> = (context: ErrorContext<TErrorData>) => Awaitable<boolean>;
-interface RetryOptions<TErrorData> {
-    /**
-     * Keeps track of the number of times the request has already been retried
-     * @deprecated This property is used internally to track retries. Please abstain from modifying it.
-     */
-    readonly ["~retryCount"]?: number;
+type UnionToIntersection<TUnion> = (TUnion extends unknown ? (param: TUnion) => void : never) extends (param: infer TParam) => void ? TParam : never;
+type InferSchema<TResult> = TResult extends StandardSchemaV1 ? InferSchemaResult<TResult, NonNullable<unknown>> : TResult;
+type InferPluginOptions<TPluginArray extends CallApiPlugin[]> = UnionToIntersection<InferSchema<ReturnType<NonNullable<TPluginArray[number]["createExtraOptions"]>>>>;
+type PluginInitContext<TMoreOptions = DefaultMoreOptions> = Prettify<SharedHookContext<TMoreOptions> & {
+    initURL: InitURL | undefined;
+}>;
+type PluginInitResult = Partial<Omit<PluginInitContext, "request"> & {
+    request: CallApiRequestOptions;
+}>;
+type PluginHooksWithMoreOptions<TMoreOptions = DefaultMoreOptions> = HooksOrHooksArray<never, never, TMoreOptions>;
+type PluginHooks<TData = never, TErrorData = never, TMoreOptions = DefaultMoreOptions> = HooksOrHooksArray<TData, TErrorData, TMoreOptions>;
+interface CallApiPlugin {
     /**
-     * Number of allowed retry attempts on HTTP errors
-     * @default 0
+     * Defines additional options that can be passed to callApi
      */
-    retryAttempts?: number;
+    createExtraOptions?: (...params: never[]) => unknown;
     /**
-     * Callback whose return value determines if a request should be retried or not
+     * A description for the plugin
      */
-    retryCondition?: RetryCondition<TErrorData>;
+    description?: string;
     /**
-     * Delay between retries in milliseconds
-     * @default 1000
+     * Hooks / Interceptors for the plugin
      */
-    retryDelay?: number;
+    hooks?: PluginHooks;
     /**
-     * Maximum delay in milliseconds. Only applies to exponential strategy
-     * @default 10000
+     *  A unique id for the plugin
      */
-    retryMaxDelay?: number;
+    id: string;
     /**
-     * HTTP methods that are allowed to retry
-     * @default ["GET", "POST"]
+     * A function that will be called when the plugin is initialized. This will be called before the any of the other internal functions.
      */
-    retryMethods?: Method[];
+    init?: (context: PluginInitContext) => Awaitable<PluginInitResult> | Awaitable<void>;
     /**
-     * HTTP status codes that trigger a retry
-     * @default [409, 425, 429, 500, 502, 503, 504]
+     * A name for the plugin
      */
-    retryStatusCodes?: Array<409 | 425 | 429 | 500 | 502 | 503 | 504 | AnyNumber>;
+    name: string;
     /**
-     * Strategy to use when retrying
-     * @default "linear"
+     *  A version for the plugin
      */
-    retryStrategy?: "exponential" | "linear";
+    version?: string;
 }
+declare const definePlugin: <TPlugin extends CallApiPlugin | AnyFunction<CallApiPlugin>>(plugin: TPlugin) => TPlugin;
+type Plugins<TPluginArray extends CallApiPlugin[]> = TPluginArray;
 
 type DefaultDataType = unknown;
 type DefaultMoreOptions = NonNullable<unknown>;
 type DefaultPluginArray = CallApiPlugin[];
 type DefaultThrowOnError = boolean;
 
-type Parser = (responseString: string) => Awaitable<Record<string, unknown>>;
-declare const getResponseType: <TResponse>(response: Response, parser?: Parser) => {
-    arrayBuffer: () => Promise<ArrayBuffer>;
-    blob: () => Promise<Blob>;
-    formData: () => Promise<FormData>;
-    json: () => Promise<TResponse>;
-    stream: () => ReadableStream<Uint8Array<ArrayBufferLike>> | null;
-    text: () => Promise<string>;
+type WithMoreOptions<TMoreOptions = DefaultMoreOptions> = {
+    options: CombinedCallApiExtraOptions & Partial<TMoreOptions>;
 };
-type InitResponseTypeMap<TResponse = unknown> = ReturnType<typeof getResponseType<TResponse>>;
-type ResponseTypeUnion = keyof InitResponseTypeMap | undefined;
-type ResponseTypeMap<TResponse> = {
-    [Key in keyof InitResponseTypeMap<TResponse>]: Awaited<ReturnType<InitResponseTypeMap<TResponse>[Key]>>;
+type Hooks<TData = DefaultDataType, TErrorData = DefaultDataType, TMoreOptions = DefaultMoreOptions> = {
+    /**
+     * Hook that will be called when any error occurs within the request/response lifecycle, regardless of whether the error is from the api or not.
+     * It is basically a combination of `onRequestError` and `onResponseError` hooks
+     */
+    onError?: (context: ErrorContext<TErrorData> & WithMoreOptions<TMoreOptions>) => Awaitable<unknown>;
+    /**
+     * Hook that will be called just before the request is made, allowing for modifications or additional operations.
+     */
+    onRequest?: (context: Prettify<RequestContext & WithMoreOptions<TMoreOptions>>) => Awaitable<unknown>;
+    /**
+     *  Hook that will be called when an error occurs during the fetch request.
+     */
+    onRequestError?: (context: Prettify<RequestErrorContext & WithMoreOptions<TMoreOptions>>) => Awaitable<unknown>;
+    /**
+     * Hook that will be called when upload stream progress is tracked
+     */
+    onRequestStream?: (context: Prettify<RequestStreamContext & WithMoreOptions<TMoreOptions>>) => Awaitable<unknown>;
+    /**
+     * Hook that will be called when any response is received from the api, whether successful or not
+     */
+    onResponse?: (context: ResponseContext<TData, TErrorData> & WithMoreOptions<TMoreOptions>) => Awaitable<unknown>;
+    /**
+     *  Hook that will be called when an error response is received from the api.
+     */
+    onResponseError?: (context: Prettify<ResponseErrorContext<TErrorData> & WithMoreOptions<TMoreOptions>>) => Awaitable<unknown>;
+    /**
+     * Hook that will be called when download stream progress is tracked
+     */
+    onResponseStream?: (context: Prettify<ResponseStreamContext & WithMoreOptions<TMoreOptions>>) => Awaitable<unknown>;
+    /**
+     * Hook that will be called when a request is retried.
+     */
+    onRetry?: (response: ErrorContext<TErrorData> & WithMoreOptions<TMoreOptions>) => Awaitable<unknown>;
+    /**
+     * Hook that will be called when a successful response is received from the api.
+     */
+    onSuccess?: (context: Prettify<SuccessContext<TData> & WithMoreOptions<TMoreOptions>>) => Awaitable<unknown>;
 };
-type GetResponseType<TResponse, TResponseType extends ResponseTypeUnion, TComputedMap extends ResponseTypeMap<TResponse> = ResponseTypeMap<TResponse>> = undefined extends TResponseType ? TComputedMap["json"] : TResponseType extends NonNullable<ResponseTypeUnion> ? TComputedMap[TResponseType] : never;
-
-type StreamProgressEvent = {
+type HooksOrHooksArray<TData = DefaultDataType, TErrorData = DefaultDataType, TMoreOptions = DefaultMoreOptions> = {
+    [Key in keyof Hooks<TData, TErrorData, TMoreOptions>]: Hooks<TData, TErrorData, TMoreOptions>[Key] | Array<Hooks<TData, TErrorData, TMoreOptions>[Key]>;
+};
+type SharedHookContext<TMoreOptions = DefaultMoreOptions> = {
     /**
-     * Current chunk of data being streamed
+     * Config object passed to createFetchClient
      */
-    chunk: Uint8Array;
+    baseConfig: BaseCallApiExtraOptions & CallApiRequestOptions;
     /**
-     * Progress in percentage
+     * Config object passed to the callApi instance
      */
-    progress: number;
+    config: CallApiExtraOptions & CallApiRequestOptions;
     /**
-     * Total size of data in bytes
+     * Merged options consisting of extra options from createFetchClient, the callApi instance and default options.
+     *
      */
-    totalBytes: number;
+    options: CombinedCallApiExtraOptions & Partial<TMoreOptions>;
     /**
-     * Amount of data transferred so far
+     * Merged request consisting of request options from createFetchClient, the callApi instance and default request options.
      */
-    transferredBytes: number;
+    request: CallApiRequestOptionsForHooks;
 };
-type RequestStreamContext = {
+type RequestContext = UnmaskType<SharedHookContext>;
+type ResponseContext<TData, TErrorData> = UnmaskType<Prettify<SharedHookContext & {
+    data: TData;
+    error: null;
+    response: Response;
+}> | Prettify<SharedHookContext & {
+    data: null;
+    error: PossibleHTTPError<TErrorData>;
+    response: Response;
+}>>;
+type SuccessContext<TData> = UnmaskType<Prettify<SharedHookContext & {
+    data: TData;
+    response: Response;
+}>>;
+type RequestErrorContext = UnmaskType<Prettify<SharedHookContext & {
+    error: PossibleJavaScriptError;
+    response: null;
+}>>;
+type ResponseErrorContext<TErrorData> = UnmaskType<Prettify<SharedHookContext & {
+    error: PossibleHTTPError<TErrorData>;
+    response: Response;
+}>>;
+type ErrorContext<TErrorData> = UnmaskType<Prettify<SharedHookContext & {
+    error: PossibleHTTPError<TErrorData>;
+    response: Response;
+}> | Prettify<SharedHookContext & {
+    error: PossibleJavaScriptError;
+    response: null;
+}>>;
+type RequestStreamContext = UnmaskType<Prettify<SharedHookContext & {
     event: StreamProgressEvent;
-    options: CombinedCallApiExtraOptions;
-    request: CallApiRequestOptionsForHooks;
     requestInstance: Request;
-};
-type ResponseStreamContext = {
+}>>;
+type ResponseStreamContext = UnmaskType<Prettify<SharedHookContext & {
     event: StreamProgressEvent;
-    options: CombinedCallApiExtraOptions;
-    request: CallApiRequestOptionsForHooks;
     response: Response;
-};
-declare global {
-    interface ReadableStream<R> {
-        [Symbol.asyncIterator]: () => AsyncIterableIterator<R>;
-    }
-}
+}>>;
 
-type UnionToIntersection<TUnion> = (TUnion extends unknown ? (param: TUnion) => void : never) extends (param: infer TParam) => void ? TParam : never;
-type InferSchema<TResult> = TResult extends StandardSchemaV1 ? InferSchemaResult<TResult, NonNullable<unknown>> : TResult;
-type InferPluginOptions<TPluginArray extends CallApiPlugin[]> = UnionToIntersection<InferSchema<ReturnType<NonNullable<TPluginArray[number]["createExtraOptions"]>>>>;
-type PluginInitContext<TMoreOptions = DefaultMoreOptions> = WithMoreOptions<TMoreOptions> & {
-    baseConfig: BaseCallApiExtraOptions & CallApiRequestOptions;
-    config: CallApiExtraOptions & CallApiRequestOptions;
-    initURL: InitURL | undefined;
-    options: CombinedCallApiExtraOptions;
-    request: CallApiRequestOptionsForHooks;
+type Parser = (responseString: string) => Awaitable<Record<string, unknown>>;
+declare const getResponseType: <TResponse>(response: Response, parser?: Parser) => {
+    arrayBuffer: () => Promise<ArrayBuffer>;
+    blob: () => Promise<Blob>;
+    formData: () => Promise<FormData>;
+    json: () => Promise<TResponse>;
+    stream: () => ReadableStream<Uint8Array<ArrayBufferLike>> | null;
+    text: () => Promise<string>;
 };
-type PluginInitResult = Partial<Omit<PluginInitContext, "request"> & {
-    request: CallApiRequestOptions;
-}>;
-interface CallApiPlugin<TData = never, TErrorData = never> {
+type InitResponseTypeMap<TResponse = unknown> = ReturnType<typeof getResponseType<TResponse>>;
+type ResponseTypeUnion = keyof InitResponseTypeMap | null;
+type ResponseTypeMap<TResponse> = {
+    [Key in keyof InitResponseTypeMap<TResponse>]: Awaited<ReturnType<InitResponseTypeMap<TResponse>[Key]>>;
+};
+type GetResponseType<TResponse, TResponseType extends ResponseTypeUnion, TComputedResponseTypeMap extends ResponseTypeMap<TResponse> = ResponseTypeMap<TResponse>> = null extends TResponseType ? TComputedResponseTypeMap["json"] : TResponseType extends NonNullable<ResponseTypeUnion> ? TComputedResponseTypeMap[TResponseType] : never;
+
+type RetryCondition<TErrorData> = (context: ErrorContext<TErrorData>) => Awaitable<boolean>;
+interface RetryOptions<TErrorData> {
     /**
-     * Defines additional options that can be passed to callApi
+     * Keeps track of the number of times the request has already been retried
+     * @deprecated This property is used internally to track retries. Please abstain from modifying it.
      */
-    createExtraOptions?: (...params: never[]) => unknown;
+    readonly ["~retryCount"]?: number;
     /**
-     * A description for the plugin
+     * Number of allowed retry attempts on HTTP errors
+     * @default 0
      */
-    description?: string;
+    retryAttempts?: number;
     /**
-     * Hooks / Interceptors for the plugin
+     * Callback whose return value determines if a request should be retried or not
      */
-    hooks?: InterceptorsOrInterceptorArray<TData, TErrorData>;
+    retryCondition?: RetryCondition<TErrorData>;
     /**
-     *  A unique id for the plugin
+     * Delay between retries in milliseconds
+     * @default 1000
      */
-    id: string;
+    retryDelay?: number;
     /**
-     * A function that will be called when the plugin is initialized. This will be called before the any of the other internal functions.
+     * Maximum delay in milliseconds. Only applies to exponential strategy
+     * @default 10000
      */
-    init?: (context: PluginInitContext) => Awaitable<PluginInitResult> | Awaitable<void>;
+    retryMaxDelay?: number;
     /**
-     * A name for the plugin
+     * HTTP methods that are allowed to retry
+     * @default ["GET", "POST"]
      */
-    name: string;
+    retryMethods?: Method[];
     /**
-     *  A version for the plugin
+     * HTTP status codes that trigger a retry
+     * @default [409, 425, 429, 500, 502, 503, 504]
      */
-    version?: string;
+    retryStatusCodes?: Array<409 | 425 | 429 | 500 | 502 | 503 | 504 | AnyNumber>;
+    /**
+     * Strategy to use when retrying
+     * @default "linear"
+     */
+    retryStrategy?: "exponential" | "linear";
 }
-declare const definePlugin: <TPlugin extends CallApiPlugin | AnyFunction<CallApiPlugin>>(plugin: TPlugin) => TPlugin;
-type Plugins<TPluginArray extends CallApiPlugin[]> = TPluginArray;
 
 type ModifiedRequestInit = RequestInit & {
     duplex?: "half";
@@ -467,7 +583,7 @@ type ResultModeOption<TErrorData, TResultMode extends ResultModeUnion> = TErrorD
     resultMode: "onlySuccessWithException";
 } : TErrorData extends false | undefined ? {
     resultMode?: "onlySuccessWithException";
-} : undefined extends TResultMode ? {
+} : null extends TResultMode ? {
     resultMode?: TResultMode;
 } : {
     resultMode: TResultMode;
@@ -478,51 +594,6 @@ type CallApiRequestOptions<TSchemas extends CallApiSchemas = DefaultMoreOptions>
 type CallApiRequestOptionsForHooks<TSchemas extends CallApiSchemas = DefaultMoreOptions> = Omit<CallApiRequestOptions<TSchemas>, "headers"> & {
     headers?: Record<string, string | undefined>;
 };
-type WithMoreOptions<TMoreOptions = DefaultMoreOptions> = {
-    options: CombinedCallApiExtraOptions & Partial<TMoreOptions>;
-};
-interface Interceptors<TData = DefaultDataType, TErrorData = DefaultDataType, TMoreOptions = DefaultMoreOptions> {
-    /**
-     * Interceptor that will be called when any error occurs within the request/response lifecycle, regardless of whether the error is from the api or not.
-     * It is basically a combination of `onRequestError` and `onResponseError` interceptors
-     */
-    onError?: (context: ErrorContext<TErrorData> & WithMoreOptions<TMoreOptions>) => Awaitable<unknown>;
-    /**
-     * Interceptor that will be called just before the request is made, allowing for modifications or additional operations.
-     */
-    onRequest?: (context: RequestContext & WithMoreOptions<TMoreOptions>) => Awaitable<unknown>;
-    /**
-     *  Interceptor that will be called when an error occurs during the fetch request.
-     */
-    onRequestError?: (context: RequestErrorContext & WithMoreOptions<TMoreOptions>) => Awaitable<unknown>;
-    /**
-     * Interceptor that will be called when upload stream progress is tracked
-     */
-    onRequestStream?: (context: RequestStreamContext & WithMoreOptions<TMoreOptions>) => Awaitable<unknown>;
-    /**
-     * Interceptor that will be called when any response is received from the api, whether successful or not
-     */
-    onResponse?: (context: ResponseContext<TData, TErrorData> & WithMoreOptions<TMoreOptions>) => Awaitable<unknown>;
-    /**
-     *  Interceptor that will be called when an error response is received from the api.
-     */
-    onResponseError?: (context: ResponseErrorContext<TErrorData> & WithMoreOptions<TMoreOptions>) => Awaitable<unknown>;
-    /**
-     * Interceptor that will be called when download stream progress is tracked
-     */
-    onResponseStream?: (context: ResponseStreamContext & WithMoreOptions<TMoreOptions>) => Awaitable<unknown>;
-    /**
-     * Interceptor that will be called when a request is retried.
-     */
-    onRetry?: (response: ErrorContext<TErrorData> & WithMoreOptions<TMoreOptions>) => Awaitable<unknown>;
-    /**
-     * Interceptor that will be called when a successful response is received from the api.
-     */
-    onSuccess?: (context: SuccessContext<TData> & WithMoreOptions<TMoreOptions>) => Awaitable<unknown>;
-}
-type InterceptorsOrInterceptorArray<TData = DefaultDataType, TErrorData = DefaultDataType, TMoreOptions = DefaultMoreOptions> = {
-    [Key in keyof Interceptors<TData, TErrorData, TMoreOptions>]: Interceptors<TData, TErrorData, TMoreOptions>[Key] | Array<Interceptors<TData, TErrorData, TMoreOptions>[Key]>;
-};
 type FetchImpl = UnmaskType<(input: string | Request | URL, init?: RequestInit) => Promise<Response>>;
 type ExtraOptions<TData = DefaultDataType, TErrorData = DefaultDataType, TResultMode extends ResultModeUnion = ResultModeUnion, TThrowOnError extends boolean = DefaultThrowOnError, TResponseType extends ResponseTypeUnion = ResponseTypeUnion, TPluginArray extends CallApiPlugin[] = DefaultPluginArray, TSchemas extends CallApiSchemas = DefaultMoreOptions> = {
     /**
@@ -569,7 +640,7 @@ type ExtraOptions<TData = DefaultDataType, TErrorData = DefaultDataType, TResult
      * If true, forces the calculation of the total byte size from the request or response body, in case the content-length header is not present or is incorrect.
      * @default false
      */
-    forceStreamSizeCalc?: boolean | {
+    forceCalculateStreamSize?: boolean | {
         request?: boolean;
         response?: boolean;
     };
@@ -578,14 +649,14 @@ type ExtraOptions<TData = DefaultDataType, TErrorData = DefaultDataType, TResult
      */
     readonly fullURL?: string;
     /**
-     * Defines the mode in which the merged hooks are executed, can be set to "parallel" | "sequential".
+     * Defines the mode in which the composed hooks are executed".
      * - If set to "parallel", main and plugin hooks will be executed in parallel.
      * - If set to "sequential", the plugin hooks will be executed first, followed by the main hook.
      * @default "parallel"
      */
     mergedHooksExecutionMode?: "parallel" | "sequential";
     /**
-     * - Controls what order in which the merged hooks execute
+     * - Controls what order in which the composed hooks execute
      * @default "mainHooksAfterPlugins"
      */
     mergedHooksExecutionOrder?: "mainHooksAfterPlugins" | "mainHooksBeforePlugins";
@@ -594,7 +665,7 @@ type ExtraOptions<TData = DefaultDataType, TErrorData = DefaultDataType, TResult
      */
     plugins?: Plugins<TPluginArray>;
     /**
-     * Custom function to parse the response string into a object.
+     * Custom function to parse the response string
      */
     responseParser?: (responseString: string) => Awaitable<Record<string, unknown>>;
     /**
@@ -626,27 +697,44 @@ type ExtraOptions<TData = DefaultDataType, TErrorData = DefaultDataType, TResult
      * Custom validation functions for response validation
      */
     validators?: CallApiValidators<TData, TErrorData>;
-} & InterceptorsOrInterceptorArray<TData, TErrorData> & Partial<InferPluginOptions<TPluginArray>> & MetaOption<TSchemas> & RetryOptions<TErrorData> & ResultModeOption<TErrorData, TResultMode> & UrlOptions<TSchemas>;
-declare const optionsEnumToExtendFromBase: ("plugins" | "schemas" | "validators")[];
+} & HooksOrHooksArray<TData, TErrorData, Partial<InferPluginOptions<TPluginArray>>> & Partial<InferPluginOptions<TPluginArray>> & MetaOption<TSchemas> & RetryOptions<TErrorData> & ResultModeOption<TErrorData, TResultMode> & UrlOptions<TSchemas>;
 type CallApiExtraOptions<TData = DefaultDataType, TErrorData = DefaultDataType, TResultMode extends ResultModeUnion = ResultModeUnion, TThrowOnError extends boolean = DefaultThrowOnError, TResponseType extends ResponseTypeUnion = ResponseTypeUnion, TPluginArray extends CallApiPlugin[] = DefaultPluginArray, TSchemas extends CallApiSchemas = DefaultMoreOptions> = ExtraOptions<TData, TErrorData, TResultMode, TThrowOnError, TResponseType, TPluginArray, TSchemas> & {
-    /**
-     * Options that should extend the base options.
-     */
-    extend?: Pick<ExtraOptions<TData, TErrorData, TResultMode, TThrowOnError, TResponseType, TPluginArray, TSchemas>, (typeof optionsEnumToExtendFromBase)[number]>;
+    plugins?: Plugins<TPluginArray> | ((context: {
+        basePlugins: Plugins<TPluginArray>;
+    }) => Plugins<TPluginArray>);
+    schemas?: TSchemas | ((context: {
+        baseSchemas: TSchemas;
+    }) => TSchemas);
+    validators?: CallApiValidators<TData, TErrorData> | ((context: {
+        baseValidators: CallApiValidators<TData, TErrorData>;
+    }) => CallApiValidators<TData, TErrorData>);
 };
-declare const optionsEnumToOmitFromBase: ("dedupeKey" | "extend")[];
+declare const optionsEnumToOmitFromBase: "dedupeKey"[];
 type BaseCallApiExtraOptions<TBaseData = DefaultDataType, TBaseErrorData = DefaultDataType, TBaseResultMode extends ResultModeUnion = ResultModeUnion, TBaseThrowOnError extends boolean = DefaultThrowOnError, TBaseResponseType extends ResponseTypeUnion = ResponseTypeUnion, TBasePluginArray extends CallApiPlugin[] = DefaultPluginArray, TBaseSchemas extends CallApiSchemas = DefaultMoreOptions> = Omit<Partial<CallApiExtraOptions<TBaseData, TBaseErrorData, TBaseResultMode, TBaseThrowOnError, TBaseResponseType, TBasePluginArray, TBaseSchemas>>, (typeof optionsEnumToOmitFromBase)[number]> & {
     /**
-     * If true, the base options will not be merged with the main options by default.
+     * Specifies which configuration parts should skip automatic merging between base and main configs.
+     * Use this when you need manual control over how configs are combined.
      *
-     * It's recommended to set this to true when you want to handle the options merge manually from the createFetchClient config function signature.
+     * @values
+     * - "all" - Disables automatic merging for both request and options
+     * - "options" - Disables automatic merging of options only
+     * - "request" - Disables automatic merging of request only
      *
-     * This helps prevent main options from overriding base options by default.
-     * @default false
+     * @example
+     * ```ts
+     * const client = createFetchClient((ctx) => ({
+     *   skipAutoMergeFor: "options",
+     *
+     *   // Now you can manually merge options in your config function
+     *   ...ctx.options,
+     * }));
+     * ```
      */
-    mergeMainOptionsManuallyFromBase?: boolean;
+    skipAutoMergeFor?: "all" | "options" | "request";
 };
-type CombinedCallApiExtraOptions = Interceptors & Omit<BaseCallApiExtraOptions & CallApiExtraOptions, keyof Interceptors>;
+type CombinedExtraOptionsWithoutHooks = Omit<BaseCallApiExtraOptions & CallApiExtraOptions, keyof Hooks>;
+interface CombinedCallApiExtraOptions extends CombinedExtraOptionsWithoutHooks, Hooks {
+}
 type BaseCallApiConfig<TBaseData = DefaultDataType, TBaseErrorData = DefaultDataType, TBaseResultMode extends ResultModeUnion = ResultModeUnion, TBaseThrowOnError extends boolean = DefaultThrowOnError, TBaseResponseType extends ResponseTypeUnion = ResponseTypeUnion, TBasePluginArray extends CallApiPlugin[] = DefaultPluginArray, TBaseSchemas extends CallApiSchemas = DefaultMoreOptions> = (CallApiRequestOptions<TBaseSchemas> & BaseCallApiExtraOptions<TBaseData, TBaseErrorData, TBaseResultMode, TBaseThrowOnError, TBaseResponseType, TBasePluginArray, TBaseSchemas>) | ((context: {
     initURL: string;
     options: CallApiExtraOptions;
@@ -657,63 +745,6 @@ type CallApiParameters<TData = DefaultDataType, TErrorData = DefaultDataType, TR
     initURL: InferSchemaResult<TSchemas["initURL"], InitURL>,
     config?: CallApiConfig<TData, TErrorData, TResultMode, TThrowOnError, TResponseType, TPluginArray, TSchemas>
 ];
-type RequestContext = UnmaskType<{
-    options: CombinedCallApiExtraOptions;
-    request: CallApiRequestOptionsForHooks;
-}>;
-type ResponseContext<TData, TErrorData> = UnmaskType<{
-    data: TData;
-    error: null;
-    options: CombinedCallApiExtraOptions;
-    request: CallApiRequestOptionsForHooks;
-    response: Response;
-} | {
-    data: null;
-    error: PossibleHTTPError<TErrorData>;
-    options: CombinedCallApiExtraOptions;
-    request: CallApiRequestOptionsForHooks;
-    response: Response;
-}>;
-type SuccessContext<TData> = UnmaskType<{
-    data: TData;
-    options: CombinedCallApiExtraOptions;
-    request: CallApiRequestOptionsForHooks;
-    response: Response;
-}>;
-type PossibleJavascriptErrorNames = "AbortError" | "Error" | "SyntaxError" | "TimeoutError" | "TypeError" | (`${string}Error` & DefaultMoreOptions);
-type PossibleJavaScriptError = UnmaskType<{
-    errorData: DOMException | Error | SyntaxError | TypeError;
-    message: string;
-    name: PossibleJavascriptErrorNames;
-}>;
-type PossibleHTTPError<TErrorData> = UnmaskType<{
-    errorData: TErrorData;
-    message: string;
-    name: "HTTPError";
-}>;
-type RequestErrorContext = UnmaskType<{
-    error: PossibleJavaScriptError;
-    options: CombinedCallApiExtraOptions;
-    request: CallApiRequestOptionsForHooks;
-    response: null;
-}>;
-type ResponseErrorContext<TErrorData> = UnmaskType<{
-    error: PossibleHTTPError<TErrorData>;
-    options: CombinedCallApiExtraOptions;
-    request: CallApiRequestOptionsForHooks;
-    response: Response;
-}>;
-type ErrorContext<TErrorData> = UnmaskType<{
-    error: PossibleHTTPError<TErrorData>;
-    options: CombinedCallApiExtraOptions;
-    request: CallApiRequestOptionsForHooks;
-    response: Response;
-} | {
-    error: PossibleJavaScriptError;
-    options: CombinedCallApiExtraOptions;
-    request: CallApiRequestOptionsForHooks;
-    response: null;
-}>;
 type CallApiResultSuccessVariant<TData> = {
     data: TData;
     error: null;
@@ -738,24 +769,8 @@ type ResultModeMap<TData = DefaultDataType, TErrorData = DefaultDataType, TRespo
     onlySuccess: CallApiResultErrorVariant<TComputedErrorData>["data"] | CallApiResultSuccessVariant<TComputedData>["data"];
     onlySuccessWithException: CallApiResultSuccessVariant<TComputedData>["data"];
 }>;
-type ResultModeUnion = keyof ResultModeMap | undefined;
-type GetCallApiResult<TData, TErrorData, TResultMode extends ResultModeUnion, TThrowOnError extends boolean, TResponseType extends ResponseTypeUnion> = TErrorData extends false | undefined ? ResultModeMap<TData, TErrorData, TResponseType>["onlySuccessWithException"] : ResultModeUnion | undefined extends TResultMode ? TThrowOnError extends true ? ResultModeMap<TData, TErrorData, TResponseType>["allWithException"] : ResultModeMap<TData, TErrorData, TResponseType>["all"] : TResultMode extends NonNullable<ResultModeUnion> ? TResultMode extends "onlySuccess" ? ResultModeMap<TData, TErrorData, TResponseType>["onlySuccessWithException"] : TResultMode extends "onlyResponse" ? ResultModeMap<TData, TErrorData, TResponseType>["onlyResponseWithException"] : ResultModeMap<TData, TErrorData, TResponseType>[TResultMode] : never;
+type ResultModeUnion = keyof ResultModeMap | null;
+type GetCallApiResult<TData, TErrorData, TResultMode extends ResultModeUnion, TThrowOnError extends boolean, TResponseType extends ResponseTypeUnion> = TErrorData extends false | undefined ? ResultModeMap<TData, TErrorData, TResponseType>["onlySuccessWithException"] : null extends TResultMode ? TThrowOnError extends true ? ResultModeMap<TData, TErrorData, TResponseType>["allWithException"] : ResultModeMap<TData, TErrorData, TResponseType>["all"] : TResultMode extends NonNullable<ResultModeUnion> ? TResultMode extends "onlySuccess" ? ResultModeMap<TData, TErrorData, TResponseType>["onlySuccessWithException"] : TResultMode extends "onlyResponse" ? ResultModeMap<TData, TErrorData, TResponseType>["onlyResponseWithException"] : ResultModeMap<TData, TErrorData, TResponseType>[TResultMode] : never;
 type CallApiResult<TData, TErrorData, TResultMode extends ResultModeUnion, TThrowOnError extends boolean, TResponseType extends ResponseTypeUnion> = Promise<GetCallApiResult<TData, TErrorData, TResultMode, TThrowOnError, TResponseType>>;
 
-type ErrorDetails<TErrorResponse> = {
-    defaultErrorMessage: string;
-    errorData: TErrorResponse;
-    response: Response;
-};
-type ErrorOptions = {
-    cause?: unknown;
-};
-declare class HTTPError<TErrorResponse = Record<string, unknown>> extends Error {
-    errorData: ErrorDetails<TErrorResponse>["errorData"];
-    isHTTPError: boolean;
-    name: "HTTPError";
-    response: ErrorDetails<TErrorResponse>["response"];
-    constructor(errorDetails: ErrorDetails<TErrorResponse>, errorOptions?: ErrorOptions);
-}
-
-export { type ResponseContext as A, type BaseCallApiConfig as B, type CallApiPlugin as C, type DefaultPluginArray as D, type ErrorContext as E, type ResponseErrorContext as F, HTTPError as H, type InferSchemaResult as I, type PluginInitContext as P, type ResultModeUnion as R, type SuccessContext as S, type ResponseTypeUnion as a, type CallApiSchemas as b, type CallApiConfig as c, type CallApiResult as d, type DefaultDataType as e, type DefaultThrowOnError as f, type DefaultMoreOptions as g, type CallApiParameters as h, definePlugin as i, getDefaultOptions as j, type RetryOptions as k, type BaseCallApiExtraOptions as l, type CallApiExtraOptions as m, type PossibleJavaScriptError as n, type PossibleHTTPError as o, type CallApiRequestOptions as p, type CallApiRequestOptionsForHooks as q, type CallApiResultErrorVariant as r, type CallApiResultSuccessVariant as s, type CombinedCallApiExtraOptions as t, type Interceptors as u, type InterceptorsOrInterceptorArray as v, type PossibleJavascriptErrorNames as w, type Register as x, type RequestContext as y, type RequestErrorContext as z };
+export { type CallApiRequestOptions as A, type BaseCallApiConfig as B, type CallApiPlugin as C, type DefaultPluginArray as D, type ErrorContext as E, type CallApiRequestOptionsForHooks as F, type CallApiResultErrorVariant as G, HTTPError as H, type InferSchemaResult as I, type CallApiResultSuccessVariant as J, type CombinedCallApiExtraOptions as K, type Register as L, type PluginInitContext as P, type ResultModeUnion as R, type SharedHookContext as S, type ResponseTypeUnion as a, type CallApiSchemas as b, type CallApiConfig as c, type CallApiResult as d, type DefaultDataType as e, type DefaultThrowOnError as f, type DefaultMoreOptions as g, type CallApiParameters as h, definePlugin as i, type PluginHooks as j, type PluginHooksWithMoreOptions as k, getDefaultOptions as l, type RetryOptions as m, type PossibleHTTPError as n, type PossibleJavaScriptError as o, type Hooks as p, type HooksOrHooksArray as q, type RequestContext as r, type RequestErrorContext as s, type RequestStreamContext as t, type ResponseContext as u, type ResponseErrorContext as v, type ResponseStreamContext as w, type SuccessContext as x, type BaseCallApiExtraOptions as y, type CallApiExtraOptions as z };