dinocollab-core 1.0.1 → 1.0.3

package/dist/index.d.ts

@@ -0,0 +1,928 @@
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import * as React$1 from 'react';
+import React__default, { Component, ReactNode, PropsWithChildren, FC, ComponentType } from 'react';
+import { PopoverVirtualElement, PopoverProps, DrawerProps, SxProps, TypographyProps, TooltipProps, ButtonProps, Theme, TextFieldProps, BoxProps, RegularBreakpoints, Breakpoint, SelectProps, IconButtonProps } from '@mui/material';
+import { AlertColor } from '@mui/material/Alert';
+import { Dayjs } from 'dayjs';
+export { default as dayjsCustom } from 'dayjs';
+import { DatePickerProps } from '@mui/x-date-pickers';
+import { GridValidRowModel, GridColDef, GridPaginationModel, GridLogicOperator, GridSortDirection, GridDensity, DataGridProps, GridFeatureMode, GridRowIdGetter, GridFilterOperator, GridValueFormatterParams, GridRenderCellParams, GridTreeNodeWithRender } from '@mui/x-data-grid';
+import queryString from 'query-string';
+
+interface IPopoverOptions {
+    anchorEl?: Element | (() => Element) | PopoverVirtualElement | (() => PopoverVirtualElement) | null;
+    popoverProps?: Omit<PopoverProps, 'open'>;
+    content: React__default.ReactNode;
+}
+type TShowPopover = (option: IPopoverOptions) => void;
+type TClosePopover = (reason?: 'backdropClick' | 'escapeKeyDown') => void;
+interface IApiPopoverContext {
+    showPopover: TShowPopover;
+    closePopover: TClosePopover;
+}
+declare const ApiPopoverContext: React__default.Context<IApiPopoverContext>;
+declare const MapApiPopoverContext: (context: (state: IApiPopoverContext) => React__default.ReactNode) => react_jsx_runtime.JSX.Element;
+interface IProps$2 {
+}
+interface IState$1 extends IPopoverOptions {
+}
+type TProps = React__default.PropsWithChildren<IProps$2>;
+declare class ApiPopover extends Component<TProps, IState$1> implements IApiPopoverContext {
+    constructor(props: any);
+    render(): react_jsx_runtime.JSX.Element;
+    showPopover: (option: IPopoverOptions) => void;
+    timer: any;
+    closePopover: TClosePopover;
+}
+
+interface IApiPopoverContextProps {
+    contextPopover: IApiPopoverContext;
+}
+declare const withApiPopoverContext: <P extends IApiPopoverContextProps>(Component: React__default.ComponentType<P>) => (props: Omit<P, "contextPopover">) => react_jsx_runtime.JSX.Element;
+
+interface MessageData {
+    id: string;
+    text: string;
+    type: AlertColor;
+    duration?: number;
+}
+interface IApiAlert {
+    PushMessage: (data: MessageData) => void;
+    PushInfo: (data: string) => void;
+    PushError: (data: string) => void;
+    PushWarning: (data: string) => void;
+    PushSuccess: (data: string) => void;
+}
+interface IApiContext {
+    ApiAlert?: IApiAlert;
+}
+declare const ApiAlertContext: IApiContext;
+declare function AlertGlobal(): react_jsx_runtime.JSX.Element;
+
+interface AlertDialogProps {
+    IsOpen: boolean;
+    onClose?: () => void;
+    onAccept?: () => void;
+    Title: string;
+    Message: string;
+}
+declare const AlertDialog: React__default.FC<AlertDialogProps>;
+
+interface IProps$1 {
+}
+interface IState {
+    title?: ReactNode;
+    icon?: ReactNode;
+    fullHeight?: boolean;
+    anchor?: DrawerProps['anchor'];
+    /** @default true */
+    backdropClickeable?: boolean;
+    renderContent?: () => ReactNode;
+}
+type TReason = 'backdropClick' | 'escapeKeyDown';
+interface DrawerGlobalApiType {
+    open: (state: IState) => void;
+    close: (reason?: TReason) => void;
+}
+declare class DrawerGlobalProvider extends Component<IProps$1, IState> {
+    constructor(props: IProps$1);
+    close: (reason?: TReason) => void;
+    open: (state: IState) => void;
+    componentDidMount(): void;
+    render(): react_jsx_runtime.JSX.Element;
+    renderTitle: () => number | boolean | Iterable<React__default.ReactNode> | react_jsx_runtime.JSX.Element | null | undefined;
+    getClasses: () => string;
+}
+declare const DrawerGlobal: {
+    Provider: typeof DrawerGlobalProvider;
+    Api: DrawerGlobalApiType;
+};
+
+interface GlobalModalState {
+    sx?: SxProps;
+    sxWrap?: SxProps;
+    /** @default true */
+    backdropActivated?: boolean;
+    onClose?: (reason?: TModalReason) => void;
+    renderContent?: () => React__default.ReactNode;
+}
+type TModalReason = 'backdropClick' | 'escapeKeyDown';
+interface GlobalModalProps {
+}
+type TShowModal = (value: GlobalModalState) => void;
+type TCloseModal = (event?: {}, reason?: TModalReason) => void;
+interface IGlobalModalContext {
+    show: TShowModal;
+    close: TCloseModal;
+}
+declare const GlobalModalContext: React__default.Context<IGlobalModalContext>;
+interface IMapGlobalModal {
+    context: IGlobalModalContext;
+}
+declare const MapGlobalModalContext: (context: (state: IGlobalModalContext) => React__default.ReactNode) => react_jsx_runtime.JSX.Element;
+declare class GlobalModal extends Component<React__default.PropsWithChildren<GlobalModalProps>, GlobalModalState> implements IGlobalModalContext {
+    constructor(props: any);
+    show: TShowModal;
+    close: TCloseModal;
+    render(): react_jsx_runtime.JSX.Element;
+    renderContent: () => React__default.ReactNode;
+}
+
+interface IApiGlobalModalContextProps {
+    contextGlobalModal: IGlobalModalContext;
+}
+declare const withApiGlobalModalContext: <P extends IApiGlobalModalContextProps>(Component: React__default.ComponentType<P>) => (props: Omit<P, "contextGlobalModal">) => react_jsx_runtime.JSX.Element;
+declare const withApiGlobalModalConsumerContext: <P extends IApiGlobalModalContextProps>(Component: React__default.ComponentType<P>) => (props: Omit<P, "contextGlobalModal">) => react_jsx_runtime.JSX.Element;
+
+interface PopoverGlobalState {
+    anchorEl?: Element | (() => Element) | PopoverVirtualElement | (() => PopoverVirtualElement) | null;
+    popoverProps?: Omit<PopoverProps, 'open'>;
+    content: React__default.ReactNode;
+}
+type OpenPopover = (value: PopoverGlobalState) => void;
+type ClosePopover = (reason?: 'backdropClick' | 'escapeKeyDown') => void;
+declare const PopoverGlobalApi: PopoverGlobalContext;
+interface PopoverGlobalContext {
+    open: OpenPopover;
+    close: ClosePopover;
+}
+declare const PopoverGlobalContext: React__default.Context<PopoverGlobalContext>;
+declare const MapPopoverGlobalContext: (context: (state: PopoverGlobalContext) => React__default.ReactNode) => react_jsx_runtime.JSX.Element;
+interface IProps extends PropsWithChildren {
+}
+declare class PopoverGlobalProvider extends Component<IProps, PopoverGlobalState> {
+    constructor(props: any);
+    componentDidMount(): void;
+    render(): react_jsx_runtime.JSX.Element;
+    openPopover: OpenPopover;
+    timer: any;
+    closePopover: ClosePopover;
+}
+interface IPopoverGlobalContextProps {
+    contextPopover: PopoverGlobalContext;
+}
+declare const withPopoverGlobalContext: <P extends IPopoverGlobalContextProps>(Component: React__default.ComponentType<P>) => (props: Omit<P, "contextPopover">) => react_jsx_runtime.JSX.Element;
+declare const PopoverGlobal: {
+    Provider: typeof PopoverGlobalProvider;
+    Api: PopoverGlobalContext;
+    Context: React__default.Context<PopoverGlobalContext>;
+    mapContext: (context: (state: PopoverGlobalContext) => React__default.ReactNode) => react_jsx_runtime.JSX.Element;
+};
+
+interface IBreadcrumbConfig {
+    label: string;
+    url?: string;
+    propsGetter?: () => TypographyProps;
+    onClick?: (event: React__default.MouseEvent<HTMLDivElement, MouseEvent>) => void;
+}
+interface IBreadcrumbsProps {
+    value?: IBreadcrumbConfig[];
+}
+declare const Breadcrumbs: FC<IBreadcrumbsProps>;
+
+interface ICopyToClipboardProps {
+    value: string;
+    slots?: {
+        tooltipProps?: Partial<TooltipProps>;
+        button?: ComponentType<{
+            onClick: () => void;
+            copied?: boolean;
+        }>;
+        buttonProps?: ButtonProps;
+    };
+}
+interface ICopyToClipboardState {
+    showTooltip: boolean;
+    copied: boolean;
+}
+declare class CopyToClipboard extends Component<ICopyToClipboardProps, ICopyToClipboardState> {
+    constructor(props: ICopyToClipboardProps);
+    render(): react_jsx_runtime.JSX.Element;
+    renderIcon: () => react_jsx_runtime.JSX.Element;
+    handleClickCopy: () => void;
+    private debounceTime;
+    private onCopy;
+}
+
+interface IImageWithFallbackPropsOwner {
+    src?: string;
+    alt?: string;
+    fallbackSrc: string;
+    loading?: ReactNode;
+    debounceDelay?: number;
+}
+type IImageProps = Omit<React__default.ImgHTMLAttributes<HTMLImageElement>, keyof IImageWithFallbackPropsOwner>;
+interface IImageWithFallbackProps extends IImageProps, IImageWithFallbackPropsOwner {
+}
+declare const ImageWithFallback: FC<IImageWithFallbackProps>;
+
+interface IHelpTooltipProps {
+    title: string;
+    small?: boolean;
+    sxIcon?: SxProps<Theme>;
+}
+declare const HelpTooltip: FC<PropsWithChildren<IHelpTooltipProps>>;
+
+interface IHelpTooltipWrapProps {
+    content: ReactNode;
+    title: string;
+    children: React__default.ReactNode;
+}
+declare const HelpTooltipWrap: FC<IHelpTooltipWrapProps>;
+
+declare const TextEditorPreview: FC<{
+    children: string;
+}>;
+
+declare const textEditorClasses: {
+    root: string;
+    fullscreen: string;
+};
+interface ITextEditorProps$1 {
+    id?: string;
+    name: string;
+    sx?: SxProps<Theme>;
+    readOnly?: boolean;
+    defautValue?: string;
+    error?: boolean;
+    onBlur?: () => void;
+}
+interface ITextEditorState$1 {
+    value: string;
+}
+declare class TextEditor extends Component<ITextEditorProps$1, ITextEditorState$1> {
+    constructor(props: ITextEditorProps$1);
+    handleChange: (value: string) => void;
+    id: number;
+    render(): react_jsx_runtime.JSX.Element;
+}
+
+type IModelBase = {
+    [key: string]: any;
+};
+declare enum SingleRuleValidate {
+    Required = "Required",
+    Regex = "Regex",
+    RequiredValue = "RequiredValue",
+    Array = "Array",
+    Number = "Number",
+    Email = "Email",
+    PhoneNumber = "PhoneNumber",
+    Url = "Url",
+    File = "File",
+    FileRequired = "FileRequired",
+    Custom = "Custom"
+}
+interface IRuleOptions {
+    File: {
+        maxSize: number;
+        all?: boolean;
+    };
+}
+declare const mapRuleOptions: <TK extends "File">(key: TK, options?: IRuleOptions[TK] | undefined) => IRuleOptions[TK] | undefined;
+interface IRuleOption<TModel = any> {
+    rule: SingleRuleValidate;
+    message?: string;
+    Value?: RegExp | ((value: any, model: TModel) => boolean) | number | Array<any> | boolean;
+    options?: any;
+}
+interface IConfigValue<TModel = any> {
+    Rules: IRuleOption<TModel>[];
+    label?: string;
+}
+interface IModelError {
+    message: string;
+    error: boolean;
+}
+type IFormValidatorConfig<TModel> = {
+    [key in keyof Extract<TModel, IModelBase>]?: IConfigValue<TModel>;
+};
+type IPartialError<TModel> = {
+    [key in keyof TModel]?: IRuleOption<TModel>[];
+};
+declare class FormValidator<TModel> {
+    configs: IFormValidatorConfig<TModel>;
+    constructor(configs: IFormValidatorConfig<TModel>);
+    static initial: <T>(configs: IFormValidatorConfig<T>) => FormValidator<T>;
+    AddRules: (key: keyof TModel, ...rule: IRuleOption<TModel>[]) => this;
+    Required: (RuleOption: IRuleOption, value: any) => boolean;
+    Regex: (RuleOption: IRuleOption, value: string, Regex: RegExp) => boolean;
+    RequiredValue: (RuleOption: IRuleOption, value: any) => boolean;
+    Custom: (RuleOption: IRuleOption, value: any, model: any) => boolean;
+    Array: (RuleOption: IRuleOption, value: any) => boolean;
+    Number: (RuleOption: IRuleOption, value: any) => boolean;
+    Email: (RuleOption: IRuleOption, value: any) => boolean;
+    PhoneNumber: (RuleOption: IRuleOption, value: any) => boolean;
+    Url: (RuleOption: IRuleOption, value: any) => boolean;
+    File: (RuleOption: IRuleOption, value: any) => boolean;
+    FileRequired: (RuleOption: IRuleOption, value: any) => boolean;
+    RenderMessage: (RuleOption: IRuleOption, key: string, label?: string) => IRuleOption<any>;
+    run: (model: TModel) => IPartialError<TModel>;
+    Executed: (Config: IConfigValue, valueField: any, model: any) => IRuleOption<any>[];
+}
+declare const createFormValidator: <TModel>() => FormValidator<Partial<TModel>>;
+
+interface IFormBase<TModel> {
+    data?: Partial<TModel>;
+    messageErrors: IPartialError<TModel>;
+    onBlur: (keyName: keyof TModel) => void;
+    disabled?: boolean;
+}
+interface IFormInputBase<TModel, TSlots = any> extends Partial<IFormBase<TModel>> {
+    name?: keyof TModel;
+    label?: React.ReactNode;
+    placeholder?: string;
+    defaultValue?: any;
+    slots?: TSlots;
+}
+
+interface ISelectWithApiOption<TOther = any> {
+    Id: string;
+    Name?: string;
+    Other?: TOther;
+}
+interface ISelectWithApiPropsSlots {
+    textFieldProps: TextFieldProps;
+}
+type ISelectWithApiFetchData<O extends ISelectWithApiOption> = (value?: string, signal?: AbortSignal) => Promise<O[]>;
+interface ISelectWithApiProps<T, O extends ISelectWithApiOption> extends IFormInputBase<T>, ISelectWithApiParams<O> {
+    onChange?: (value: O | null) => void;
+    existedIds?: string[];
+    slots?: ISelectWithApiPropsSlots;
+}
+interface ISelectWithApiParams<O extends ISelectWithApiOption> {
+    fetchData?: ISelectWithApiFetchData<O>;
+}
+
+interface InputBaseImage<T> extends Partial<IImageWithFallbackPropsOwner> {
+    srcValue?: (value: any, model?: Partial<T>) => string;
+    element?: React__default.ComponentType<{
+        value: any;
+        model?: Partial<T>;
+    }>;
+    mirror?: boolean;
+}
+interface IInputSlots<T> {
+    maxLength?: number;
+    textFieldProps?: TextFieldProps;
+    pastenable?: boolean;
+    imageLeft?: InputBaseImage<T>;
+    imageRight?: InputBaseImage<T>;
+}
+interface IInputProps<T> extends IFormInputBase<T> {
+    slots?: IInputSlots<T>;
+}
+interface IInputParams<T> extends IInputSlots<T> {
+}
+
+interface IDatePickerSlots {
+    defaultValue?: string;
+    minDate?: Dayjs;
+    minDateOffset?: number;
+    datePickerProps?: DatePickerProps<Dayjs>;
+}
+interface IDatePickerProps<T> extends IFormInputBase<T> {
+    format?: string;
+    slots?: Omit<IDatePickerSlots, 'defaultValue'>;
+}
+
+interface IFormGridLayoutConfig<T> {
+    key: keyof T;
+    label?: string;
+    placeholder?: string;
+    reponsives?: RegularBreakpoints;
+    defaultValue?: any;
+    inputElement?: React__default.ComponentType<IFormInputBase<T>>;
+}
+type SubmitMappingEvent<T> = (value: Partial<T>, oldValue?: T) => Partial<T>;
+interface IFormGridLayoutSlots<T> {
+    action?: React__default.ComponentType<IFormBase<T>>;
+    actionBefore?: JSX.Element;
+    contentBefore?: JSX.Element;
+    contentAfter?: JSX.Element;
+    inputVisibility?: Partial<Record<keyof T, boolean>>;
+    inputDisabled?: Partial<Record<keyof T, boolean>>;
+    closeState?: {
+        Success?: boolean;
+        Fail?: boolean;
+    };
+    contentProps?: BoxProps;
+}
+interface IFormGridLayoutParams<T> extends IFormGridLayoutSlots<T> {
+    configs: IFormGridLayoutConfig<T>[];
+    validate: FormValidator<Partial<T>>;
+    submitMapping?: SubmitMappingEvent<T>;
+}
+interface IFormGridLayoutProps<T> {
+    data?: T;
+    onSubmit: (value: Partial<T>, signal?: AbortSignal) => Promise<void>;
+    onError?: (error: any) => void;
+    onClose?: () => void;
+    sx?: SxProps<Theme>;
+    slots?: IFormGridLayoutSlots<T>;
+}
+
+interface IFormComfirmParam<T> {
+    title?: string;
+    content: (value?: T) => JSX.Element;
+    colors?: {
+        yes?: 'inherit' | 'error' | 'primary' | 'secondary' | 'success' | 'info' | 'warning';
+        no?: 'inherit' | 'error' | 'primary' | 'secondary' | 'success' | 'info' | 'warning';
+    };
+}
+interface IFormComfirmProps<T> {
+    data?: T;
+    title?: string;
+    onSubmit: (value?: T) => Promise<void>;
+    onCancel?: () => void;
+}
+
+interface FormBaseParam<TModel> {
+    validate?: FormValidator<Partial<TModel>>;
+}
+interface FormBaseProps<TModel> extends PropsWithChildren {
+    sx?: SxProps<Theme>;
+    validate?: FormValidator<Partial<TModel>>;
+    onSubmit: (data: Partial<TModel>, e: React__default.FormEvent<HTMLFormElement>) => Promise<void>;
+}
+interface IFormContextBase<TModel> {
+    modelState?: Partial<TModel>;
+    messageErrors: IPartialError<TModel>;
+    onBlur: (keyName: keyof TModel) => void;
+    setError: (keyName: keyof TModel, message: string) => void;
+    clearErrorAll: (keyName: keyof TModel) => void;
+}
+interface FormBaseResult<TModel> {
+    Form: ComponentType<FormBaseProps<TModel>>;
+    Validator?: FormValidator<Partial<TModel>>;
+    Context: React__default.Context<IFormContextBase<TModel>>;
+    contextMapping: (params: (context: IFormContextBase<TModel>) => JSX.Element) => JSX.Element;
+}
+
+interface IFormModalWrapperProps extends PropsWithChildren {
+    title: string;
+    size?: Breakpoint;
+    fullHeight?: boolean;
+    onCloseClick?: () => void;
+    slots?: {
+        sxTopbarProps?: SxProps<Theme>;
+        beforeTitle?: JSX.Element;
+    };
+}
+
+interface IInputFileParams {
+    accept?: string;
+    multiple?: boolean;
+}
+declare function CreateInputFile<T>(params?: IInputFileParams): ComponentType<IFormInputBase<T>>;
+
+interface ITextEditorParams {
+    id: string;
+    title: string;
+}
+interface ITextEditorProps<T> extends IFormInputBase<T> {
+}
+interface ITextEditorState {
+    isFullscreen: boolean;
+}
+declare function CreateTextEditor<T>(params: ITextEditorParams): {
+    new (props: ITextEditorProps<T>): {
+        contentRef: React__default.RefObject<HTMLDivElement | null>;
+        componentDidMount(): void;
+        componentWillUnmount(): void;
+        handleFullscreenChange: () => void;
+        handleFullscreenToggle: () => void;
+        getWrapClasses: () => string;
+        render(): react_jsx_runtime.JSX.Element;
+        context: unknown;
+        setState<K extends "isFullscreen">(state: ITextEditorState | ((prevState: Readonly<ITextEditorState>, props: Readonly<ITextEditorProps<T>>) => ITextEditorState | Pick<ITextEditorState, K> | null) | Pick<ITextEditorState, K> | null, callback?: (() => void) | undefined): void;
+        forceUpdate(callback?: (() => void) | undefined): void;
+        readonly props: Readonly<ITextEditorProps<T>>;
+        state: Readonly<ITextEditorState>;
+        refs: {
+            [key: string]: React__default.ReactInstance;
+        };
+        shouldComponentUpdate?(nextProps: Readonly<ITextEditorProps<T>>, nextState: Readonly<ITextEditorState>, nextContext: any): boolean;
+        componentDidCatch?(error: Error, errorInfo: React__default.ErrorInfo): void;
+        getSnapshotBeforeUpdate?(prevProps: Readonly<ITextEditorProps<T>>, prevState: Readonly<ITextEditorState>): any;
+        componentDidUpdate?(prevProps: Readonly<ITextEditorProps<T>>, prevState: Readonly<ITextEditorState>, snapshot?: any): void;
+        componentWillMount?(): void;
+        UNSAFE_componentWillMount?(): void;
+        componentWillReceiveProps?(nextProps: Readonly<ITextEditorProps<T>>, nextContext: any): void;
+        UNSAFE_componentWillReceiveProps?(nextProps: Readonly<ITextEditorProps<T>>, nextContext: any): void;
+        componentWillUpdate?(nextProps: Readonly<ITextEditorProps<T>>, nextState: Readonly<ITextEditorState>, nextContext: any): void;
+        UNSAFE_componentWillUpdate?(nextProps: Readonly<ITextEditorProps<T>>, nextState: Readonly<ITextEditorState>, nextContext: any): void;
+    };
+    contextType?: React__default.Context<any> | undefined;
+};
+
+interface IDateExpiredSlots<T> {
+    /** @default string */
+    type?: 'number' | 'string';
+    textFieldProps?: Partial<TextFieldProps>;
+    switchChecked?: boolean;
+    switchCheckedGetter?: (value: any, model?: Partial<T>) => boolean;
+}
+interface IDateExpiredProps<T> extends IFormInputBase<T> {
+    slots?: IDateExpiredSlots<T>;
+}
+declare function CreateDateExpired<T>(params?: IDateExpiredSlots<T>): React__default.ComponentType<IDateExpiredProps<T>>;
+
+interface ISelectSimpleOption<T extends string = string> {
+    name: string;
+    value: T;
+}
+interface ISelectSimpleSlots {
+    selectProps?: Omit<SelectProps, 'variant'>;
+}
+interface ISelectSimpleProps<T> extends Partial<IFormInputBase<T>> {
+    options?: ISelectSimpleOption[];
+    onChange?: (value: ISelectSimpleOption) => void;
+    slots?: ISelectSimpleSlots;
+    fullWidth?: boolean;
+}
+interface ISelectSimpleParams extends ISelectSimpleSlots {
+    options?: ISelectSimpleOption[];
+}
+declare function CreateSelectSimple<T>(args?: ISelectSimpleParams): ComponentType<ISelectSimpleProps<T>>;
+
+interface IAutocompleteChipParams {
+    optionItems?: string[];
+    limitTags?: number;
+    separator?: string;
+    saveLocalStorageByKey?: string;
+}
+interface IAutocompleteChipProps<T> extends IFormInputBase<T, IAutocompleteChipParams> {
+}
+declare function CreateAutocompleteChip<T>(params?: IAutocompleteChipParams): ComponentType<IAutocompleteChipProps<T>>;
+
+declare class DinoFormBase {
+    ModalWrap: React$1.FC<IFormModalWrapperProps>;
+    BottomBarWrap: any;
+    FormValidator: typeof FormValidator;
+    validator: <T>(configs: IFormValidatorConfig<T>) => FormValidator<T>;
+    createFormBase: <TModel>(param?: FormBaseParam<TModel> | undefined) => FormBaseResult<TModel>;
+    createFormComfirm: <T = any>(param?: IFormComfirmParam<T> | undefined) => React$1.ComponentType<React$1.PropsWithChildren<IFormComfirmProps<T>>>;
+    createFormGridLayout: <T>(params: IFormGridLayoutParams<T>) => React$1.ComponentType<IFormGridLayoutProps<T>>;
+    createDateExpired: typeof CreateDateExpired;
+    createDatePicker: <T extends Object>(params?: IDatePickerSlots | undefined) => React$1.ComponentType<IDatePickerProps<T>>;
+    createAutocompleteChip: typeof CreateAutocompleteChip;
+    createInput: <T>(params?: IInputParams<T> | undefined) => React$1.ComponentType<IInputProps<T>>;
+    createInputFile: typeof CreateInputFile;
+    createSelectSimple: typeof CreateSelectSimple;
+    createSelectWithApi: <T, O extends ISelectWithApiOption<any> = ISelectWithApiOption<any>>(params?: ISelectWithApiParams<O> | undefined) => React$1.ComponentType<ISelectWithApiProps<T, O>>;
+    createTextEditor: typeof CreateTextEditor;
+}
+declare const DinoForm: DinoFormBase;
+
+declare const getErrorMessage: <TModel>(MessageErrors: IPartialError<TModel> | undefined, key?: keyof TModel | undefined) => IModelError;
+declare const convertFormDataToJson: <TModel>(form: FormData) => Partial<TModel>;
+
+declare const useCheckScrolled: () => {
+    isScrolled: boolean;
+};
+declare const useDebounce: <T>(value: T, delay: number) => T;
+
+declare enum ELazyStatus {
+    Loading = "Loading",
+    Loaded = "Loaded",
+    Error = "Error"
+}
+interface IDinoReduxState {
+    status: ELazyStatus;
+    requestedId?: string;
+}
+interface IReturnDispatch {
+    abort?: () => void;
+}
+interface IDinoReduxDispatch<P = any> {
+    fetchData?: (params?: P, signal?: AbortSignal) => IReturnDispatch;
+    setStatus: (status: ELazyStatus) => void;
+}
+interface IBaseActions<T, Id extends keyof T> {
+    create: (value: Partial<T>, signal?: AbortSignal) => Promise<void>;
+    update: (id: T[Id], value: Partial<T>, signal?: AbortSignal) => Promise<void>;
+    delete: (id: T[Id], value?: Partial<T>, signal?: AbortSignal) => Promise<void>;
+}
+type IDinoReduxActions<T, Id extends keyof T, K extends keyof IBaseActions<T, Id> = keyof IBaseActions<T, Id>> = Pick<IBaseActions<T, Id>, K>;
+
+interface IErrorViewDefaultProps {
+}
+interface IHocLazyWrapperProps extends PropsWithChildren {
+    loading?: boolean;
+    backdrop?: boolean;
+}
+
+interface IHocLazyBase<T> extends IDinoReduxState, IDinoReduxDispatch<T> {
+}
+interface IHocLazyBaseOptions {
+    ErrorScreen?: React__default.ComponentType<IErrorViewDefaultProps>;
+    LazySpinner: React__default.ComponentType<PropsWithChildren<IHocLazyWrapperProps>>;
+}
+interface IHocLazyOtherProps<T> {
+    param?: T;
+}
+interface IHocLazyOptions<T> extends IHocLazyOtherProps<T>, Omit<IHocLazyBaseOptions, 'LazySpinner'> {
+    LazySpinner?: React__default.ComponentType<PropsWithChildren<IHocLazyWrapperProps>>;
+}
+declare const EmptyComponent: React__default.FC<React__default.PropsWithChildren<any>>;
+declare const defaultOptionHocLazy: IHocLazyBaseOptions;
+declare const CreateHocLazy: <P extends IHocLazyBase<T>, T = any>(ChildComponent: React__default.ComponentType<P>, options?: IHocLazyOptions<T> | undefined) => React__default.ComponentType<P>;
+
+declare class DinoReduxBase {
+    createHocLazy: <P extends IHocLazyBase<T>, T = any>(ChildComponent: React$1.ComponentType<P>, options?: IHocLazyOptions<T> | undefined) => React$1.ComponentType<P>;
+}
+declare const DinoRedux: DinoReduxBase;
+
+type ICustomGridColDef<T extends GridValidRowModel> = {
+    [key in keyof T]?: Omit<GridColDef, 'field'>;
+};
+type ITableQueryDetail = 'filter' | 'quickSearch' | 'sort' | 'pagination' | undefined;
+interface ICustomGridSortItem<T> {
+    field: keyof T;
+    sort: GridSortDirection;
+}
+type ICustomGridSortModel<T> = ICustomGridSortItem<T>[];
+interface ICustomGridFilterItem<T> {
+    id?: number | string;
+    field: keyof T;
+    value?: any;
+    operator: GridLogicOperator;
+}
+interface ICustomGridFilterModel<T> {
+    items: ICustomGridFilterItem<T>[];
+    logicOperator?: GridLogicOperator;
+    quickFilterValues?: any[];
+    quickFilterLogicOperator?: GridLogicOperator;
+    quickFilterExcludeHiddenColumns?: boolean;
+}
+interface ITableQueryParams<T> {
+    pagination?: GridPaginationModel;
+    filter?: ICustomGridFilterModel<T>;
+    sort?: ICustomGridSortModel<T>;
+    loading?: boolean;
+    detail?: ITableQueryDetail;
+}
+interface ITableData<T> {
+    items?: T[];
+    rowTotal?: number;
+}
+interface ITableState<T> {
+    tableData: ITableData<T>;
+    tableQueryParams: ITableQueryParams<T>;
+    tableQueryThunk: ITableQueryParams<T>;
+}
+type ITableStateRedux<T, K extends keyof ITableState<T> = keyof ITableState<T>> = Pick<ITableState<T>, K>;
+
+declare enum ELogic {
+    And = 0,
+    Or = 1
+}
+declare enum EOperator {
+    GreaterThan = 0,
+    LessThan = 1,
+    GreaterThanOrEqual = 2,
+    LessThanOrEqual = 3,
+    NotEqual = 4,
+    Equal = 5,
+    Contains = 6
+}
+declare enum EOrder {
+    Ascending = 0,
+    Descending = 1
+}
+interface IFieldFilter<T> {
+    Logic?: ELogic;
+    Operator?: EOperator;
+    FieldName: keyof T;
+    Value: string;
+}
+interface IScopeFilter<T> {
+    Logic?: ELogic;
+    Scopes: IPropFilter<T>[];
+}
+type IPropFilter<T> = IFieldFilter<T> | IScopeFilter<T>;
+interface IPropOrderBy<T> {
+    Type: EOrder;
+    FieldName: keyof T;
+}
+interface IModelFilter<T> {
+    Page?: number;
+    Amount?: number;
+    PropFilters?: IPropFilter<T>[];
+    PropOrders?: IPropOrderBy<T>[];
+}
+
+interface ITableBaseContext {
+    showModal: TShowModal;
+    closeModal: TCloseModal;
+}
+
+interface IActionRowProps<T> {
+    value: T;
+    formEdit?: (value: T, tableContext: ITableBaseContext) => React__default.ReactNode;
+    formDelete?: (value: T, tableContext: ITableBaseContext) => React__default.ReactNode;
+    after?: (value: T, tableContext: ITableBaseContext) => React__default.ReactNode;
+    before?: (value: T, tableContext: ITableBaseContext) => React__default.ReactNode;
+    wrapProps?: BoxProps;
+    buttonEditConfig?: GlobalModalState;
+    buttonDeleteConfig?: GlobalModalState;
+}
+declare function CreateActionRow<T>(params?: Omit<IActionRowProps<T>, 'value'>): ComponentType<IActionRowProps<T>>;
+
+interface IToolbarPannelOptions {
+    searchInclude?: string[];
+    formCreate?: React__default.ReactNode;
+    afterAction?: React__default.ReactNode;
+    breadcrumbs?: IBreadcrumbConfig[];
+}
+interface IToolbarPannelProps extends IToolbarPannelOptions {
+    title?: React__default.ReactNode;
+    afterTitle?: React__default.ReactNode;
+}
+declare class ToolbarPannel extends Component<React__default.PropsWithChildren<IToolbarPannelProps>> {
+    render(): react_jsx_runtime.JSX.Element;
+    renderTitle: () => react_jsx_runtime.JSX.Element;
+    renderEndAdornment: () => react_jsx_runtime.JSX.Element;
+}
+
+interface ITableSlots<T> {
+    maxSelection?: number;
+    density?: GridDensity;
+    toolbar?: React__default.ComponentType<IToolbarPannelProps>;
+    actionRow?: React__default.ComponentType<IActionRowProps<T>>;
+    toolbarProps?: IToolbarPannelProps;
+    dataGridProps?: DataGridProps;
+}
+type ITableParamsSlots<T> = Pick<ITableSlots<T>, 'maxSelection' | 'toolbarProps' | 'dataGridProps'>;
+interface ITableProps<T> {
+    data?: ITableData<T>;
+    query?: ITableQueryParams<T>;
+    onChange?: (query: ITableQueryParams<T>) => void;
+    onRowSelectionChange?: DataGridProps['onRowSelectionModelChange'];
+    slots?: ITableSlots<T>;
+}
+interface ITableParams<T extends GridValidRowModel> extends ITableParamsSlots<T> {
+    featureMode?: GridFeatureMode;
+    getRowId: GridRowIdGetter<T>;
+    columns: ICustomGridColDef<T>;
+    filterOperators?: (config: GridColDef) => GridFilterOperator[];
+    columnVisibilityModel?: Partial<Record<keyof T, boolean>>;
+    actionRow?: Omit<GridColDef, 'field'>;
+}
+declare function CreateTable<T extends GridValidRowModel>(params: ITableParams<T>): ComponentType<ITableProps<T>>;
+
+type IStatusCellConfig<T extends string> = {
+    [key in T]: SxProps<Theme>;
+};
+interface IStatusCellOptions {
+    sx?: SxProps<Theme>;
+}
+interface IStatusCellProps<T extends string> extends PropsWithChildren {
+    value?: T;
+    title?: string;
+    sx?: SxProps<Theme>;
+    onClick?: TypographyProps['onClick'];
+    slots?: {
+        typographyProps?: TypographyProps;
+    };
+}
+interface CellBaseOptions {
+    openInNewTab?: boolean;
+    beforeLine?: boolean;
+    copyToClipboard?: boolean;
+    imageUrl?: string;
+    imageFallbackSrc?: string;
+    valueFormatter?: (value?: string) => string;
+    wrapProps?: BoxProps;
+    typographyProps?: TypographyProps;
+}
+interface CellChipsProps {
+    value?: string;
+    separator?: string;
+    maximum?: number;
+}
+interface CellDatePropsOwner {
+    formatString?: string;
+    showRelative?: boolean;
+    typographyProps?: TypographyProps;
+    styledGetter?: (value: any) => SxProps<Theme>;
+}
+
+interface IBtnFormDetailProps {
+    formDetail: React__default.ReactNode;
+    onOpenModal?: (event: React__default.MouseEvent<HTMLButtonElement, MouseEvent>) => void;
+    onCloseModal?: (reason?: TModalReason) => void;
+}
+interface IBtnDetailProps {
+    onClick?: IconButtonProps['onClick'];
+}
+
+type RenderCellBaseParams<T> = Omit<CellBaseOptions, 'imageUrl'> & {
+    imageUrl?: (value: any, model: T) => string;
+    valueFormatter?: (value: any, model: T) => string;
+};
+interface FormatterDateOptions {
+    formatString?: string;
+    showRelative?: boolean;
+}
+declare class DinoTableBase {
+    createTable: typeof CreateTable;
+    createActionRow: typeof CreateActionRow;
+    setUrlQuery: <TModel>(tableInfo: Partial<ITableQueryParams<TModel>>, defaultValue: ITableQueryParams<TModel>) => void;
+    getUrlQuery: <TModel>(defaultValue: ITableQueryParams<TModel>) => ITableQueryParams<TModel>;
+    mapContext: (context: (context: ITableBaseContext) => React$1.ReactNode) => react_jsx_runtime.JSX.Element;
+    ToolbarPannel: typeof ToolbarPannel;
+    createToolbar: (props: IToolbarPannelProps) => FC<IToolbarPannelProps>;
+    BtnFormDetail: FC<IBtnFormDetailProps>;
+    BtnDetail: FC<IBtnDetailProps>;
+    createBreadcrumbConfigs: (value: IBreadcrumbConfig[]) => IBreadcrumbConfig[];
+    createBreadcrumbs: (value: IBreadcrumbConfig[]) => FC;
+    createStatusCell: <T extends string>(config: IStatusCellConfig<T>, options?: IStatusCellOptions | undefined) => React$1.ComponentType<IStatusCellProps<T>>;
+    formatterDate: (value: any, options?: FormatterDateOptions) => string;
+    valueFormatterDate: (options?: FormatterDateOptions) => (params: GridValueFormatterParams<any>) => string;
+    renderCellChips: (params?: CellChipsProps) => (tableRow: GridRenderCellParams<any, any, any, GridTreeNodeWithRender>) => react_jsx_runtime.JSX.Element;
+    renderCellStatus: <E extends string>(config: IStatusCellConfig<E>, options?: IStatusCellOptions) => (tableRow: GridRenderCellParams<any, any, any, GridTreeNodeWithRender>) => react_jsx_runtime.JSX.Element;
+    renderCellBase: <T = any>(options?: RenderCellBaseParams<T> | undefined) => (tableRow: GridRenderCellParams<any, any, any, GridTreeNodeWithRender>) => react_jsx_runtime.JSX.Element;
+    renderCellImage: <T>(selectImage: (value: T) => T[keyof T], options?: {
+        fallbackSrc?: string;
+    }) => (tableRow: GridRenderCellParams<any, any, any, GridTreeNodeWithRender>) => react_jsx_runtime.JSX.Element;
+    renderCellDate: (params?: CellDatePropsOwner) => (tableRow: GridRenderCellParams<any, any, any, GridTreeNodeWithRender>) => react_jsx_runtime.JSX.Element;
+}
+declare const DinoTable: DinoTableBase;
+
+declare const dinoTableClasses: {
+    whiteSpacePre: string;
+};
+
+declare const sleep: (sec: number) => Promise<unknown>;
+declare const fetchDelay: <TModel>(action: () => Promise<TModel>, sec: number) => Promise<TModel>;
+declare const windowScrollToTop: (options?: ScrollToOptions, delay?: number) => void;
+declare const mergeClasses: (...classes: string[]) => string;
+declare const encodeBase64: (input: string) => string;
+declare const decodeBase64: (encoded: string) => string | undefined;
+declare const tryParseObject: <T>(value: any, defaultValue: T) => T;
+declare const tryParseArray: <T>(value: any, defaultValue?: T[]) => T[];
+declare const tryParseIntRequired: (value: any, defaultValue: number) => number;
+type DeepPartial<T> = {
+    [P in keyof T]?: T[P] extends object ? DeepPartial<T[P]> : T[P];
+} | undefined;
+declare const mergeObjects: <T>(...objects: DeepPartial<T>[]) => T;
+declare const formatFileSize: (sizeInKb: number) => string;
+declare const formatCurrency: (value?: any, prefix?: string, suffix?: string) => string;
+declare const formatNumberWithCommas: (number: number) => string;
+declare const formatCapitalizeFirstText: (value?: string) => string;
+declare const formatDatetimeStyle: {
+    style1: string;
+    style2: string;
+    style3: string;
+};
+/**
+ * Formats a datetime string using one of the predefined styles.
+ *
+ * Available format styles:
+ * - style1: DD/MM/YYYY HH:mm → e.g., '25/04/2025 14:30'
+ * - style2: 'MMMM D, YYYY' → e.g., 'April 25, 2025'
+ * - style2: 'MM-DD-YYYY' → e.g., '04-25-2025'
+ * @param value - A datetime string (ISO format or any format parsable by dayjs).
+ * @param format - Format style key: 'style1' or 'style2'. Defaults to 'style1'.
+ * @returns A formatted datetime string, or 'unknown' if the input is invalid or unparsable.
+ */
+declare const formatDatetime: (value: string, format?: keyof typeof formatDatetimeStyle) => string;
+
+declare class JObject {
+    private value;
+    constructor(value?: any);
+    static fromJson(value?: any): JObject;
+    toValue: <T extends Record<string, any>, TK extends keyof T = keyof T>(key: TK) => T[TK] | undefined;
+    toJObject: <T extends Record<string, any>, TK extends keyof T = keyof T>(key: TK) => JObject;
+    setValue: <T extends Record<string, any>, TK extends keyof T = keyof T>(key: TK, value: any) => void;
+    toObject: <T>() => Partial<T>;
+}
+
+declare class QueryParamBase {
+    private _GetValues;
+    private _GetValuesMap;
+    private _GetkeysMap;
+    private getPath;
+    stringify: <TParam extends Record<string, any> = any>(param: TParam) => string;
+    Replace<TParam extends {} = any, TState = any>(param: TParam, state?: TState): void;
+    Patch<TParam extends {
+        [key: string]: any;
+    } = any, TState = any>(param: TParam, state?: TState): void;
+    ReplacePatch<TParam extends {
+        [key: string]: any;
+    } = any, TState = any>(param: TParam, state?: TState): void;
+    Put<TParam extends {} = any, TState = any>(param: TParam, state?: TState): void;
+    Deletes<TValue extends {} = any>(...keys: (keyof TValue)[]): void;
+    ReplaceDeletes<TValue extends {} = any>(...keys: (keyof TValue)[]): void;
+    ReplaceDeletesWithState<TValue extends {} = any, TState = any>(keys: (keyof TValue)[], state?: TState): void;
+    DeletesWithState<TValue extends {} = any, TState = any>(keys: (keyof TValue)[], state?: TState): void;
+    DeleteAll(): void;
+    GetAll: () => queryString.ParsedQuery<string>;
+    Gets<TValue extends {} = any>(...keys: (keyof TValue)[]): Partial<TValue>;
+}
+declare const QueryParam: QueryParamBase;
+
+export { AlertDialog, AlertGlobal, ApiAlertContext, ApiPopover, ApiPopoverContext, Breadcrumbs, CopyToClipboard, CreateHocLazy, CreateTable, DinoForm, DinoRedux, DinoTable, DrawerGlobal, ELazyStatus, ELogic, EOperator, EOrder, EmptyComponent, FormValidator, GlobalModal, GlobalModalContext, HelpTooltip, HelpTooltipWrap, ImageWithFallback, JObject, MapApiPopoverContext, MapGlobalModalContext, MapPopoverGlobalContext, PopoverGlobal, PopoverGlobalApi, PopoverGlobalContext, PopoverGlobalProvider, QueryParam, SingleRuleValidate, TextEditor, TextEditorPreview, convertFormDataToJson, createFormValidator, decodeBase64, defaultOptionHocLazy, dinoTableClasses, encodeBase64, fetchDelay, formatCapitalizeFirstText, formatCurrency, formatDatetime, formatFileSize, formatNumberWithCommas, getErrorMessage, mapRuleOptions, mergeClasses, mergeObjects, sleep, textEditorClasses, tryParseArray, tryParseIntRequired, tryParseObject, useCheckScrolled, useDebounce, windowScrollToTop, withApiGlobalModalConsumerContext, withApiGlobalModalContext, withApiPopoverContext, withPopoverGlobalContext };
+export type { ClosePopover, GlobalModalState, IActionRowProps, IApiContext, IApiGlobalModalContextProps, IApiPopoverContext, IApiPopoverContextProps, IBaseActions, IBreadcrumbConfig, IBreadcrumbsProps, IConfigValue, ICopyToClipboardProps, ICopyToClipboardState, ICustomGridColDef, ICustomGridFilterItem, ICustomGridFilterModel, ICustomGridSortItem, ICustomGridSortModel, IDinoReduxActions, IDinoReduxDispatch, IDinoReduxState, IFieldFilter, IFormBase, IFormInputBase, IFormValidatorConfig, IGlobalModalContext, IHelpTooltipProps, IHelpTooltipWrapProps, IHocLazyBase, IHocLazyBaseOptions, IHocLazyOptions, IHocLazyOtherProps, IImageProps, IImageWithFallbackProps, IImageWithFallbackPropsOwner, IMapGlobalModal, IModelBase, IModelError, IModelFilter, IPartialError, IPopoverGlobalContextProps, IPopoverOptions, IPropFilter, IPropOrderBy, IReturnDispatch, IRuleOption, IRuleOptions, IScopeFilter, ISelectWithApiOption, IStatusCellConfig, ITableData, ITableQueryDetail, ITableQueryParams, ITableState, ITableStateRedux, ITextEditorProps$1 as ITextEditorProps, ITextEditorState$1 as ITextEditorState, InputBaseImage, OpenPopover, PopoverGlobalState, TCloseModal, TClosePopover, TModalReason, TShowModal, TShowPopover };