npm - @zayne-labs/callapi - Versions diffs - 1.7.1 → 1.7.4 - Mend

@zayne-labs/callapi 1.7.1 → 1.7.4

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (19) hide show

package/LICENSE +21 -0
package/README.md +1 -1
package/dist/cjs/{error-B0rQm6WQ.d.cts → common-DiBiESb2.d.cts} +336 -223
package/dist/cjs/index.cjs +220 -210
package/dist/cjs/index.cjs.map +1 -1
package/dist/cjs/index.d.cts +3 -4
package/dist/cjs/utils/index.cjs +5 -2
package/dist/cjs/utils/index.cjs.map +1 -1
package/dist/cjs/utils/index.d.cts +2 -4
package/dist/esm/{chunk-MMZRXEXE.js → chunk-FE6ZVVZS.js} +13 -13
package/dist/esm/chunk-FE6ZVVZS.js.map +1 -0
package/dist/esm/{error-B0rQm6WQ.d.ts → common-DiBiESb2.d.ts} +336 -223
package/dist/esm/index.d.ts +3 -4
package/dist/esm/index.js +107 -92
package/dist/esm/index.js.map +1 -1
package/dist/esm/utils/index.d.ts +2 -4
package/dist/esm/utils/index.js +1 -1
package/package.json +2 -6
package/dist/esm/chunk-MMZRXEXE.js.map +0 -1

package/dist/esm/{error-B0rQm6WQ.d.ts → common-DiBiESb2.d.ts} RENAMED Viewed

@@ -1,5 +1,3 @@
-import { StandardSchemaV1 } from '@standard-schema/spec';
 type ValueOrFunctionResult<TValue> = TValue | (() => TValue);
 /**
  * Bearer Or Token authentication
@@ -56,6 +54,9 @@ type AnyNumber = number & {
     z_placeholder?: never;
 };
 type AnyFunction<TResult = unknown> = (...args: any) => TResult;
+type Prettify<TObject> = NonNullable<unknown> & {
+    [Key in keyof TObject]: TObject[Key];
+};
 type UnmaskType<TValue> = {
     _: TValue;
 }["_"];
@@ -64,56 +65,132 @@ 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;
-interface CallApiSchemas {
-    /**
-     *  The schema to use for validating the request body.
-     */
-    body?: StandardSchemaV1<Body>;
-    /**
-     *  The schema to use for validating the response data.
-     */
-    data?: StandardSchemaV1;
+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";
+}>;
+/**
+ * The Standard Schema interface.
+ * @see https://github.com/standard-schema/standard-schema
+ */
+interface StandardSchemaV1<Input = unknown, Output = Input> {
     /**
-     *  The schema to use for validating the response error data.
+     * The Standard Schema properties.
      */
-    errorData?: StandardSchemaV1;
+    readonly "~standard": StandardSchemaV1.Props<Input, Output>;
+}
+declare namespace StandardSchemaV1 {
+    /**
+     * The Standard Schema properties interface.
+     */
+    interface Props<Input = unknown, Output = Input> {
+        /**
+         * Inferred types associated with the schema.
+         */
+        readonly types?: Types<Input, Output> | undefined;
+        /**
+         * Validates unknown input values.
+         */
+        readonly validate: (value: unknown) => Promise<Result<Output>> | Result<Output>;
+        /**
+         * The vendor name of the schema library.
+         */
+        readonly vendor: string;
+        /**
+         * The version number of the standard.
+         */
+        readonly version: 1;
+    }
     /**
-     *  The schema to use for validating the request headers.
+     * The result interface of the validate function.
      */
-    headers?: StandardSchemaV1<Headers>;
+    type Result<Output> = FailureResult | SuccessResult<Output>;
     /**
-     *  The schema to use for validating the request url.
+     * The result interface if validation succeeds.
      */
-    initURL?: StandardSchemaV1<InitURL>;
+    interface SuccessResult<Output> {
+        /**
+         * The non-existent issues.
+         */
+        readonly issues?: undefined;
+        /**
+         * The typed output value.
+         */
+        readonly value: Output;
+    }
     /**
-     *  The schema to use for validating the meta option.
+     * The result interface if validation fails.
      */
-    meta?: StandardSchemaV1<GlobalMeta>;
+    interface FailureResult {
+        /**
+         * The issues of failed validation.
+         */
+        readonly issues: readonly Issue[];
+    }
     /**
-     *  The schema to use for validating the request method.
-     */
-    method?: StandardSchemaV1<Method>;
+     * 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 schema to use for validating the request url parameter.
+     * The path segment interface of the issue.
      */
-    params?: StandardSchemaV1<Params>;
+    interface PathSegment {
+        /**
+         * The key representing a path segment.
+         */
+        readonly key: PropertyKey;
+    }
     /**
-     *  The schema to use for validating the request url querys.
+     * The Standard Schema types interface.
      */
-    query?: StandardSchemaV1<Query>;
-}
-interface CallApiValidators<TData = unknown, TErrorData = unknown> {
+    interface Types<Input = unknown, Output = Input> {
+        /** The input type of the schema. */
+        readonly input: Input;
+        /** The output type of the schema. */
+        readonly output: Output;
+    }
     /**
-     * Custom function to validate the response data.
+     * Infers the input type of a Standard Schema.
      */
-    data?: (value: unknown) => TData;
+    type InferInput<Schema extends StandardSchemaV1> = NonNullable<Schema["~standard"]["types"]>["input"];
     /**
-     * Custom function to validate the response error data, stemming from the api.
-     * This only runs if the api actually sends back error status codes, else it will be ignored, in which case you should only use the `responseValidator` option.
+     * Infers the output type of a Standard Schema.
      */
-    errorData?: (value: unknown) => TErrorData;
+    type InferOutput<Schema extends StandardSchemaV1> = NonNullable<Schema["~standard"]["types"]>["output"];
 }
-type InferSchemaResult<TSchema, TData> = TSchema extends StandardSchemaV1 ? StandardSchemaV1.InferOutput<TSchema> : TData;
 type Params = UnmaskType<Record<string, boolean | number | string> | Array<boolean | number | string>>;
 type Query = UnmaskType<Record<string, boolean | number | string>>;
@@ -133,53 +210,56 @@ interface UrlOptions<TSchemas extends CallApiSchemas> {
     query?: InferSchemaResult<TSchemas["query"], Query>;
 }
-type RetryCondition<TErrorData> = (context: ErrorContext<TErrorData>) => Awaitable<boolean>;
-interface RetryOptions<TErrorData> {
+interface CallApiSchemas {
     /**
-     * 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.
+     *  The schema to use for validating the request body.
      */
-    readonly ["~retryCount"]?: number;
+    body?: StandardSchemaV1<Body>;
     /**
-     * Number of allowed retry attempts on HTTP errors
-     * @default 0
+     *  The schema to use for validating the response data.
      */
-    retryAttempts?: number;
+    data?: StandardSchemaV1;
     /**
-     * Callback whose return value determines if a request should be retried or not
+     *  The schema to use for validating the response error data.
      */
-    retryCondition?: RetryCondition<TErrorData>;
+    errorData?: StandardSchemaV1;
     /**
-     * Delay between retries in milliseconds
-     * @default 1000
+     *  The schema to use for validating the request headers.
      */
-    retryDelay?: number;
+    headers?: StandardSchemaV1<Headers>;
     /**
-     * Maximum delay in milliseconds. Only applies to exponential strategy
-     * @default 10000
+     *  The schema to use for validating the request url.
      */
-    retryMaxDelay?: number;
+    initURL?: StandardSchemaV1<InitURL>;
     /**
-     * HTTP methods that are allowed to retry
-     * @default ["GET", "POST"]
+     *  The schema to use for validating the meta option.
      */
-    retryMethods?: Method[];
+    meta?: StandardSchemaV1<GlobalMeta>;
     /**
-     * HTTP status codes that trigger a retry
-     * @default [409, 425, 429, 500, 502, 503, 504]
+     *  The schema to use for validating the request method.
      */
-    retryStatusCodes?: Array<409 | 425 | 429 | 500 | 502 | 503 | 504 | AnyNumber>;
+    method?: StandardSchemaV1<Method>;
     /**
-     * Strategy to use when retrying
-     * @default "linear"
+     *  The schema to use for validating the request url parameter.
      */
-    retryStrategy?: "exponential" | "linear";
+    params?: StandardSchemaV1<Params>;
+    /**
+     *  The schema to use for validating the request url querys.
+     */
+    query?: StandardSchemaV1<Query>;
 }
-type DefaultDataType = unknown;
-type DefaultMoreOptions = NonNullable<unknown>;
-type DefaultPluginArray = CallApiPlugin[];
-type DefaultThrowOnError = boolean;
+interface CallApiValidators<TData = unknown, TErrorData = unknown> {
+    /**
+     * Custom function to validate the response data.
+     */
+    data?: (value: unknown) => TData;
+    /**
+     * Custom function to validate the response error data, stemming from the api.
+     * This only runs if the api actually sends back error status codes, else it will be ignored, in which case you should only use the `responseValidator` option.
+     */
+    errorData?: (value: unknown) => TErrorData;
+}
+type InferSchemaResult<TSchema, TData> = TSchema extends StandardSchemaV1 ? StandardSchemaV1.InferOutput<TSchema> : TData;
 type Parser = (responseString: string) => Awaitable<Record<string, unknown>>;
 declare const getResponseType: <TResponse>(response: Response, parser?: Parser) => {
@@ -215,18 +295,6 @@ type StreamProgressEvent = {
      */
     transferredBytes: number;
 };
-type RequestStreamContext = {
-    event: StreamProgressEvent;
-    options: CombinedCallApiExtraOptions;
-    request: CallApiRequestOptionsForHooks;
-    requestInstance: Request;
-};
-type ResponseStreamContext = {
-    event: StreamProgressEvent;
-    options: CombinedCallApiExtraOptions;
-    request: CallApiRequestOptionsForHooks;
-    response: Response;
-};
 declare global {
     interface ReadableStream<R> {
         [Symbol.asyncIterator]: () => AsyncIterableIterator<R>;
@@ -236,13 +304,9 @@ declare global {
 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;
+type PluginInitContext<TMoreOptions = DefaultMoreOptions> = Prettify<SharedHookContext & WithMoreOptions<TMoreOptions> & {
     initURL: InitURL | undefined;
-    options: CombinedCallApiExtraOptions;
-    request: CallApiRequestOptionsForHooks;
-};
+}>;
 type PluginInitResult = Partial<Omit<PluginInitContext, "request"> & {
     request: CallApiRequestOptions;
 }>;
@@ -258,7 +322,7 @@ interface CallApiPlugin<TData = never, TErrorData = never> {
     /**
      * Hooks / Interceptors for the plugin
      */
-    hooks?: InterceptorsOrInterceptorArray<TData, TErrorData>;
+    hooks?: hooksOrHooksArray<TData, TErrorData>;
     /**
      *  A unique id for the plugin
      */
@@ -279,10 +343,160 @@ interface CallApiPlugin<TData = never, TErrorData = never> {
 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 WithMoreOptions<TMoreOptions = DefaultMoreOptions> = {
+    options: CombinedCallApiExtraOptions & Partial<TMoreOptions>;
+};
+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 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 = {
+    /**
+     * Config object passed to createFetchClient
+     */
+    baseConfig: BaseCallApiExtraOptions & CallApiRequestOptions;
+    /**
+     * Config object passed to the callApi instance
+     */
+    config: CallApiExtraOptions & CallApiRequestOptions;
+    /**
+     * Merged options consisting of extra options from createFetchClient, the callApi instance and default options.
+     *
+     */
+    options: CombinedCallApiExtraOptions;
+    /**
+     * Merged request consisting of request options from createFetchClient, the callApi instance and default request options.
+     */
+    request: CallApiRequestOptionsForHooks;
+};
+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;
+    requestInstance: Request;
+}>>;
+type ResponseStreamContext = UnmaskType<Prettify<SharedHookContext & {
+    event: StreamProgressEvent;
+    response: Response;
+}>>;
+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;
+    /**
+     * Number of allowed retry attempts on HTTP errors
+     * @default 0
+     */
+    retryAttempts?: number;
+    /**
+     * Callback whose return value determines if a request should be retried or not
+     */
+    retryCondition?: RetryCondition<TErrorData>;
+    /**
+     * Delay between retries in milliseconds
+     * @default 1000
+     */
+    retryDelay?: number;
+    /**
+     * Maximum delay in milliseconds. Only applies to exponential strategy
+     * @default 10000
+     */
+    retryMaxDelay?: number;
+    /**
+     * HTTP methods that are allowed to retry
+     * @default ["GET", "POST"]
+     */
+    retryMethods?: Method[];
+    /**
+     * HTTP status codes that trigger a retry
+     * @default [409, 425, 429, 500, 502, 503, 504]
+     */
+    retryStatusCodes?: Array<409 | 425 | 429 | 500 | 502 | 503 | 504 | AnyNumber>;
+    /**
+     * Strategy to use when retrying
+     * @default "linear"
+     */
+    retryStrategy?: "exponential" | "linear";
+}
 type ModifiedRequestInit = RequestInit & {
-    duplex?: "full" | "half" | "none";
+    duplex?: "half";
 };
-declare const fetchSpecificKeys: ("body" | "cache" | "credentials" | "headers" | "integrity" | "keepalive" | "method" | "mode" | "priority" | "redirect" | "referrer" | "referrerPolicy" | "signal" | "window" | "duplex")[];
+declare const fetchSpecificKeys: (keyof RequestInit | "duplex")[];
 declare const getDefaultOptions: () => {
     baseURL: string;
     bodySerializer: {
@@ -374,55 +588,10 @@ type ResultModeOption<TErrorData, TResultMode extends ResultModeUnion> = TErrorD
 };
 type FetchSpecificKeysUnion = Exclude<(typeof fetchSpecificKeys)[number], "body" | "headers" | "method">;
-type CallApiRequestOptions<TSchemas extends CallApiSchemas = DefaultMoreOptions> = BodyOption<TSchemas> & HeadersOption<TSchemas> & MethodOption<TSchemas> & Pick<ModifiedRequestInit, FetchSpecificKeysUnion>;
+type CallApiRequestOptions<TSchemas extends CallApiSchemas = DefaultMoreOptions> = Prettify<BodyOption<TSchemas> & HeadersOption<TSchemas> & MethodOption<TSchemas> & Pick<ModifiedRequestInit, FetchSpecificKeysUnion>>;
 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> = {
     /**
@@ -469,7 +638,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;
     };
@@ -478,15 +647,15 @@ 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
-     * @default "mainHooksLast"
+     * - Controls what order in which the composed hooks execute
+     * @default "mainHooksAfterPlugins"
      */
     mergedHooksExecutionOrder?: "mainHooksAfterPlugins" | "mainHooksBeforePlugins";
     /**
@@ -494,7 +663,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>>;
     /**
@@ -526,27 +695,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>> & 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>;
+type ResolvedHooks = Hooks;
+type CombinedCallApiExtraOptions = CombinedExtraOptionsWithoutHooks & ResolvedHooks;
 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;
@@ -557,63 +743,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;
@@ -642,20 +771,4 @@ 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 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 CallApiResultErrorVariant as A, type BaseCallApiConfig as B, type CallApiPlugin as C, type DefaultPluginArray as D, type ErrorContext as E, type CallApiResultSuccessVariant as F, type CombinedCallApiExtraOptions as G, HTTPError as H, type InferSchemaResult as I, type Register as J, 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, getDefaultOptions as j, type RetryOptions as k, type PossibleHTTPError as l, type PossibleJavaScriptError as m, type Hooks as n, type hooksOrHooksArray as o, type RequestContext as p, type RequestErrorContext as q, type RequestStreamContext as r, type ResponseContext as s, type ResponseErrorContext as t, type ResponseStreamContext as u, type SuccessContext as v, type BaseCallApiExtraOptions as w, type CallApiExtraOptions as x, type CallApiRequestOptions as y, type CallApiRequestOptionsForHooks as z };