@bgscore/react-core/dist/index.d.cts

A React utility library that provides advanced API hooks (fetch, mutation, caching). Built for scalable and flexible data handling in modern React applications.

import { GenericAbortSignal, AxiosProgressEvent, AxiosResponse, AxiosRequestConfig } from 'axios';
import { DurationUnitType } from 'dayjs/plugin/duration';
import React$1, { PropsWithChildren } from 'react';
import * as zustand from 'zustand';
import dayjs from 'dayjs';
import * as react_jsx_runtime from 'react/jsx-runtime';

type Children<T = unknown> = ChildFunction<T> | React.ReactNode;
type ChildFunction<T = unknown> = (props: T) => Children<T>;
interface PaginationMeta {
    limit: number;
    page: number;
    totalItems: number;
    totalPages: number;
}
interface ApiResponse<T = any> {
    status: boolean;
    data: T;
    paging?: PaginationMeta;
    message: string;
    code: number;
    isCancel: boolean;
    isUnauthorization: boolean;
    httpCode: number;
}
type CallbackHelper<T = any> = ((response: ApiResponse<T>) => (void | ApiResponse<T>));
type HandleCallback<T = any> = (props: AxiosResponse<T> & {
    isCancel: boolean;
    isUnauthorization: boolean;
}, err?: any) => Omit<ApiResponse, "httpCode" | "isCancel" | "isUnauthorization">;
interface UseHelperProps {
    /** Base URL API */
    url: string;
    /** Header tambahan untuk request */
    headers?: Record<string, string>;
    /** Token autentikasi, bisa string atau null/undefined jika tidak ada */
    token?: string | null | undefined;
    /** Callback yang dijalankan setiap response atau error */
    onCallback: HandleCallback;
    /** Handler khusus jika response tidak authorized */
    onUnauthorized?: (response: ApiResponse) => void;
    /** Fungsi untuk memeriksa otorisasi response, return true jika authorized */
    handleAuthorization?: (response: ApiResponse, options?: OptionsHelper) => boolean;
    /** Fungsi untuk menampilkan toast/notification berdasarkan response */
    handleToast?: (response: ApiResponse) => void;
    /**
     * Fungsi manipulasi/preparasi data sebelum dikirim ke server.
     */
    beforeRequest?: (data: any) => any;
    /** Jika true, toast tidak ditampilkan ketika request dibatalkan */
    disabledToastWhenCancel?: boolean;
    /**
     * Jika true, maka cookie seperti HttpOnly akan dikirim dalam request.
     * Digunakan saat autentikasi berbasis cookie (bukan token di header Authorization).
     */
    withCredentials?: boolean;
    /**
     * Jika `true`, data request akan dienkripsi sebelum dikirim ke server.
     * Pastikan server dapat mendekripsi payload ini.
     */
    encryptRequest?: boolean;
    /**
     * Jika `true`, data response dari server akan didekripsi.
     * Asumsinya response telah terenkripsi sebelumnya oleh server.
     */
    encryptResponse?: boolean;
    /**
     * Kata sandi atau kunci untuk proses enkripsi dan dekripsi data.
     * Digunakan bersama `encryptRequest` dan `encryptResponse` untuk memastikan
     * data terenkripsi dan terdekripsi dengan algoritma yang sama di sisi client dan server.
     * Harus disepakati antara client dan server.
     *
     * Secara default, nilai passphrase akan diambil dari context `bgsCore` jika ada.
     */
    passphrase?: string | null;
}
interface OptionsHelper {
    /** Menampilkan toast/info ketika response success */
    infoSuccess: boolean;
    /** Menampilkan toast/info ketika response error */
    infoError: boolean;
    /** Menyisipkan Authorization token.
     *  - `true` → pakai token default dari `UseHelperProps`
     *  - `string` → pakai token string ini
     *  - `false` → tidak menyisipkan token
     */
    token: boolean | string;
    /** Header tambahan untuk request */
    headers: Record<string, string>;
    /** Signal dari AbortController, bisa dipakai untuk cancel request */
    signal: GenericAbortSignal;
    /** Response type seperti 'json', 'blob', dll */
    responseType: ResponseType;
    /** Callback ketika ada upload progress (biasanya untuk form upload) */
    onUploadProgress: (props: AxiosProgressEvent) => void;
    /** Handler saat request unauthorized (status 401/403), bisa override default */
    onUnauthorized: (response: ApiResponse) => void;
    /** Jika `true`, maka onUnauthorized tidak akan dijalankan */
    disabledHandleUnauthorized: boolean;
    /** Jika `true`, maka tidak akan munculkan toast saat request dibatalkan (abort) */
    disabledToastWhenCancel?: boolean;
    /**
     * Jika true, maka cookie seperti HttpOnly akan dikirim dalam request.
     * Digunakan saat autentikasi berbasis cookie (bukan token di header Authorization).
     */
    withCredentials?: boolean;
    /**
     * Jika `true`, data request akan dienkripsi sebelum dikirim ke server.
     * Pastikan server dapat mendekripsi payload ini.
     */
    encryptRequest?: boolean;
    /**
     * Jika `true`, data response dari server akan didekripsi.
     * Asumsinya response telah terenkripsi sebelumnya oleh server.
     */
    encryptResponse?: boolean;
    /**
     * Kata sandi atau kunci untuk proses enkripsi dan dekripsi data.
     * Digunakan bersama `encryptRequest` dan `encryptResponse` untuk memastikan
     * data terenkripsi dan terdekripsi dengan algoritma yang sama di sisi client dan server.
     * Harus disepakati antara client dan server.
     *
     * Secara default, nilai passphrase akan diambil dari context `bgsCore` jika ada.
     */
    passphrase?: string | true | null;
}
type ClientCallback<T> = (response: AxiosResponse<T>, err?: any) => any;
declare enum HttpMethod {
    POST = "POST",
    PUT = "PUT",
    PATCH = "PATCH",
    DELETE = "DELETE",
    GET = "GET"
}
type ApiMethod<DReq = any, DRes = DReq> = (data: DReq, callback?: CallbackHelper<DRes>, options?: Partial<OptionsHelper>) => Promise<ApiResponse<DRes>>;
type ApiMethodVoid<DRes = any> = <Res = DRes>(callback?: CallbackHelper<Res>, options?: Partial<OptionsHelper>) => Promise<ApiResponse<Res>>;
type ApiMethodStream<DReq = any, DRes = DReq> = (data: DReq, callback: CallbackStream<DRes>, options?: Partial<OptionsHelper>) => Promise<void>;
type ApiDefaultMethod<DReq = any, DRes = DReq> = <Req = DReq, Res = DRes>(url: string, data: Req, callback?: CallbackHelper<Res>, options?: Partial<OptionsHelper>) => Promise<ApiResponse<Res>>;
type ApiDefaultFetch<DRes = any> = <Res = DRes>(url: string, callback?: CallbackHelper<Res>, options?: Partial<OptionsHelper>) => Promise<ApiResponse<Res>>;
type ApiDefaultStream<DReq = any, DRes = DReq> = <Req = DReq, Res = DRes>(method: HttpMethod, url: string, data: Req, callback: CallbackStream<Res>, options?: Partial<OptionsHelper>) => Promise<void>;
type CallbackStream<T = any> = (response: ApiResponseStream<T>) => void;
interface ApiResponseStream<T = any> {
    status: boolean;
    data: T;
    message: string;
    isCancel: boolean;
    isUnauthorization: boolean;
    httpCode: number;
    isDone: boolean;
}
interface UseApiStreamProps<Req, Res> extends Partial<OptionsHelper> {
    /**
     * Callback ketika respon selesai.
     */
    onDone?: (res: ApiResponseStream<Res>[]) => void;
    /**
     * Callback ketika respon selesai.
     */
    onStream?: (res: ApiResponseStream<Res>) => void;
    /**
     * Callback ketika terjadi error.
     */
    onError?: (res: ApiResponseStream<Res>) => void;
    abortOnUnmount?: boolean;
}
type ResponseType = 'arraybuffer' | 'blob' | 'document' | 'json' | 'text' | 'stream' | 'formdata';
type OptionsCallReturn<DReq = unknown, DRes = DReq> = Partial<ApiResponse<DRes>> & {
    /** Status loading saat request berlangsung */
    loading: boolean;
    /** Menjalankan ulang request dengan payload & config sebelumnya */
    refresh: (force?: boolean) => void;
    /** Membatalkan request yang sedang berjalan */
    abort: () => void;
    /** Clear/reset response dan status terkait */
    clear: () => void;
    /** Response dari server (bisa undefined/null jika belum ada atau sudah di-clear) */
    response: ApiResponse<DRes> | undefined | null;
    /**
     * Mengkloning call API dengan payload/config baru.
     * Cocok untuk membuat instance baru tanpa mempengaruhi state lama.
     */
    clone: <T = unknown>(newPayload?: DReq, newConfig?: Partial<UseCallOptionsProps<DReq, DRes & T>>) => UseCallReturnType<DReq, DRes>;
    /** Menunjukkan apakah request terakhir dibatalkan (via abort).
     * Berguna untuk mengabaikan cache saat refresh berikutnya.
     */
    isCancel: boolean;
};
type UseCallReturnType<DReq, DRes = DReq> = [
    DRes | undefined,
    OptionsCallReturn<DReq, DRes>
];
interface TimeoutConfig {
    value: number;
    unit: DurationUnitType;
}
interface CacheProps {
    /**
     * Menentukan apakah fitur cache diaktifkan atau tidak.
     * Jika `false`, data tidak akan disimpan atau diambil dari cache,
     * meskipun properti `cacheKey` dan `cacheName` telah diatur.
     * Default: `true`
     */
    enabled?: boolean;
    /**
     * Nama cache yang akan digunakan sebagai container atau namespace.
     * Biasanya untuk membedakan jenis cache yang berbeda.
     */
    cacheName?: string;
    /**
     * Kunci unik untuk menyimpan dan mengambil data dari cache.
     * Biasanya merepresentasikan entri spesifik dalam cacheName.
     */
    cacheKey?: string | Array<string | number | boolean | null | undefined | Record<string, any>>;
    /**
     * Durasi timeout cache sebelum dianggap kedaluwarsa.
     * Bisa berupa angka (dalam satuan detik) atau objek konfigurasi timeout.
     */
    timeout?: number | TimeoutConfig;
    /**
     * Jika true, data cache akan dipertahankan walau halaman direfresh atau ditutup.
     * Jika false atau tidak diisi, cache akan dihapus saat halaman ditutup.
     */
    persistence?: boolean;
}
interface CacheData<DRes> {
    /**
     * Waktu kedaluwarsa cache dalam bentuk ISO string.
     */
    expired: string;
    /**
     * Data respon API yang disimpan dalam cache.
     */
    data: ApiResponse<DRes>;
}
interface UseCallOptionsProps<DReq, DRes> extends OptionsHelper {
    /**
     * Jika true, proses request & response akan dicetak ke console.
     */
    logging: boolean;
    /**
     * Fungsi manipulasi/preparasi data sebelum dikirim ke server.
     */
    beforeRequest: (request: DReq) => DReq;
    /**
     * Fungsi manipulasi respon dari server sebelum disimpan atau ditampilkan.
     */
    afterResponse: (response: DRes, request: DReq) => DRes;
    /**
     * Hook yang dijalankan sebelum request diproses.
     */
    onBeforeRequest: (request: DReq) => void;
    /**
     * Hook yang dijalankan setelah respon diterima dari server.
     */
    onAfterResponse: OnCallback<DRes, DReq>;
    /**
     * Callback ketika respon berhasil.
     */
    onSuccess?: OnCallback<DRes, DReq>;
    /**
     * Callback ketika terjadi error.
     */
    onError?: OnCallback<DRes, DReq>;
    /**
     * Daftar dependency yang dapat memicu ulang pemanggilan API jika berubah.
     */
    trigger: any[];
    /**
     * Jika true, maka request tidak dijalankan otomatis hingga dipanggil secara manual.
     */
    hold: boolean;
    /**
      * Jika true, data lama akan di-clear sebelum melakukan request baru saat payload berubah.
      * Default: false (tampilkan data lama sambil mem-fetch data baru).
      */
    clearPreviousData?: boolean;
    /**
     * Callback yang dipanggil setiap kali data berubah.
     */
    onChange: (data: DReq, options: OptionsCallReturn<DReq, DRes>) => void;
    /**
     * Mengaktifkan cache untuk menyimpan respon API.
     * Bisa true/false (default pengaturan dri context) atau objek konfigurasi `CacheProps`.
     */
    cache: boolean | CacheProps;
    /**
     * Interval auto refresh data. Bisa dalam detik atau konfigurasi TimeoutConfig.
     */
    refreshInterval: number | TimeoutConfig;
    /**
     * Menentukan apakah data akan difetch ulang saat tab aktif kembali.
     */
    refetchOnWindowFocus: {
        enabled?: boolean;
        timeout: number | TimeoutConfig;
    };
    /**
     * Nama unik untuk store/context/cache dari request API ini.
     *
     * Properti ini digunakan sebagai identitas untuk:
     * - Menyimpan hasil request di global store agar bisa diakses antar komponen.
     * - Menamai cache secara otomatis jika `cacheName` tidak diatur manual.
     * - Menghindari konflik antar pemanggilan API yang berbeda.
     *
     * Disarankan menggunakan nama yang deskriptif dan unik per endpoint,
     * seperti: "historyAbsence", "dashboardSummary", "userProfile", dst.
     *
     * Contoh penggunaan bersama context:
     * const [data, options] = useApiStore(api.absence.history, "historyAbsence")
     */
    storeName: string;
}
interface UseApiSendProps<Req, Res> extends Partial<OptionsHelper> {
    /**
     * Callback ketika respon berhasil.
     */
    onSuccess?: OnCallback<Res, Req>;
    /**
     * Callback ketika terjadi error.
     */
    onError?: OnCallback<Res, Req>;
    /**
     * Jika true, proses request & response akan dicetak ke console.
     */
    logging?: boolean;
    /**
     * Fungsi manipulasi sebelum request dikirim.
     */
    beforeRequest?: (request: Req) => Req;
    /**
     * Fungsi manipulasi setelah respon diterima.
     */
    afterResponse?: (response: Res, request: Req) => Res;
    /**
     * Hook yang dijalankan sebelum request diproses.
     */
    onBeforeRequest?: (request: Req) => void;
    /**
     * Hook yang dijalankan setelah respon diterima dari server.
     */
    onAfterResponse?: OnCallback<Res, Req>;
    /**
     * Jika true, request akan otomatis dibatalkan saat komponen unmount.
     */
    abortOnUnmount?: boolean;
}
type OnCallback<Res = any, Req = any> = (response: ApiResponse<Res>, request: Req) => void;
type ApiActionState<Res> = Partial<ApiResponse<Res>> & {
    /** Membatalkan request yang sedang berjalan */
    abort: () => void;
    /** Clear/reset response dan status terkait */
    reset: () => void;
    /** Status loading saat request berlangsung */
    loading: boolean;
    /** Progress upload/download, nilai antara 0 - 100 */
    progress: number;
};
type UseApiSendReturnType<Req, Res> = Req extends undefined ? [
    (values?: Req) => void,
    ApiActionState<Res>
] : [
    (values: Req) => void,
    ApiActionState<Res>
];
type ApiActionStateStream<Res> = Partial<ApiResponse<Res>> & {
    /** Membatalkan request yang sedang berjalan */
    abort: () => void;
    /** Clear/reset response dan status terkait */
    reset: () => void;
    /** Status loading saat request berlangsung */
    loading: boolean;
    response: ApiResponseStream<Res>[];
};
type UseApiStreamReturn<Req, Res> = Req extends undefined ? [
    Res[],
    (values?: Req) => void,
    ApiActionStateStream<Res>
] : [
    Res[],
    (values: Req) => void,
    ApiActionStateStream<Res>
];
declare enum DataTypeEnum {
    number = "number",
    currency = "currency",
    percent = "percent",
    date = "date",
    dateTime = "dateTime",
    month = "month",
    year = "year",
    time = "time",
    timestamp = "timestamp",
    string = "string",
    textarea = "textarea",
    code = "code",
    password = "password",
    boolean = "boolean",
    toggle = "toggle",// Optional, untuk UI switch boolean
    email = "email",
    phone = "phone",
    url = "url",
    json = "json",
    file = "file",
    image = "image",
    array = "array",
    object = "object",
    enum = "enum",
    user = "user",
    department = "department",
    status = "status"
}
type DataType = `${DataTypeEnum}`;
type NestedKeyOf<T> = T extends object ? T extends Array<infer U> ? `${number}` | `${number}.${NestedKeyOf<U>}` : {
    [K in keyof T]: T[K] extends Array<infer U> ? `${K & string}` | `${K & string}[${number}]` | `${K & string}[${number}].${NestedKeyOf<U>}` : T[K] extends object ? `${K & string}` | `${K & string}.${NestedKeyOf<T[K]>}` : `${K & string}`;
}[keyof T] : never;
type PathValue<T, P extends string> = P extends `${infer K}[${infer I}].${infer R}` ? K extends keyof T ? T[K] extends Array<infer U> ? PathValue<U, R> : never : never : P extends `${infer K}[${infer I}]` ? K extends keyof T ? T[K] extends Array<infer U> ? U : never : never : P extends `${infer K}.${infer R}` ? K extends keyof T ? PathValue<T[K], R> : never : P extends keyof T ? T[P] : never;
type SelectedNested<T> = Partial<Record<NestedKeyOf<T>, any>>;
type TextTransform = "capitalize" | "uppercase" | "lowercase";
type StorePayload<DRes> = {
    response?: ApiResponse<DRes> | undefined | null;
    loading?: boolean;
    isCancel?: boolean;
};
type DataSource<T = unknown> = {
    label: string;
    value: string;
    index: number;
    rowData: T;
};

declare function useApiLoad<DRes>(api: ApiMethodVoid<DRes>, options?: Partial<UseCallOptionsProps<undefined, DRes>>): UseCallReturnType<undefined, DRes>;
declare function useApiLoad<DReq, DRes>(api: ApiMethod<DReq, DRes>, data: DReq, options?: Partial<UseCallOptionsProps<DReq, DRes>>): UseCallReturnType<DReq, DRes>;

declare function useDelay(s: number, callback?: Function): Promise<unknown>;

type OptionsNumberProps = {
    thouSep: string;
    decSep: string;
    decDigits: number | "auto";
};
type OptionsNumber = OptionsNumberProps & {
    dataType: Extract<DataType, "number">;
    method?: "round" | "ceil" | "floor" | "trunc";
    dirty?: boolean;
};
type DataTypeDateGroup = Extract<DataType, "date" | "dateTime" | "month" | "year" | "time">;
type OptionsDate = {
    dataType: DataTypeDateGroup;
    display: string;
    value: string;
};
type OptionsBoolean = {
    dataType: Extract<DataType, "boolean">;
    trueLabel?: string;
    falseLabel?: string;
};
type OptionsString = {
    dataType: Extract<DataType, "string">;
    textTransform?: TextTransform;
    ellipsis?: number;
};
type UseFormattedOptions<T extends DataType> = T extends DataTypeDateGroup ? Partial<OptionsDate> : T extends "number" ? Partial<OptionsNumber> : T extends "boolean" ? Partial<OptionsBoolean> : T extends "string" ? Partial<OptionsString> : never;
type SupportedFormattedType = Extract<DataType, "number" | "date" | "dateTime" | "month" | "year" | "time" | "boolean" | "string">;
declare const useFormatted: <T extends SupportedFormattedType>(value: unknown, dataType: T, options?: UseFormattedOptions<T>) => string;

declare function useInterval<P extends Function>(callback: P, { interval, lead }: {
    interval: number;
    lead?: boolean;
}): void;

type CombinationType = "ctrl" | "alt" | "shift";
declare function useKeyPress(targetKey: string | number, combination?: CombinationType | CombinationType[], stopPropagation?: boolean): boolean;

declare const createApiHelper: <DReq = any, DRes = any>({ url, token, beforeRequest, onCallback, headers: headerProps, onUnauthorized, handleToast, handleAuthorization, disabledToastWhenCancel: disabledToastWhenCancelProps, withCredentials, encryptRequest: encryptRequestDefault, encryptResponse: encryptResponseDefault, passphrase, }: UseHelperProps) => {
    client: (props: AxiosRequestConfig, callback?: ClientCallback<DRes>) => Promise<any>;
    post: ApiDefaultMethod<DReq, DRes>;
    put: ApiDefaultMethod<DReq, DRes>;
    patch: ApiDefaultMethod<DReq, DRes>;
    delete: ApiDefaultFetch<DRes>;
    get: ApiDefaultFetch<DRes>;
    upload: ApiDefaultMethod<DReq, DRes>;
    stream: ApiDefaultStream<DReq, DRes>;
};

declare function useApiSend<DReq, DRes>(api: ApiMethod<DReq, DRes>, props?: UseApiSendProps<DReq, DRes>): UseApiSendReturnType<DReq, DRes>;
declare function useApiSend<DRes>(api: ApiMethodVoid<DRes>, props?: UseApiSendProps<undefined, DRes>): UseApiSendReturnType<undefined, DRes>;

interface UseScrollTriggerOptions {
    disableHysteresis?: boolean;
    target?: Node | Window | null;
    threshold?: number;
    getTrigger?: (store: ReturnType<typeof React$1.useRef<number | undefined>>, options: {
        disableHysteresis?: boolean;
        threshold?: number;
        target?: Node | Window | null;
    }) => boolean;
}
declare function useScrollTrigger(options?: UseScrollTriggerOptions): boolean;

declare const useStorage: () => {
    save: <T = any>(key: string, data: T) => void;
    get: <T = any>(key: string) => T | null;
    clear: (key?: string) => void;
    useWatchStorage: <T = any>(key: string) => T | null;
};

type EncryptedPayload = {
    salt: string;
    iv: string;
    encrypted: string;
};
declare function encrypt<T = unknown>(payload: T, passphrase: string): EncryptedPayload;
declare function decrypt<T = unknown>(cipherPayload: EncryptedPayload, passphrase: string): T;
declare function encryptString(plain: string, passphrase: string): string;
declare function decryptString(encryptedJson: string, passphrase: string): string;

declare function useCrypto(): {
    passphrase: string | undefined;
    encrypt<T>(payload: T, passphraseProps?: string | null): EncryptedPayload;
    decrypt<T>(data: EncryptedPayload, passphraseProps?: string | null): T;
    encryptString(payload: string, passphraseProps?: string | null): string;
    decryptString(data: string, passphraseProps?: string | null): string;
};

type UseDebounceOptions<T> = {
    delay?: number;
    onDebounce?: (value: T) => void;
};
declare function useDebounce<T = string>(value: T, options?: number | UseDebounceOptions<T>): T;

type AnyApiMethod = ApiMethod<any, any> | ApiMethodVoid<any>;
type InferApiRequest<T> = T extends ApiMethod<infer Req, any> ? Req : T extends ApiMethodVoid<any> ? never : never;
type InferApiResponse<T> = T extends ApiMethod<any, infer Res> ? Res : T extends ApiMethodVoid<infer Res> ? Res : never;
/**
 * Hook untuk menggunakan API store yang sesuai dengan method.
 *
 * @param api  API method yang ingin digunakan (misalnya `api.absence.save`)
 * @param key  (Optional) Nama store. Jika tidak diisi, akan otomatis memakai `api.__path` (jika tersedia dari `wrapApi`) atau `api.name`
 *
 * Contoh:
 * ```ts
 * const store = useApiStore(api.absence.save); // pakai __path
 * const store = useApiStore(api.absence.save, 'absence.save'); // pakai key manual
 * ```
 */
/**
 * Opsi tambahan untuk penggunaan hook `useApiStore`.
 *
 * @template T - Tipe method API (ApiMethod atau ApiMethodVoid).
 * @template U - Tipe hasil akhir setelah selector diterapkan (default-nya adalah `UseCallReturnType`).
 */
interface UseApiStoreOptions<T extends AnyApiMethod, U = UseCallReturnType<InferApiRequest<T>, InferApiResponse<T>>> {
    /**
     * Nama custom untuk store.
     * Jika tidak diisi, maka akan otomatis menggunakan `api.__path` atau `api.name`.
     */
    storeName?: string;
    /**
     * Menentukan apakah akan menggunakan shallow comparison (perbandingan dangkal) saat subscribe state.
     * Berguna untuk mencegah rerender tidak perlu saat hanya sebagian kecil data yang berubah.
     *
     * @default true
     */
    shallow?: boolean;
    /**
     * Fungsi selector untuk mengambil bagian tertentu dari hasil `useApiStore`.
     * Sangat berguna untuk menghindari rerender besar karena hanya bagian yang dipilih yang akan dipantau.
     *
     * Contoh penggunaan:
     * ```ts
     * const loading = useApiStore(api.absence.get, {
     *   selector: ([, meta]) => meta.loading
     * });
     * ```
     */
    selector?: (value: UseCallReturnType<InferApiRequest<T>, InferApiResponse<T>>) => U;
}
declare const useApiStore: <T extends AnyApiMethod, U = UseCallReturnType<InferApiRequest<T>, InferApiResponse<T>>>(api: T, options?: UseApiStoreOptions<T, U>) => U;

type CreateElementProps<P = unknown> = {
    (element: (props: P) => React$1.JSX.Element, elementName: string): React$1.FC<P>;
};
declare const createElement: <T>(element: (props: T) => React$1.JSX.Element, elementName: string) => React$1.FC<T>;
type SplitElementResult<T extends string> = {
    [K in T]?: React$1.ReactNode;
} & {
    others?: React$1.ReactNode[];
};
declare const splitElement: <T extends string>(children: React$1.ReactNode, elementNames: T[]) => SplitElementResult<T>;

declare function useParseStringToNumber(): (value?: string, strict?: boolean) => number | null;

declare function generateUUID(): string;
declare function diffJson(data1: any, data2: any): boolean;
declare const mappingUndefinedtoNull: (values: any) => any;
declare function isArray(data: any, length?: number): boolean;
declare function isNotEmpty(value: unknown): boolean;
declare const labelFormatter: {
    camelCase: (value?: string) => string;
    snackCase: (value?: string) => string;
    changeAll: (value?: string, capShortWords?: boolean) => string;
};
declare function renderChildren<T = unknown>(children: Children, props: T): any;
declare const getFieldValue: <T, P extends NestedKeyOf<T>, D = unknown>(obj: T, path: P, defaultValue?: D) => PathValue<T, P> | D;
declare const sorting: {
    desc: <T>(data: T[], field?: NestedKeyOf<T>) => T[];
    asc: <T>(data: T[], field?: NestedKeyOf<T>) => T[];
};
declare const summary: <T>(data: T[], field?: NestedKeyOf<T>) => number;
declare function jsonCopy<T>(data: T): T;
declare function stableStringify(obj: any): string;
declare function generateCacheKey(data?: any, cacheKey?: string | any[]): string;
declare function capitalizeWords(value?: string): string;
declare function debounce<T extends (...args: any[]) => void>(func: T, delayInSeconds?: number): (...args: Parameters<T>) => void;
declare const parseSSEChunk: (chunk: string) => any;
declare function isDirtyRaw(val: string, decSep: string): boolean;
declare function isValidNumber(val: any, dirty?: boolean, decSep?: string): boolean;
declare function parseStringToNumber(value?: string, strict?: boolean, decSep?: string): number | null;
declare function filterDOMPropsLite<T extends Record<string, any>>(props: T): Partial<T>;
declare function getInitials(fullName?: string, max?: number): string;
declare function getMinMaxDate(dates?: string[]): [string, string];
declare function getDateRangeLabelFromSorted(from: string, to: string): string;
declare function getTotalMinutes(from?: string, to?: string): string;
declare const mappingData: <T = unknown>(dataSource?: T[], displayExpr?: NestedKeyOf<T> | "label" | ((data: T, index: number) => string), valueExpr?: NestedKeyOf<T> | "value" | ((data: T, index: number) => string), groupBy?: NestedKeyOf<T>) => DataSource<T>[];
declare function objectToQueryString(obj: Record<string, any>, parentKey?: string): string;
declare function replaceNullStrings(input: any): any;

type Listener = () => void;
declare function createStore<T>(initialState: T): {
    getSnapshot: () => T;
    subscribe: (listener: Listener) => () => boolean;
    setState: (newState: T | ((prev: T) => T)) => void;
    useStore: {
        (): T;
        <K>(selector: (state: T) => K): K;
    };
};

type TWithName<T> = {
    [K in keyof T]: T[K] extends (...args: infer Args) => infer R ? ((...args: Args) => R) & {
        __path: string;
        __isVoid?: boolean;
    } : T[K] extends object ? TWithName<T[K]> : T[K];
};
declare function wrapApi<T extends object>(obj: T, path?: string[]): T;

declare const registerApi: (key: string, actions: Partial<OptionsCallReturn<any, any>>) => void;
declare const unregisterApi: (key: string) => void;
declare const getApiActions: (key: string) => Partial<OptionsCallReturn<any, any>> | undefined;

declare function safeUpdate<T>(prev: T, next: T): boolean;
interface ApiLoadState {
    states: Record<string, OptionsCallReturn>;
    updateState: (storeName: string, state: Partial<OptionsCallReturn>) => void;
}
declare const defaultState: Partial<OptionsCallReturn>;
declare const useApiLoadStore: zustand.UseBoundStore<zustand.StoreApi<ApiLoadState>>;

declare const moment: typeof dayjs;

declare function useApiStream<DReq, DRes>(api: ApiMethodStream<DReq, DRes>, props?: UseApiStreamProps<DReq, DRes>): UseApiStreamReturn<DReq, DRes>;

type FormatType = {
    display: string;
    value: string;
};
type FormatContextProps = {
    date: FormatType;
    month: FormatType;
    year: FormatType;
    dateTime: FormatType;
    time: FormatType;
    number: OptionsNumberProps;
};
type BgsCoreProps = {
    localeConfig?: {
        preset?: string | ILocale;
        object?: Partial<ILocale>;
        isLocal?: boolean;
    };
    passphrase?: string;
    storageKey?: string;
    format: FormatContextProps;
    cache?: Omit<CacheProps, "cacheName" | "cacheKey">;
    clearPreviousData?: boolean;
    refetchOnWindowFocus?: UseCallOptionsProps<any, any>["refetchOnWindowFocus"];
};
declare function useBgsCore(): BgsCoreProps;
interface BgsCoreProviderProps {
    value: BgsCoreProps;
}
declare const BgsCoreProvider: ({ children, value: options }: PropsWithChildren<BgsCoreProviderProps>) => react_jsx_runtime.JSX.Element;

export { type ApiActionState, type ApiActionStateStream, type ApiDefaultFetch, type ApiDefaultMethod, type ApiDefaultStream, type ApiLoadState, type ApiMethod, type ApiMethodStream, type ApiMethodVoid, type ApiResponse, type ApiResponseStream, type BgsCoreProps, BgsCoreProvider, type CacheData, type CacheProps, type CallbackHelper, type CallbackStream, type Children, type ClientCallback, type CombinationType, type CreateElementProps, type DataSource, type DataType, DataTypeEnum, type EncryptedPayload, HttpMethod, type NestedKeyOf, type OptionsCallReturn, type OptionsHelper, type OptionsNumberProps, type PaginationMeta, type PathValue, type ResponseType, type SelectedNested, type SplitElementResult, type StorePayload, type SupportedFormattedType, type TWithName, type TextTransform, type TimeoutConfig, type UseApiSendProps, type UseApiSendReturnType, type UseApiStreamProps, type UseApiStreamReturn, type UseCallOptionsProps, type UseCallReturnType, type UseHelperProps, type UseScrollTriggerOptions, capitalizeWords, createApiHelper, createElement, createStore, debounce, decrypt, decryptString, defaultState, diffJson, encrypt, encryptString, filterDOMPropsLite, generateCacheKey, generateUUID, getApiActions, getDateRangeLabelFromSorted, getFieldValue, getInitials, getMinMaxDate, getTotalMinutes, isArray, isDirtyRaw, isNotEmpty, isValidNumber, jsonCopy, labelFormatter, mappingData, mappingUndefinedtoNull, moment, objectToQueryString, parseSSEChunk, parseStringToNumber, registerApi, renderChildren, replaceNullStrings, safeUpdate, sorting, splitElement, stableStringify, summary, unregisterApi, useApiLoad, useApiLoadStore, useApiSend, useApiStore, useApiStream, useBgsCore, useCrypto, useDebounce, useDelay, useFormatted, useInterval, useKeyPress, useParseStringToNumber, useScrollTrigger, useStorage, wrapApi };