@zayne-labs/callapi 1.7.18 → 1.8.1

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

@@ -1,774 +0,0 @@
-type AnyString = string & {
-    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;
-}["_"];
-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;
-
-type ValueOrFunctionResult<TValue> = TValue | (() => TValue);
-type ValidAuthValue = ValueOrFunctionResult<Awaitable<string | null | undefined>>;
-/**
- * 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?: ValidAuthValue;
-    token?: never;
-} | {
-    type?: "Token";
-    bearer?: never;
-    token?: ValidAuthValue;
-};
-/**
- * Basic auth
- */
-type BasicAuth = {
-    type: "Basic";
-    username: ValidAuthValue;
-    password: ValidAuthValue;
-};
-/**
- * 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: ValidAuthValue;
-    value: ValidAuthValue;
-};
-type Auth = BearerOrTokenAuth | BasicAuth | CustomAuth;
-
-declare const fetchSpecificKeys: (keyof RequestInit | "duplex")[];
-
-type ErrorDetails<TErrorData> = {
-    defaultErrorMessage: CallApiExtraOptions["defaultErrorMessage"];
-    errorData: TErrorData;
-    response: Response;
-};
-declare class HTTPError<TErrorData = Record<string, unknown>> extends Error {
-    errorData: ErrorDetails<TErrorData>["errorData"];
-    httpErrorSymbol: symbol;
-    isHTTPError: boolean;
-    name: "HTTPError";
-    response: ErrorDetails<TErrorData>["response"];
-    constructor(errorDetails: ErrorDetails<TErrorData>, errorOptions?: ErrorOptions);
-    /**
-     * @description Checks if the given error is an instance of HTTPError
-     * @param error - The error to check
-     * @returns true if the error is an instance of HTTPError, false otherwise
-     */
-    static isError<TErrorData>(error: unknown): error is HTTPError<TErrorData>;
-}
-
-/**
- * The Standard Schema interface.
- * @see https://github.com/standard-schema/standard-schema
- */
-interface StandardSchemaV1<Input = unknown, Output = Input> {
-    /**
-     * The Standard Schema properties.
-     */
-    readonly "~standard": StandardSchemaV1.Props<Input, Output>;
-}
-declare namespace StandardSchemaV1 {
-    /**
-     * The Standard Schema properties interface.
-     */
-    interface Props<Input = unknown, Output = Input> {
-        /**
-         * 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 result interface of the validate function.
-     */
-    type Result<Output> = FailureResult | SuccessResult<Output>;
-    /**
-     * The result interface if validation succeeds.
-     */
-    interface SuccessResult<Output> {
-        /**
-         * The non-existent issues.
-         */
-        readonly issues?: undefined;
-        /**
-         * The typed output value.
-         */
-        readonly value: Output;
-    }
-    /**
-     * The result interface if validation fails.
-     */
-    interface FailureResult {
-        /**
-         * The issues of failed validation.
-         */
-        readonly issues: readonly Issue[];
-    }
-    /**
-     * The issue interface of the failure output.
-     */
-    interface Issue {
-        /**
-         * The error message of the issue.
-         */
-        readonly message: string;
-        /**
-         * The path of the issue, if any.
-         */
-        readonly path?: ReadonlyArray<PathSegment | PropertyKey> | undefined;
-    }
-    /**
-     * The path segment interface of the issue.
-     */
-    interface PathSegment {
-        /**
-         * The key representing a path segment.
-         */
-        readonly key: PropertyKey;
-    }
-    /**
-     * The Standard Schema types interface.
-     */
-    interface Types<Input = unknown, Output = Input> {
-        /** The input type of the schema. */
-        readonly input: Input;
-        /** The output type of the schema. */
-        readonly output: Output;
-    }
-    /**
-     * Infers the input type of a Standard Schema.
-     */
-    type InferInput<Schema extends StandardSchemaV1> = NonNullable<Schema["~standard"]["types"]>["input"];
-    /**
-     * Infers the output type of a Standard Schema.
-     */
-    type InferOutput<Schema extends StandardSchemaV1> = NonNullable<Schema["~standard"]["types"]>["output"];
-}
-
-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 = NonNullable<unknown>> = 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 UnionToIntersection<TUnion> = (TUnion extends unknown ? (param: TUnion) => void : never) extends (param: infer TParam) => void ? TParam : never;
-type InferPluginOptions<TPluginArray extends CallApiPlugin[]> = UnionToIntersection<TPluginArray extends Array<infer TPlugin> ? TPlugin extends CallApiPlugin ? TPlugin["createExtraOptions"] extends AnyFunction<infer TResult> ? InferSchemaResult<TResult, TResult> : NonNullable<unknown> : NonNullable<unknown> : NonNullable<unknown>>;
-type PluginInitContext<TMoreOptions = DefaultMoreOptions> = Prettify<SharedHookContext<TMoreOptions> & {
-    initURL: InitURL | undefined;
-}>;
-type PluginInitResult = Partial<Omit<PluginInitContext, "request"> & {
-    request: CallApiRequestOptions;
-}>;
-type PluginHooksWithMoreOptions<TMoreOptions = DefaultMoreOptions> = HooksOrHooksArray<never, never, TMoreOptions>;
-type PluginHooks<TData = never, TErrorData = never, TMoreOptions = DefaultMoreOptions> = HooksOrHooksArray<TData, TErrorData, TMoreOptions>;
-interface CallApiPlugin {
-    /**
-     * 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?: PluginHooks;
-    /**
-     *  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;
-
-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 | null;
-type ResponseTypeMap<TResponse> = {
-    [Key in keyof InitResponseTypeMap<TResponse>]: Awaited<ReturnType<InitResponseTypeMap<TResponse>[Key]>>;
-};
-type GetResponseType<TResponse, TResponseType extends ResponseTypeUnion, TComputedResponseTypeMap extends ResponseTypeMap<TResponse> = ResponseTypeMap<TResponse>> = null extends TResponseType ? TComputedResponseTypeMap["json"] : TResponseType extends NonNullable<ResponseTypeUnion> ? TComputedResponseTypeMap[TResponseType] : never;
-type CallApiResultSuccessVariant<TData> = {
-    data: TData;
-    error: null;
-    response: Response;
-};
-type PossibleJavaScriptError = UnmaskType<{
-    errorData: PossibleJavaScriptError["originalError"];
-    message: string;
-    name: "AbortError" | "Error" | "SyntaxError" | "TimeoutError" | "TypeError" | (`${string}Error` & {});
-    originalError: DOMException | Error | SyntaxError | TypeError;
-}>;
-type PossibleHTTPError<TErrorData> = Prettify<UnmaskType<{
-    errorData: TErrorData;
-    message: string;
-    name: "HTTPError";
-    originalError: HTTPError;
-}>>;
-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>;
-    onlySuccess: CallApiResultErrorVariant<TComputedErrorData>["data"] | CallApiResultSuccessVariant<TComputedData>["data"];
-    onlySuccessWithException: CallApiResultSuccessVariant<TComputedData>["data"];
-}>;
-type ResultModeUnion = keyof ResultModeMap | null;
-type GetCallApiResult<TData, TErrorData, TResultMode extends ResultModeUnion, TThrowOnError extends boolean, TResponseType extends ResponseTypeUnion> = TErrorData extends false ? ResultModeMap<TData, TErrorData, TResponseType>["onlySuccessWithException"] : TErrorData extends false | undefined ? ResultModeMap<TData, TErrorData, TResponseType>["onlySuccessWithException"] : TErrorData extends false | null ? ResultModeMap<TData, TErrorData, TResponseType>["onlySuccess"] : null 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;
-
-type StreamProgressEvent = {
-    /**
-     * Current chunk of data being streamed
-     */
-    chunk: Uint8Array;
-    /**
-     * Progress in percentage
-     */
-    progress: number;
-    /**
-     * Total size of data in bytes
-     */
-    totalBytes: number;
-    /**
-     * Amount of data transferred so far
-     */
-    transferredBytes: number;
-};
-declare global {
-    interface ReadableStream<R> {
-        [Symbol.asyncIterator]: () => AsyncIterableIterator<R>;
-    }
-}
-
-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: RetryContext<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<TMoreOptions = DefaultMoreOptions> = {
-    /**
-     * 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 & Partial<TMoreOptions>;
-    /**
-     * 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 RetryContext<TErrorData> = UnmaskType<Prettify<ErrorContext<TErrorData> & {
-    retryAttemptCount: number;
-}>>;
-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>;
-type InnerRetryKeys<TErrorData> = Exclude<keyof RetryOptions<TErrorData>, "~retryAttemptCount" | "retry">;
-type InnerRetryOptions<TErrorData> = {
-    [Key in InnerRetryKeys<TErrorData> as Key extends `retry${infer TRest}` ? Uncapitalize<TRest> extends "attempts" ? never : Uncapitalize<TRest> : Key]?: RetryOptions<TErrorData>[Key];
-} & {
-    attempts: NonNullable<RetryOptions<TErrorData>["retryAttempts"]>;
-};
-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 ["~retryAttemptCount"]?: number;
-    /**
-     * All retry options in a single object instead of separate properties
-     */
-    retry?: InnerRetryOptions<TErrorData>;
-    /**
-     * 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 | ((currentAttemptCount: number) => 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
-     */
-    retryStatusCodes?: number[];
-    /**
-     * Strategy to use when retrying
-     * @default "linear"
-     */
-    retryStrategy?: "exponential" | "linear";
-}
-
-/**
- * @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> ? TObject : Required<TObject>;
-type JsonPrimitive = boolean | number | string | null | undefined;
-type SerializableObject = Record<keyof object, unknown>;
-type SerializableArray = Array<JsonPrimitive | SerializableArray | SerializableObject> | ReadonlyArray<JsonPrimitive | SerializableArray | SerializableObject>;
-type Body = UnmaskType<RequestInit["body"] | SerializableArray | SerializableObject>;
-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 ExtractKeys<T, U extends T> = Extract<T, U>;
-type ResultModeOption<TErrorData, TResultMode extends ResultModeUnion> = TErrorData extends false ? {
-    resultMode: "onlySuccessWithException";
-} : TErrorData extends false | undefined ? {
-    resultMode?: "onlySuccessWithException";
-} : TErrorData extends false | null ? {
-    resultMode?: ExtractKeys<ResultModeUnion, "onlySuccess" | "onlySuccessWithException">;
-} : null extends TResultMode ? {
-    resultMode?: TResultMode;
-} : {
-    resultMode: TResultMode;
-};
-type ThrowOnErrorOption<TErrorData> = TErrorData extends false ? {
-    throwOnError: true;
-} : TErrorData extends false | undefined ? {
-    throwOnError?: true;
-} : NonNullable<unknown>;
-
-type FetchSpecificKeysUnion = Exclude<(typeof fetchSpecificKeys)[number], "body" | "headers" | "method">;
-type ModifiedRequestInit = RequestInit & {
-    duplex?: "half";
-};
-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 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> = {
-    /**
-     * 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;
-    /**
-     * 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
-     */
-    forceCalculateStreamSize?: boolean | {
-        request?: boolean;
-        response?: boolean;
-    };
-    /**
-     * Resolved request URL
-     */
-    readonly fullURL?: string;
-    /**
-     * 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 composed hooks execute
-     * @default "mainHooksAfterPlugins"
-     */
-    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
-     */
-    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>;
-} & HooksOrHooksArray<TData, TErrorData, Partial<InferPluginOptions<TPluginArray>>> & Partial<InferPluginOptions<TPluginArray>> & MetaOption<TSchemas> & RetryOptions<TErrorData> & ResultModeOption<TErrorData, TResultMode> & ThrowOnErrorOption<TErrorData> & 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> & {
-    plugins?: Plugins<TPluginArray> | ((context: {
-        basePlugins: Plugins<TPluginArray>;
-    }) => Plugins<TPluginArray>);
-    schemas?: TSchemas | ((context: {
-        baseSchemas: TSchemas | undefined;
-    }) => TSchemas);
-    validators?: CallApiValidators<TData, TErrorData> | ((context: {
-        baseValidators: CallApiValidators<TData, TErrorData> | undefined;
-    }) => CallApiValidators<TData, TErrorData>);
-};
-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]> & {
-    /**
-     * 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.
-     *
-     * @values
-     * - "all" - Disables automatic merging for both request and options
-     * - "options" - Disables automatic merging of options only
-     * - "request" - Disables automatic merging of request only
-     *
-     * @example
-     * ```ts
-     * const client = createFetchClient((ctx) => ({
-     *   skipAutoMergeFor: "options",
-     *
-     *   // Now you can manually merge options in your config function
-     *   ...ctx.options,
-     * }));
-     * ```
-     */
-    skipAutoMergeFor?: "all" | "options" | "request";
-};
-type CombinedExtraOptionsWithoutHooks = Omit<BaseCallApiExtraOptions & CallApiExtraOptions, keyof Hooks>;
-interface CombinedCallApiExtraOptions extends CombinedExtraOptionsWithoutHooks, Hooks {
-}
-type BaseCallApiConfig<TBaseData = DefaultDataType, TBaseErrorData = DefaultDataType, TBaseResultMode extends ResultModeUnion = ResultModeUnion, TBaseThrowOnError extends boolean = DefaultThrowOnError, TBaseResponseType extends ResponseTypeUnion = ResponseTypeUnion, TBasePluginArray extends CallApiPlugin[] = DefaultPluginArray, TBaseSchemas extends CallApiSchemas = DefaultMoreOptions> = (CallApiRequestOptions<TBaseSchemas> & BaseCallApiExtraOptions<TBaseData, TBaseErrorData, TBaseResultMode, TBaseThrowOnError, TBaseResponseType, TBasePluginArray, TBaseSchemas>) | ((context: {
-    initURL: string;
-    options: CallApiExtraOptions;
-    request: CallApiRequestOptions;
-}) => CallApiRequestOptions<TBaseSchemas> & BaseCallApiExtraOptions<TBaseData, TBaseErrorData, TBaseResultMode, TBaseThrowOnError, TBaseResponseType, TBasePluginArray, TBaseSchemas>);
-type CallApiConfig<TData = DefaultDataType, TErrorData = DefaultDataType, TResultMode extends ResultModeUnion = ResultModeUnion, TThrowOnError extends boolean = DefaultThrowOnError, TResponseType extends ResponseTypeUnion = ResponseTypeUnion, TPluginArray extends CallApiPlugin[] = DefaultPluginArray, TSchemas extends CallApiSchemas = DefaultMoreOptions> = CallApiRequestOptions<TSchemas> & CallApiExtraOptions<TData, TErrorData, TResultMode, TThrowOnError, TResponseType, TPluginArray, TSchemas>;
-type CallApiParameters<TData = DefaultDataType, TErrorData = DefaultDataType, TResultMode extends ResultModeUnion = ResultModeUnion, TThrowOnError extends boolean = DefaultThrowOnError, TResponseType extends ResponseTypeUnion = ResponseTypeUnion, TPluginArray extends CallApiPlugin[] = DefaultPluginArray, TSchemas extends CallApiSchemas = DefaultMoreOptions> = [
-    initURL: InferSchemaResult<TSchemas["initURL"], InitURL>,
-    config?: CallApiConfig<TData, TErrorData, TResultMode, TThrowOnError, TResponseType, TPluginArray, TSchemas>
-];
-type CallApiResult<TData, TErrorData, TResultMode extends ResultModeUnion, TThrowOnError extends boolean, TResponseType extends ResponseTypeUnion> = Promise<GetCallApiResult<TData, TErrorData, TResultMode, TThrowOnError, TResponseType>>;
-
-export { type CallApiExtraOptions as A, type BaseCallApiConfig as B, type CallApiPlugin as C, type DefaultPluginArray as D, type ErrorContext as E, type CallApiRequestOptions as F, type CallApiRequestOptionsForHooks as G, HTTPError as H, type InferSchemaResult as I, type CombinedCallApiExtraOptions as J, type Register as K, type PluginInitContext as P, type ResultModeUnion as R, type SharedHookContext as S, type ResponseTypeUnion as a, type CallApiSchemas as b, type CallApiConfig as c, type CallApiResult as d, type DefaultDataType as e, type DefaultThrowOnError as f, type DefaultMoreOptions as g, type CallApiParameters as h, definePlugin as i, type PluginHooks as j, type PluginHooksWithMoreOptions as k, type RetryOptions as l, type PossibleHTTPError as m, type PossibleJavaScriptError as n, type CallApiResultErrorVariant as o, type CallApiResultSuccessVariant as p, type Hooks as q, type HooksOrHooksArray as r, type RequestContext as s, type RequestErrorContext as t, type RequestStreamContext as u, type ResponseContext as v, type ResponseErrorContext as w, type ResponseStreamContext as x, type SuccessContext as y, type BaseCallApiExtraOptions as z };