@zayne-labs/callapi 1.6.11 → 1.6.14

package/dist/esm/common-B_9jiZXC.d.ts

@@ -0,0 +1,551 @@
+import { StandardSchemaV1 } from '@standard-schema/spec';
+
+type ValueOrFunctionResult<TValue> = TValue | (() => TValue);
+/**
+ * Bearer Or Token authentication
+ *
+ * The value of `bearer` will be added to a header as
+ * `auth: Bearer some-auth-token`,
+ *
+ * The value of `token` will be added to a header as
+ * `auth: Token some-auth-token`,
+ */
+type BearerOrTokenAuth = {
+    type?: "Bearer";
+    bearer?: ValueOrFunctionResult<string | null>;
+    token?: never;
+} | {
+    type?: "Token";
+    bearer?: never;
+    token?: ValueOrFunctionResult<string | null>;
+};
+/**
+ * Basic auth
+ */
+type BasicAuth = {
+    type: "Basic";
+    username: ValueOrFunctionResult<string | null | undefined>;
+    password: ValueOrFunctionResult<string | null | undefined>;
+};
+/**
+ * Custom auth
+ *
+ * @param prefix - prefix of the header
+ * @param authValue - value of the header
+ *
+ * @example
+ * ```ts
+ * {
+ *  type: "Custom",
+ *  prefix: "Token",
+ *  authValue: "token"
+ * }
+ * ```
+ */
+type CustomAuth = {
+    type: "Custom";
+    prefix: ValueOrFunctionResult<string | null | undefined>;
+    value: ValueOrFunctionResult<string | null | undefined>;
+};
+type Auth = BearerOrTokenAuth | BasicAuth | CustomAuth;
+
+type AnyString = string & {
+    z_placeholder?: never;
+};
+type AnyNumber = number & {
+    z_placeholder?: never;
+};
+type AnyFunction<TResult = unknown> = (...args: any) => TResult;
+type UnmaskType<TValue> = {
+    _: TValue;
+}["_"];
+type Awaitable<TValue> = Promise<TValue> | TValue;
+type CommonRequestHeaders = "Access-Control-Allow-Credentials" | "Access-Control-Allow-Headers" | "Access-Control-Allow-Methods" | "Access-Control-Allow-Origin" | "Access-Control-Expose-Headers" | "Access-Control-Max-Age" | "Age" | "Allow" | "Cache-Control" | "Clear-Site-Data" | "Content-Disposition" | "Content-Encoding" | "Content-Language" | "Content-Length" | "Content-Location" | "Content-Range" | "Content-Security-Policy-Report-Only" | "Content-Security-Policy" | "Cookie" | "Cross-Origin-Embedder-Policy" | "Cross-Origin-Opener-Policy" | "Cross-Origin-Resource-Policy" | "Date" | "ETag" | "Expires" | "Last-Modified" | "Location" | "Permissions-Policy" | "Pragma" | "Retry-After" | "Save-Data" | "Sec-CH-Prefers-Color-Scheme" | "Sec-CH-Prefers-Reduced-Motion" | "Sec-CH-UA-Arch" | "Sec-CH-UA-Bitness" | "Sec-CH-UA-Form-Factor" | "Sec-CH-UA-Full-Version-List" | "Sec-CH-UA-Full-Version" | "Sec-CH-UA-Mobile" | "Sec-CH-UA-Model" | "Sec-CH-UA-Platform-Version" | "Sec-CH-UA-Platform" | "Sec-CH-UA-WoW64" | "Sec-CH-UA" | "Sec-Fetch-Dest" | "Sec-Fetch-Mode" | "Sec-Fetch-Site" | "Sec-Fetch-User" | "Sec-GPC" | "Server-Timing" | "Server" | "Service-Worker-Navigation-Preload" | "Set-Cookie" | "Strict-Transport-Security" | "Timing-Allow-Origin" | "Trailer" | "Transfer-Encoding" | "Upgrade" | "Vary" | "Warning" | "WWW-Authenticate" | "X-Content-Type-Options" | "X-DNS-Prefetch-Control" | "X-Frame-Options" | "X-Permitted-Cross-Domain-Policies" | "X-Powered-By" | "X-Robots-Tag" | "X-XSS-Protection" | AnyString;
+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;
+    /**
+     *  The schema to use for validating the response error data.
+     */
+    errorData?: StandardSchemaV1;
+    /**
+     *  The schema to use for validating the request headers.
+     */
+    headers?: StandardSchemaV1<Headers>;
+    /**
+     *  The schema to use for validating the request url.
+     */
+    initURL?: StandardSchemaV1<InitURL>;
+    /**
+     *  The schema to use for validating the meta option.
+     */
+    meta?: StandardSchemaV1<GlobalMeta>;
+    /**
+     *  The schema to use for validating the request method.
+     */
+    method?: StandardSchemaV1<Method>;
+    /**
+     *  The schema to use for validating the request url parameter.
+     */
+    params?: StandardSchemaV1<Params>;
+    /**
+     *  The schema to use for validating the request url querys.
+     */
+    query?: StandardSchemaV1<Query>;
+}
+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 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>) => boolean | Promise<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>;
+    blob: () => Promise<Blob>;
+    formData: () => Promise<FormData>;
+    json: () => Promise<TResponse>;
+    stream: () => ReadableStream<Uint8Array<ArrayBufferLike>> | null;
+    text: () => Promise<string>;
+};
+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 GetResponseType<TResponse, TResponseType extends ResponseTypeUnion, TComputedMap extends ResponseTypeMap<TResponse> = ResponseTypeMap<TResponse>> = undefined extends TResponseType ? TComputedMap["json"] : TResponseType extends NonNullable<ResponseTypeUnion> ? TComputedMap[TResponseType] : never;
+
+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> & {
+    initURL: InitURL | undefined;
+    options: CombinedCallApiExtraOptions;
+    request: CallApiRequestOptionsForHooks;
+};
+type PluginInitResult = Partial<Omit<PluginInitContext, "request"> & {
+    request: CallApiRequestOptions;
+}>;
+interface CallApiPlugin<TData = never, TErrorData = never> {
+    /**
+     * Defines additional options that can be passed to callApi
+     */
+    createExtraOptions?: (...params: never[]) => unknown;
+    /**
+     * A description for the plugin
+     */
+    description?: string;
+    /**
+     * Hooks / Interceptors for the plugin
+     */
+    hooks?: InterceptorsOrInterceptorArray<TData, TErrorData>;
+    /**
+     *  A unique id for the plugin
+     */
+    id: string;
+    /**
+     * A function that will be called when the plugin is initialized. This will be called before the any of the other internal functions.
+     */
+    init?: (context: PluginInitContext) => Awaitable<PluginInitResult> | Awaitable<void>;
+    /**
+     * A name for the plugin
+     */
+    name: string;
+    /**
+     *  A version for the plugin
+     */
+    version?: string;
+}
+declare const definePlugin: <TPlugin extends CallApiPlugin | AnyFunction<CallApiPlugin>>(plugin: TPlugin) => TPlugin;
+type Plugins<TPluginArray extends CallApiPlugin[]> = TPluginArray | ((context: PluginInitContext) => TPluginArray);
+
+declare const fetchSpecificKeys: ("body" | "cache" | "credentials" | "headers" | "integrity" | "keepalive" | "method" | "mode" | "priority" | "redirect" | "referrer" | "referrerPolicy" | "signal" | "window")[];
+declare const defaultRetryMethods: ("GET" | "POST")[];
+declare const defaultRetryStatusCodes: Required<BaseCallApiExtraOptions>["retryStatusCodes"];
+
+/**
+ * @description Makes a type required if TSchema type is undefined or if the output type of TSchema contains undefined, otherwise keeps it as is
+ */
+type MakeSchemaOptionRequired<TSchema extends StandardSchemaV1 | undefined, TObject> = undefined extends TSchema ? TObject : undefined extends InferSchemaResult<TSchema, NonNullable<unknown>> ? TObject : Required<TObject>;
+type Body = UnmaskType<Record<string, unknown> | RequestInit["body"]>;
+type BodyOption<TSchemas extends CallApiSchemas> = MakeSchemaOptionRequired<TSchemas["body"], {
+    /**
+     * Body of the request, can be a object or any other supported body type.
+     */
+    body?: InferSchemaResult<TSchemas["body"], Body>;
+}>;
+type Method = UnmaskType<"CONNECT" | "DELETE" | "GET" | "HEAD" | "OPTIONS" | "PATCH" | "POST" | "PUT" | "TRACE" | AnyString>;
+type MethodOption<TSchemas extends CallApiSchemas> = MakeSchemaOptionRequired<TSchemas["method"], {
+    /**
+     * HTTP method for the request.
+     * @default "GET"
+     */
+    method?: InferSchemaResult<TSchemas["method"], Method>;
+}>;
+type Headers = UnmaskType<Record<"Authorization", CommonAuthorizationHeaders> | Record<"Content-Type", CommonContentTypes> | Record<CommonRequestHeaders, string | undefined> | Record<string, string | undefined> | RequestInit["headers"]>;
+type HeadersOption<TSchemas extends CallApiSchemas> = MakeSchemaOptionRequired<TSchemas["headers"], {
+    /**
+     * Headers to be used in the request.
+     */
+    headers?: InferSchemaResult<TSchemas["headers"], Headers>;
+}>;
+interface Register {
+}
+type GlobalMeta = Register extends {
+    meta?: infer TMeta extends Record<string, unknown>;
+} ? TMeta : never;
+type MetaOption<TSchemas extends CallApiSchemas> = {
+    /**
+     * - An optional field you can fill with additional information,
+     * to associate with the request, typically used for logging or tracing.
+     *
+     * - A good use case for this, would be to use the info to handle specific cases in any of the shared interceptors.
+     *
+     * @example
+     * ```ts
+     * const callMainApi = callApi.create({
+     * 	baseURL: "https://main-api.com",
+     * 	onResponseError: ({ response, options }) => {
+     * 		if (options.meta?.userId) {
+     * 			console.error(`User ${options.meta.userId} made an error`);
+     * 		}
+     * 	},
+     * });
+     *
+     * const response = await callMainApi({
+     * 	url: "https://example.com/api/data",
+     * 	meta: { userId: "123" },
+     * });
+     * ```
+     */
+    meta?: InferSchemaResult<TSchemas["meta"], GlobalMeta>;
+};
+type ResultModeOption<TErrorData, TResultMode extends ResultModeUnion> = TErrorData extends false ? {
+    resultMode: "onlySuccessWithException";
+} : TErrorData extends false | undefined ? {
+    resultMode?: "onlySuccessWithException";
+} : undefined extends TResultMode ? {
+    resultMode?: TResultMode;
+} : {
+    resultMode: TResultMode;
+};
+
+type FetchSpecificKeysUnion = Exclude<(typeof fetchSpecificKeys)[number], "body" | "headers" | "method">;
+type CallApiRequestOptions<TSchemas extends CallApiSchemas = DefaultMoreOptions> = BodyOption<TSchemas> & HeadersOption<TSchemas> & MethodOption<TSchemas> & Pick<RequestInit, 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 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 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, TSchemas extends CallApiSchemas = DefaultMoreOptions, TPluginArray extends CallApiPlugin[] = DefaultPluginArray> = {
+    /**
+     * Authorization header value.
+     */
+    auth?: string | Auth | null;
+    /**
+     * Base URL to be prepended to all request URLs
+     */
+    baseURL?: string;
+    /**
+     * Custom function to serialize the body object into a string.
+     */
+    bodySerializer?: (bodyData: Record<string, unknown>) => string;
+    /**
+     * Whether or not to clone the response, so response.json() and the like, can be read again else where.
+     * @see https://developer.mozilla.org/en-US/docs/Web/API/Response/clone
+     * @default false
+     */
+    cloneResponse?: boolean;
+    /**
+     * Custom fetch implementation
+     */
+    customFetchImpl?: FetchImpl;
+    /**
+     * Custom request key to be used to identify a request in the fetch deduplication strategy.
+     * @default the full request url + string formed from the request options
+     */
+    dedupeKey?: string;
+    /**
+     * Defines the deduplication strategy for the request, can be set to "none" | "defer" | "cancel".
+     * - If set to "cancel", the previous pending request with the same request key will be cancelled and lets the new request through.
+     * - If set to "defer", all new request with the same request key will be share the same response, until the previous one is completed.
+     * - If set to "none", deduplication is disabled.
+     * @default "cancel"
+     */
+    dedupeStrategy?: "cancel" | "defer" | "none";
+    /**
+     * Default error message to use if none is provided from a response.
+     * @default "Failed to fetch data from server!"
+     */
+    defaultErrorMessage?: string;
+    /**
+     * Resolved request URL
+     */
+    readonly fullURL?: string;
+    /**
+     * Defines the mode in which the merged hooks are executed, can be set to "parallel" | "sequential".
+     * - 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"
+     */
+    mergedHooksExecutionOrder?: "mainHooksAfterPlugins" | "mainHooksBeforePlugins";
+    /**
+     * An array of CallApi plugins. It allows you to extend the behavior of the library.
+     */
+    plugins?: Plugins<TPluginArray>;
+    /**
+     * Custom function to parse the response string into a object.
+     */
+    responseParser?: (responseString: string) => Awaitable<Record<string, unknown>>;
+    /**
+     * Expected response type, affects how response is parsed
+     * @default "json"
+     */
+    responseType?: TResponseType;
+    /**
+     * Mode of the result, can influence how results are handled or returned.
+     * Can be set to "all" | "onlySuccess" | "onlyError" | "onlyResponse".
+     * @default "all"
+     */
+    resultMode?: TResultMode;
+    /**
+     * Type-safe schemas for the response validation.
+     */
+    schemas?: TSchemas;
+    /**
+     * If true or the function returns true, throws errors instead of returning them
+     * The function is passed the error object and can be used to conditionally throw the error
+     * @default false
+     */
+    throwOnError?: TThrowOnError | ((context: ErrorContext<TErrorData>) => TThrowOnError);
+    /**
+     * Request timeout in milliseconds
+     */
+    timeout?: number;
+    /**
+     * 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")[];
+type CallApiExtraOptions<TData = DefaultDataType, TErrorData = DefaultDataType, TResultMode extends ResultModeUnion = ResultModeUnion, TThrowOnError extends boolean = DefaultThrowOnError, TResponseType extends ResponseTypeUnion = ResponseTypeUnion, TSchemas extends CallApiSchemas = DefaultMoreOptions, TPluginArray extends CallApiPlugin[] = DefaultPluginArray> = CallApiRequestOptions<TSchemas> & ExtraOptions<TData, TErrorData, TResultMode, TThrowOnError, TResponseType, TSchemas, TPluginArray> & {
+    /**
+     * Options that should extend the base options.
+     */
+    extend?: Pick<ExtraOptions<TData, TErrorData, TResultMode, TThrowOnError, TResponseType, TSchemas, TPluginArray>, (typeof optionsEnumToExtendFromBase)[number]>;
+};
+declare const optionsEnumToOmitFromBase: ("dedupeKey" | "extend")[];
+type BaseCallApiExtraOptions<TBaseData = DefaultDataType, TBaseErrorData = DefaultDataType, TBaseResultMode extends ResultModeUnion = ResultModeUnion, TBaseThrowOnError extends boolean = DefaultThrowOnError, TBaseResponseType extends ResponseTypeUnion = ResponseTypeUnion, TBaseSchemas extends CallApiSchemas = DefaultMoreOptions, TBasePluginArray extends CallApiPlugin[] = DefaultPluginArray> = Omit<Partial<CallApiExtraOptions<TBaseData, TBaseErrorData, TBaseResultMode, TBaseThrowOnError, TBaseResponseType, TBaseSchemas, TBasePluginArray>>, (typeof optionsEnumToOmitFromBase)[number]>;
+type CombinedCallApiExtraOptions = BaseCallApiExtraOptions & CallApiExtraOptions;
+type CallApiParameters<TData = DefaultDataType, TErrorData = DefaultDataType, TResultMode extends ResultModeUnion = ResultModeUnion, TThrowOnError extends boolean = DefaultThrowOnError, TResponseType extends ResponseTypeUnion = ResponseTypeUnion, TSchemas extends CallApiSchemas = DefaultMoreOptions, TPluginArray extends CallApiPlugin[] = DefaultPluginArray> = [
+    initURL: InferSchemaResult<TSchemas["initURL"], InitURL>,
+    config?: CallApiExtraOptions<TData, TErrorData, TResultMode, TThrowOnError, TResponseType, TSchemas, TPluginArray>
+];
+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;
+    response: Response;
+};
+type CallApiResultErrorVariant<TErrorData> = {
+    data: null;
+    error: PossibleHTTPError<TErrorData>;
+    response: Response;
+} | {
+    data: null;
+    error: PossibleJavaScriptError;
+    response: null;
+};
+type ResultModeMap<TData = DefaultDataType, TErrorData = DefaultDataType, TResponseType extends ResponseTypeUnion = ResponseTypeUnion, TComputedData = GetResponseType<TData, TResponseType>, TComputedErrorData = GetResponseType<TErrorData, TResponseType>> = UnmaskType<{
+    all: CallApiResultSuccessVariant<TComputedData> | CallApiResultErrorVariant<TComputedErrorData>;
+    allWithException: CallApiResultSuccessVariant<TComputedData>;
+    allWithoutResponse: CallApiResultSuccessVariant<TComputedData>["data" | "error"] | CallApiResultErrorVariant<TComputedErrorData>["data" | "error"];
+    onlyError: CallApiResultSuccessVariant<TComputedData>["error"] | CallApiResultErrorVariant<TComputedErrorData>["error"];
+    onlyResponse: CallApiResultErrorVariant<TComputedErrorData>["response"] | CallApiResultSuccessVariant<TComputedData>["response"];
+    onlyResponseWithException: CallApiResultSuccessVariant<TComputedErrorData>["response"];
+    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> ? ResultModeMap<TData, TErrorData, TResponseType>[TResultMode] : never;
+
+export { type BaseCallApiExtraOptions as B, type CallApiSchemas as C, type DefaultPluginArray as D, type ErrorContext as E, type GetCallApiResult as G, type InferSchemaResult as I, type PluginInitContext as P, type ResultModeUnion as R, type SuccessContext as S, type ResponseTypeUnion as a, type CallApiPlugin as b, type CallApiExtraOptions as c, type DefaultDataType as d, type DefaultThrowOnError as e, type DefaultMoreOptions as f, definePlugin as g, type PossibleJavaScriptError as h, type PossibleHTTPError as i, type CallApiParameters as j, type CallApiRequestOptions as k, type CallApiRequestOptionsForHooks as l, type CallApiResultErrorVariant as m, type CallApiResultSuccessVariant as n, type CombinedCallApiExtraOptions as o, type Interceptors as p, type InterceptorsOrInterceptorArray as q, type PossibleJavascriptErrorNames as r, type Register as s, type RequestContext as t, type RequestErrorContext as u, type ResponseContext as v, type ResponseErrorContext as w, type InitURL as x, defaultRetryMethods as y, defaultRetryStatusCodes as z };

package/dist/esm/error-lBRMiMeF.d.ts

@@ -0,0 +1,17 @@
+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 { HTTPError as H };

package/dist/esm/index.d.ts

@@ -0,0 +1,18 @@
+import { R as ResultModeUnion, a as ResponseTypeUnion, C as CallApiSchemas, b as CallApiPlugin, D as DefaultPluginArray, I as InferSchemaResult, c as CallApiExtraOptions, G as GetCallApiResult, B as BaseCallApiExtraOptions, d as DefaultDataType, e as DefaultThrowOnError, f as DefaultMoreOptions } from './common-B_9jiZXC.js';
+export { j as CallApiParameters, k as CallApiRequestOptions, l as CallApiRequestOptionsForHooks, m as CallApiResultErrorVariant, n as CallApiResultSuccessVariant, o as CombinedCallApiExtraOptions, E as ErrorContext, p as Interceptors, q as InterceptorsOrInterceptorArray, P as PluginInitContext, i as PossibleHTTPError, h as PossibleJavaScriptError, r as PossibleJavascriptErrorNames, s as Register, t as RequestContext, u as RequestErrorContext, v as ResponseContext, w as ResponseErrorContext, S as SuccessContext, g as definePlugin } from './common-B_9jiZXC.js';
+export { H as HTTPError } from './error-lBRMiMeF.js';
+import '@standard-schema/spec';
+
+declare const createFetchClient: <TBaseData = DefaultDataType, TBaseErrorData = DefaultDataType, TBaseResultMode extends ResultModeUnion = ResultModeUnion, TBaseThrowOnError extends boolean = DefaultThrowOnError, TBaseResponseType extends ResponseTypeUnion = ResponseTypeUnion, TBaseSchemas extends CallApiSchemas = DefaultMoreOptions, TBasePluginArray extends CallApiPlugin[] = DefaultPluginArray, TBaseComputedData = InferSchemaResult<TBaseSchemas["data"], TBaseData>, TBaseComputedErrorData = InferSchemaResult<TBaseSchemas["errorData"], TBaseErrorData>>(baseConfig?: BaseCallApiExtraOptions<TBaseData, TBaseErrorData, TBaseResultMode, TBaseThrowOnError, TBaseResponseType, TBaseSchemas, TBasePluginArray>) => {
+    <TData = TBaseComputedData, TErrorData = TBaseComputedErrorData, TResultMode extends ResultModeUnion = TBaseResultMode, TThrowOnError extends boolean = TBaseThrowOnError, TResponseType extends ResponseTypeUnion = TBaseResponseType, TSchemas extends CallApiSchemas = TBaseSchemas, TPluginArray extends CallApiPlugin[] = TBasePluginArray, TComputedData = InferSchemaResult<TSchemas["data"], TData>, TComputedErrorData = InferSchemaResult<TSchemas["errorData"], TErrorData>>(initURL: InferSchemaResult<TSchemas["initURL"], string | URL>, config?: CallApiExtraOptions<TData, TErrorData, TResultMode, TThrowOnError, TResponseType, TSchemas, TPluginArray> | undefined): Promise<GetCallApiResult<TComputedData, TComputedErrorData, TResultMode, TThrowOnError, TResponseType>>;
+    create: <TBaseData = unknown, TBaseErrorData = unknown, TBaseResultMode extends ResultModeUnion = ResultModeUnion, TBaseThrowOnError extends boolean = boolean, TBaseResponseType extends ResponseTypeUnion = ResponseTypeUnion, TBaseSchemas extends CallApiSchemas = {}, TBasePluginArray extends CallApiPlugin[] = DefaultPluginArray, TBaseComputedData = InferSchemaResult<TBaseSchemas["data"], TBaseData>, TBaseComputedErrorData = InferSchemaResult<TBaseSchemas["errorData"], TBaseErrorData>>(baseConfig?: BaseCallApiExtraOptions<TBaseData, TBaseErrorData, TBaseResultMode, TBaseThrowOnError, TBaseResponseType, TBaseSchemas, TBasePluginArray>) => /*elided*/ any;
+};
+declare const callApi: {
+    <TData = unknown, TErrorData = unknown, TResultMode extends ResultModeUnion = ResultModeUnion, TThrowOnError extends boolean = boolean, TResponseType extends ResponseTypeUnion = ResponseTypeUnion, TSchemas extends CallApiSchemas = {}, TPluginArray extends CallApiPlugin[] = DefaultPluginArray, TComputedData = InferSchemaResult<TSchemas["data"], TData>, TComputedErrorData = InferSchemaResult<TSchemas["errorData"], TErrorData>>(initURL: InferSchemaResult<TSchemas["initURL"], string | URL>, config?: CallApiExtraOptions<TData, TErrorData, TResultMode, TThrowOnError, TResponseType, TSchemas, TPluginArray> | undefined): Promise<GetCallApiResult<TComputedData, TComputedErrorData, TResultMode, TThrowOnError, TResponseType>>;
+    create: <TBaseData = unknown, TBaseErrorData = unknown, TBaseResultMode extends ResultModeUnion = ResultModeUnion, TBaseThrowOnError extends boolean = boolean, TBaseResponseType extends ResponseTypeUnion = ResponseTypeUnion, TBaseSchemas extends CallApiSchemas = {}, TBasePluginArray extends CallApiPlugin[] = DefaultPluginArray, TBaseComputedData = InferSchemaResult<TBaseSchemas["data"], TBaseData>, TBaseComputedErrorData = InferSchemaResult<TBaseSchemas["errorData"], TBaseErrorData>>(baseConfig?: BaseCallApiExtraOptions<TBaseData, TBaseErrorData, TBaseResultMode, TBaseThrowOnError, TBaseResponseType, TBaseSchemas, TBasePluginArray>) => {
+        <TData = TBaseComputedData, TErrorData = TBaseComputedErrorData, TResultMode extends ResultModeUnion = TBaseResultMode, TThrowOnError extends boolean = TBaseThrowOnError, TResponseType extends ResponseTypeUnion = TBaseResponseType, TSchemas extends CallApiSchemas = TBaseSchemas, TPluginArray extends CallApiPlugin[] = TBasePluginArray, TComputedData = InferSchemaResult<TSchemas["data"], TData>, TComputedErrorData = InferSchemaResult<TSchemas["errorData"], TErrorData>>(initURL: InferSchemaResult<TSchemas["initURL"], string | URL>, config?: CallApiExtraOptions<TData, TErrorData, TResultMode, TThrowOnError, TResponseType, TSchemas, TPluginArray> | undefined): Promise<GetCallApiResult<TComputedData, TComputedErrorData, TResultMode, TThrowOnError, TResponseType>>;
+        create: /*elided*/ any;
+    };
+};
+
+export { BaseCallApiExtraOptions, CallApiExtraOptions, CallApiPlugin, CallApiSchemas, InferSchemaResult, ResultModeUnion, callApi, createFetchClient };

package/dist/esm/index.js

@@ -0,0 +1 @@
+export{callApi,createFetchClient,definePlugin}from"./chunk-DQY5GNZB.js";export{HTTPError}from"./chunk-MOMG57MZ.js";//# sourceMappingURL=index.js.map

package/dist/esm/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"index.js"}

package/dist/esm/options/index.d.ts

@@ -0,0 +1,25 @@
+import { d as DefaultDataType, R as ResultModeUnion, a as ResponseTypeUnion, C as CallApiSchemas, b as CallApiPlugin, D as DefaultPluginArray, c as CallApiExtraOptions, I as InferSchemaResult, x as InitURL, G as GetCallApiResult, B as BaseCallApiExtraOptions, e as DefaultThrowOnError, f as DefaultMoreOptions } from '../common-B_9jiZXC.js';
+import '@standard-schema/spec';
+
+type CallApiExtraOptionsWithRequiredURL<TData = DefaultDataType, TErrorData = DefaultDataType, TResultMode extends ResultModeUnion = ResultModeUnion, TThrowOnError extends boolean = boolean, TResponseType extends ResponseTypeUnion = ResponseTypeUnion, TSchemas extends CallApiSchemas = CallApiSchemas, TPluginArray extends CallApiPlugin[] = DefaultPluginArray> = Omit<CallApiExtraOptions<TData, TErrorData, TResultMode, TThrowOnError, TResponseType, TSchemas, TPluginArray>, "initURL"> & {
+    initURL: InferSchemaResult<TSchemas["initURL"], InitURL>;
+};
+
+declare const createFetchClientWithOptions: <TBaseData = DefaultDataType, TBaseErrorData = DefaultDataType, TBaseResultMode extends ResultModeUnion = ResultModeUnion, TBaseThrowOnError extends boolean = DefaultThrowOnError, TBaseResponseType extends ResponseTypeUnion = ResponseTypeUnion, TBaseSchemas extends CallApiSchemas = DefaultMoreOptions, TBasePluginArray extends CallApiPlugin[] = DefaultPluginArray, TBaseComputedData = InferSchemaResult<TBaseSchemas["data"], TBaseData>, TBaseComputedErrorData = InferSchemaResult<TBaseSchemas["errorData"], TBaseErrorData>>(baseConfig?: BaseCallApiExtraOptions<TBaseData, TBaseErrorData, TBaseResultMode, TBaseThrowOnError, TBaseResponseType, TBaseSchemas, TBasePluginArray>) => {
+    <TData = TBaseComputedData, TErrorData = TBaseComputedErrorData, TResultMode extends ResultModeUnion = TBaseResultMode, TThrowOnError extends boolean = TBaseThrowOnError, TResponseType extends ResponseTypeUnion = TBaseResponseType, TSchemas extends CallApiSchemas = TBaseSchemas, TPluginArray extends CallApiPlugin[] = TBasePluginArray, TComputedData = InferSchemaResult<TSchemas["data"], TData>, TComputedErrorData = InferSchemaResult<TSchemas["errorData"], TErrorData>>(config: CallApiExtraOptionsWithRequiredURL<TData, TErrorData, TResultMode, TThrowOnError, TResponseType, TSchemas, TPluginArray>): Promise<GetCallApiResult<TComputedData, TComputedErrorData, TResultMode, TThrowOnError, TResponseType>>;
+    create: <TBaseData_1 = unknown, TBaseErrorData_1 = unknown, TBaseResultMode_1 extends ResultModeUnion = ResultModeUnion, TBaseThrowOnError_1 extends boolean = boolean, TBaseResponseType_1 extends ResponseTypeUnion = ResponseTypeUnion, TBaseSchemas_1 extends CallApiSchemas = {}, TBasePluginArray_1 extends CallApiPlugin[] = DefaultPluginArray, TBaseComputedData_1 = InferSchemaResult<TBaseSchemas_1["data"], TBaseData_1>, TBaseComputedErrorData_1 = InferSchemaResult<TBaseSchemas_1["errorData"], TBaseErrorData_1>>(baseConfig?: BaseCallApiExtraOptions<TBaseData_1, TBaseErrorData_1, TBaseResultMode_1, TBaseThrowOnError_1, TBaseResponseType_1, TBaseSchemas_1, TBasePluginArray_1>) => {
+        <TData = TBaseComputedData_1, TErrorData_1 = TBaseComputedErrorData_1, TResultMode_1 extends ResultModeUnion = TBaseResultMode_1, TThrowOnError_1 extends boolean = TBaseThrowOnError_1, TResponseType_1 extends ResponseTypeUnion = TBaseResponseType_1, TSchemas_1 extends CallApiSchemas = TBaseSchemas_1, TPluginArray_1 extends CallApiPlugin[] = TBasePluginArray_1, TComputedData_1 = InferSchemaResult<TSchemas_1["data"], TData>, TComputedErrorData_1 = InferSchemaResult<TSchemas_1["errorData"], TErrorData_1>>(initURL: InferSchemaResult<TSchemas_1["initURL"], string | URL>, config?: CallApiExtraOptions<TData, TErrorData_1, TResultMode_1, TThrowOnError_1, TResponseType_1, TSchemas_1, TPluginArray_1> | undefined): Promise<GetCallApiResult<TComputedData_1, TComputedErrorData_1, TResultMode_1, TThrowOnError_1, TResponseType_1>>;
+        create: /*elided*/ any;
+    };
+};
+declare const callApiWithOptions: {
+    <TData = unknown, TErrorData = unknown, TResultMode extends ResultModeUnion = ResultModeUnion, TThrowOnError extends boolean = boolean, TResponseType extends ResponseTypeUnion = ResponseTypeUnion, TSchemas extends CallApiSchemas = {}, TPluginArray extends CallApiPlugin[] = DefaultPluginArray, TComputedData = InferSchemaResult<TSchemas["data"], TData>, TComputedErrorData = InferSchemaResult<TSchemas["errorData"], TErrorData>>(config: CallApiExtraOptionsWithRequiredURL<TData, TErrorData, TResultMode, TThrowOnError, TResponseType, TSchemas, TPluginArray>): Promise<GetCallApiResult<TComputedData, TComputedErrorData, TResultMode, TThrowOnError, TResponseType>>;
+    create: <TBaseData = unknown, TBaseErrorData = unknown, TBaseResultMode extends ResultModeUnion = ResultModeUnion, TBaseThrowOnError extends boolean = boolean, TBaseResponseType extends ResponseTypeUnion = ResponseTypeUnion, TBaseSchemas extends CallApiSchemas = {}, TBasePluginArray extends CallApiPlugin[] = DefaultPluginArray, TBaseComputedData = InferSchemaResult<TBaseSchemas["data"], TBaseData>, TBaseComputedErrorData = InferSchemaResult<TBaseSchemas["errorData"], TBaseErrorData>>(baseConfig?: BaseCallApiExtraOptions<TBaseData, TBaseErrorData, TBaseResultMode, TBaseThrowOnError, TBaseResponseType, TBaseSchemas, TBasePluginArray>) => {
+        <TData = TBaseComputedData, TErrorData = TBaseComputedErrorData, TResultMode extends ResultModeUnion = TBaseResultMode, TThrowOnError extends boolean = TBaseThrowOnError, TResponseType extends ResponseTypeUnion = TBaseResponseType, TSchemas extends CallApiSchemas = TBaseSchemas, TPluginArray extends CallApiPlugin[] = TBasePluginArray, TComputedData = InferSchemaResult<TSchemas["data"], TData>, TComputedErrorData = InferSchemaResult<TSchemas["errorData"], TErrorData>>(initURL: InferSchemaResult<TSchemas["initURL"], string | URL>, config?: CallApiExtraOptions<TData, TErrorData, TResultMode, TThrowOnError, TResponseType, TSchemas, TPluginArray> | undefined): Promise<GetCallApiResult<TComputedData, TComputedErrorData, TResultMode, TThrowOnError, TResponseType>>;
+        create: /*elided*/ any;
+    };
+};
+
+declare const defineOptions: <TData = unknown, TErrorData = unknown, TResultMode extends ResultModeUnion = ResultModeUnion>(config: CallApiExtraOptionsWithRequiredURL<TData, TErrorData, TResultMode>) => CallApiExtraOptionsWithRequiredURL<TData, TErrorData, TResultMode>;
+
+export { type CallApiExtraOptionsWithRequiredURL, callApiWithOptions, createFetchClientWithOptions, defineOptions };

package/dist/esm/options/index.js

@@ -0,0 +1 @@
+import{hooksEnum as e,initializePlugins as r,mergeUrlWithParamsAndQuery as t,createTimeoutSignal as o,createCombinedSignal as s,createDedupeStrategy as a,createExtensibleSchemasAndValidators as n,resolveResponseData as i,handleValidation as l,resolveSuccessResult as u,createRetryStrategy as d,createFetchClient as c}from"../chunk-DQY5GNZB.js";import{splitBaseConfig as p,splitConfig as y,combineHooks as h,mergeAndResolveHeaders as f,isPlainObject as m,defaultRetryStatusCodes as w,defaultRetryMethods as g,executeHooks as R,HTTPError as E,resolveErrorResult as M,waitUntil as b,isFunction as q,isHTTPErrorInstance as D}from"../chunk-MOMG57MZ.js";var O=O=>{const[S,k]=p(O??{}),C=new Map,v=async c=>{const{initURL:p}=c,[O,x]=y(c),H={};for(const r of Object.keys(e)){const e=h(k[r],x[r]);H[r]=e}const L={baseURL:"",bodySerializer:JSON.stringify,dedupeStrategy:"cancel",defaultErrorMessage:"Failed to fetch data from server!",mergedHooksExecutionMode:"parallel",mergedHooksExecutionOrder:"mainHooksAfterPlugins",responseType:"json",resultMode:"all",retryAttempts:0,retryDelay:1e3,retryMaxDelay:1e4,retryMethods:g,retryStatusCodes:w,retryStrategy:"linear",...k,...x,...H},U=O.body??S.body,$={...S,...O,body:m(U)?L.bodySerializer(U):U,headers:f({auth:L.auth,baseHeaders:S.headers,body:U,headers:O.headers}),signal:O.signal??S.signal},{resolvedHooks:A,resolvedOptions:j,resolvedRequestOptions:T,url:F}=await r({initURL:p,options:L,request:$}),P=`${j.baseURL}${t(F,j.params,j.query)}`,z={...j,...A,fullURL:P,initURL:p.toString()},G=new AbortController,N=null!=z.timeout?o(z.timeout):null,Z=s(T.signal,N,G.signal),B={...T,signal:Z},{handleRequestCancelStrategy:I,handleRequestDeferStrategy:J,removeDedupeKeyFromCache:K}=await a({$RequestInfoCache:C,newFetchController:G,options:z,request:B});await I();try{await R(z.onRequest({options:z,request:B})),B.headers=f({auth:z.auth,baseHeaders:S.headers,body:U,headers:B.headers});const e=await J(),r="defer"===z.dedupeStrategy||z.cloneResponse,{schemas:t,validators:o}=n(z);if(!e.ok){const s=await i(r?e.clone():e,z.responseType,z.responseParser),a=await l(s,t?.errorData,o?.errorData);throw new E({defaultErrorMessage:z.defaultErrorMessage,errorData:a,response:e})}const s=await i(r?e.clone():e,z.responseType,z.responseParser),a={data:await l(s,t?.data,o?.data),options:z,request:B,response:z.cloneResponse?e.clone():e};return await R(z.onSuccess(a),z.onResponse({...a,error:null})),await u({data:a.data,response:a.response,resultMode:z.resultMode})}catch(e){const{apiDetails:r,getErrorResult:t}=M({cloneResponse:z.cloneResponse,defaultErrorMessage:z.defaultErrorMessage,error:e,resultMode:z.resultMode}),o={error:r.error,options:z,request:B,response:r.response},{getDelay:s,shouldAttemptRetry:a}=d(z,o);if(!Z.aborted&&await a()){await R(z.onRetry(o));const e=s();await b(e);const r={...c,"~retryCount":(z["~retryCount"]??0)+1};return await v(r)}const n=q(z.throwOnError)?z.throwOnError(o):z.throwOnError,i=()=>{if(n)throw r.error};if(D(e))return await R(z.onResponseError(o),z.onError(o),z.onResponse({...o,data:null})),i(),t();if(e instanceof DOMException&&"AbortError"===e.name){const{message:r,name:o}=e;return console.error(`${o}:`,r),i(),t()}if(e instanceof DOMException&&"TimeoutError"===e.name){const r=`Request timed out after ${z.timeout}ms`;return console.error(`${e.name}:`,r),i(),t({message:r})}return await R(z.onRequestError(o),z.onError(o)),i(),t()}finally{K()}};return v.create=c,v},S=O(),k=e=>e;export{S as callApiWithOptions,O as createFetchClientWithOptions,k as defineOptions};//# sourceMappingURL=index.js.map