@zayne-labs/callapi 1.7.2 → 1.7.4

package/dist/esm/{error-By05WYGj.d.ts → common-DiBiESb2.d.ts}

@@ -65,6 +65,34 @@ 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";
+}>;
+
 /**
  * The Standard Schema interface.
  * @see https://github.com/standard-schema/standard-schema
@@ -164,6 +192,24 @@ declare namespace StandardSchemaV1 {
     type InferOutput<Schema extends StandardSchemaV1> = NonNullable<Schema["~standard"]["types"]>["output"];
 }
 
+type Params = UnmaskType<Record<string, boolean | number | string> | Array<boolean | number | string>>;
+type Query = UnmaskType<Record<string, boolean | number | string>>;
+type InitURL = UnmaskType<string | URL>;
+interface UrlOptions<TSchemas extends CallApiSchemas> {
+    /**
+     * URL to be used in the request.
+     */
+    readonly initURL?: string;
+    /**
+     * Parameters to be appended to the URL (i.e: /:id)
+     */
+    params?: InferSchemaResult<TSchemas["params"], Params>;
+    /**
+     * Query parameters to append to the URL.
+     */
+    query?: InferSchemaResult<TSchemas["query"], Query>;
+}
+
 interface CallApiSchemas {
     /**
      *  The schema to use for validating the request body.
@@ -215,72 +261,6 @@ interface CallApiValidators<TData = unknown, TErrorData = unknown> {
 }
 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>>;
-type InitURL = UnmaskType<string | URL>;
-interface UrlOptions<TSchemas extends CallApiSchemas> {
-    /**
-     * URL to be used in the request.
-     */
-    readonly initURL?: string;
-    /**
-     * Parameters to be appended to the URL (i.e: /:id)
-     */
-    params?: InferSchemaResult<TSchemas["params"], Params>;
-    /**
-     * Query parameters to append to the URL.
-     */
-    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;
-    /**
-     * 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 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>;
@@ -315,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>;
@@ -336,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;
 }>;
@@ -358,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
      */
@@ -379,6 +343,156 @@ 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?: "half";
 };
@@ -478,51 +592,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 +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;
     };
@@ -578,14 +647,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 +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>>;
     /**
@@ -626,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;
@@ -657,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;
@@ -742,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 };

package/dist/esm/index.d.ts

@@ -1,7 +1,7 @@
-import { R as ResultModeUnion, a as ResponseTypeUnion, C as CallApiPlugin, D as DefaultPluginArray, b as CallApiSchemas, I as InferSchemaResult, c as CallApiConfig, d as CallApiResult, e as DefaultDataType, f as DefaultThrowOnError, g as DefaultMoreOptions, B as BaseCallApiConfig, h as CallApiParameters } from './error-By05WYGj.js';
-export { l as BaseCallApiExtraOptions, m as CallApiExtraOptions, p as CallApiRequestOptions, q as CallApiRequestOptionsForHooks, r as CallApiResultErrorVariant, s as CallApiResultSuccessVariant, t as CombinedCallApiExtraOptions, E as ErrorContext, H as HTTPError, u as Interceptors, v as InterceptorsOrInterceptorArray, P as PluginInitContext, o as PossibleHTTPError, n as PossibleJavaScriptError, w as PossibleJavascriptErrorNames, x as Register, y as RequestContext, z as RequestErrorContext, A as ResponseContext, F as ResponseErrorContext, k as RetryOptions, S as SuccessContext, i as definePlugin, j as getDefaultOptions } from './error-By05WYGj.js';
+import { R as ResultModeUnion, a as ResponseTypeUnion, C as CallApiPlugin, D as DefaultPluginArray, b as CallApiSchemas, I as InferSchemaResult, c as CallApiConfig, d as CallApiResult, e as DefaultDataType, f as DefaultThrowOnError, g as DefaultMoreOptions, B as BaseCallApiConfig, h as CallApiParameters } from './common-DiBiESb2.js';
+export { w as BaseCallApiExtraOptions, x as CallApiExtraOptions, y as CallApiRequestOptions, z as CallApiRequestOptionsForHooks, A as CallApiResultErrorVariant, F as CallApiResultSuccessVariant, G as CombinedCallApiExtraOptions, E as ErrorContext, H as HTTPError, n as Hooks, P as PluginInitContext, l as PossibleHTTPError, m as PossibleJavaScriptError, J as Register, p as RequestContext, q as RequestErrorContext, r as RequestStreamContext, s as ResponseContext, t as ResponseErrorContext, u as ResponseStreamContext, k as RetryOptions, S as SharedHookContext, v as SuccessContext, i as definePlugin, j as getDefaultOptions, o as hooksOrHooksArray } from './common-DiBiESb2.js';
 
-declare const createFetchClient: <TBaseData = DefaultDataType, TBaseErrorData = DefaultDataType, TBaseResultMode extends ResultModeUnion = ResultModeUnion, TBaseThrowOnError extends boolean = DefaultThrowOnError, TBaseResponseType extends ResponseTypeUnion = ResponseTypeUnion, TBasePluginArray extends CallApiPlugin[] = DefaultPluginArray, TBaseSchemas extends CallApiSchemas = DefaultMoreOptions>(baseConfig?: BaseCallApiConfig<TBaseData, TBaseErrorData, TBaseResultMode, TBaseThrowOnError, TBaseResponseType, TBasePluginArray, TBaseSchemas>) => <TData = InferSchemaResult<TBaseSchemas["data"], TBaseData>, TErrorData = InferSchemaResult<TBaseSchemas["errorData"], TBaseErrorData>, TResultMode extends ResultModeUnion = TBaseResultMode, TThrowOnError extends boolean = TBaseThrowOnError, TResponseType extends ResponseTypeUnion = TBaseResponseType, TPluginArray extends CallApiPlugin[] = TBasePluginArray, TSchemas extends CallApiSchemas = TBaseSchemas>(initURL: InferSchemaResult<TSchemas["initURL"], string | URL>, config?: CallApiConfig<TData, TErrorData, TResultMode, TThrowOnError, TResponseType, TPluginArray, TSchemas> | undefined) => CallApiResult<InferSchemaResult<TSchemas["data"], TData>, InferSchemaResult<TSchemas["errorData"], TErrorData>, TResultMode, TThrowOnError, TResponseType>;
+declare const createFetchClient: <TBaseData = DefaultDataType, TBaseErrorData = DefaultDataType, TBaseResultMode extends ResultModeUnion = ResultModeUnion, TBaseThrowOnError extends boolean = DefaultThrowOnError, TBaseResponseType extends ResponseTypeUnion = ResponseTypeUnion, TBasePluginArray extends CallApiPlugin[] = DefaultPluginArray, TBaseSchemas extends CallApiSchemas = DefaultMoreOptions>(initBaseConfig?: BaseCallApiConfig<TBaseData, TBaseErrorData, TBaseResultMode, TBaseThrowOnError, TBaseResponseType, TBasePluginArray, TBaseSchemas>) => <TData = InferSchemaResult<TBaseSchemas["data"], TBaseData>, TErrorData = InferSchemaResult<TBaseSchemas["errorData"], TBaseErrorData>, TResultMode extends ResultModeUnion = TBaseResultMode, TThrowOnError extends boolean = TBaseThrowOnError, TResponseType extends ResponseTypeUnion = TBaseResponseType, TPluginArray extends CallApiPlugin[] = TBasePluginArray, TSchemas extends CallApiSchemas = TBaseSchemas>(initURL: InferSchemaResult<TSchemas["initURL"], string | URL>, config?: CallApiConfig<TData, TErrorData, TResultMode, TThrowOnError, TResponseType, TPluginArray, TSchemas> | undefined) => CallApiResult<InferSchemaResult<TSchemas["data"], TData>, InferSchemaResult<TSchemas["errorData"], TErrorData>, TResultMode, TThrowOnError, TResponseType>;
 declare const callApi: <TData = unknown, TErrorData = unknown, TResultMode extends ResultModeUnion = ResultModeUnion, TThrowOnError extends boolean = boolean, TResponseType extends ResponseTypeUnion = ResponseTypeUnion, TPluginArray extends CallApiPlugin[] = DefaultPluginArray, TSchemas extends CallApiSchemas = {}>(initURL: InferSchemaResult<TSchemas["initURL"], string | URL>, config?: CallApiConfig<TData, TErrorData, TResultMode, TThrowOnError, TResponseType, TPluginArray, TSchemas> | undefined) => CallApiResult<InferSchemaResult<TSchemas["data"], TData>, InferSchemaResult<TSchemas["errorData"], TErrorData>, TResultMode, TThrowOnError, TResponseType>;
 
 declare const defineParameters: <TData = unknown, TErrorData = unknown, TResultMode extends ResultModeUnion = ResultModeUnion, TThrowOnError extends boolean = DefaultThrowOnError, TResponseType extends ResponseTypeUnion = ResponseTypeUnion, TPluginArray extends CallApiPlugin[] = DefaultPluginArray, TSchemas extends CallApiSchemas = DefaultMoreOptions>(...parameters: CallApiParameters<TData, TErrorData, TResultMode, TThrowOnError, TResponseType, TPluginArray, TSchemas>) => CallApiParameters<TData, TErrorData, TResultMode, TThrowOnError, TResponseType, TPluginArray, TSchemas>;