import * as React from 'react';
import React__default, { ReactNode, Dispatch, SetStateAction, JSX } from 'react';
import { UseFormSetValue, UseFormGetValues, UseFormReset, Control, UseFormWatch, FieldErrors } from 'react-hook-form';
import { TFunction } from 'react-i18next';
import * as react_jsx_runtime from 'react/jsx-runtime';

/** Căn lề văn bản trong bảng */
type ITextAlign = "center" | "left" | "right";
/**
 * Loại cột hiển thị trong hệ thống.
 *
 * Lưu ý:
 * - Các loại 'text', 'numeric', 'datetime' không được dùng cho view.
 */
type IColumnType = "#" | "command" | "text" | "numeric" | "datetime" | "date" | "checkbox" | "select" | "form" | "formInline" | "color" | "selectTree";
/** Loại lọc của cột */
type IFilterType = "text" | "numeric" | "date" | "select";
/** Cấu hình thao tác trên cột */
type ICommandItem = {
    /** ID thao tác */
    id: string;
    /** Màu hiển thị thao tác */
    color?: string;
    /** Tooltip mô tả thao tác */
    tooltip?: string;
    /** Icon đại diện thao tác */
    icon?: string;
    /** Template hiển thị thao tác */
    commandTemplate?: ReactNode;
};
/** Cấu hình thanh công cụ (toolbar) */
type IFToolbarOptions = {
    /** Vị trí hiển thị (trái, phải, giữa) */
    align: "left" | "right" | "center";
    /** Template toolbar */
    template: any;
};
/** Cấu hình thiết lập bảng */
type IFSettingColumns = {
    /** Tên thuộc tính */
    field: string;
    /** Tiêu đề hiển thị ở header */
    headerText?: string;
    /** Có hiển thị không */
    visible?: boolean;
    /** Cố định trái/phải */
    fixedType?: "left" | "right";
    /** Chiều rộng cột */
    width?: number | string;
};
/** Cấu hình phần tử form khi dùng loại cột `form` */
type ISettingFormElement = {
    /** Schema định nghĩa cấu trúc form */
    schema: any;
    /** Kích thước nhãn */
    labelSize?: "label-small" | "label-medium" | "label-large";
    /** Chiều rộng popup form */
    menuWidth?: number;
    /** Chiều cao popup form */
    menuHeight?: number;
    /** Giá trị hiển thị */
    displayValue?: any;
    /** Tự mở khi focus */
    openOnFocus?: boolean;
    /** Cho phép xóa giá trị */
    isClearable?: boolean;
    /** Sự kiện mở form */
    onFormOpen?: (rowData: any, itemsField: FromItemsField[], setItemsField: Dispatch<SetStateAction<FromItemsField[]>>) => void;
    /** Sự kiện submit form */
    onFormSubmit?: (rowData: any, setValue: UseFormSetValue<any>, getValues: UseFormGetValues<any>, reset: UseFormReset<any>) => void;
    /** Footer tùy chỉnh trong form */
    footerTemplate?: (rowData: any) => JSX.Element;
    /** Sự kiện thay đổi trường dữ liệu */
    onChangeField?: (rowData: any, field: string, setValue: UseFormSetValue<any>, getValues: UseFormGetValues<any>) => void;
    /** Sự kiện thay đổi form */
    onChange?: (rowData: any) => void;
};
/** Cấu hình cho cột kiểu `select` */
type ISettingSelectElement = {
    /** Cho phép xóa giá trị */
    isClearable?: boolean;
    /** Cho phép chọn nhiều */
    isMulti?: boolean;
    /** Không hiển thị header */
    noHeader?: boolean;
    /** Hiển thị footer */
    showFooter?: boolean;
    /** Tự động chọn các con */
    selectChilds?: boolean;
    /** Cho phép thêm mới */
    allowCreate?: boolean;
    /** Giá trị mặc định */
    defaultValue?: any;
    /** Trường lấy giá trị */
    fieldValue?: string;
    /** Trường hiển thị nhãn */
    fieldLabel?: string;
    /** Trường con */
    fieldChild?: string;
    /** Danh sách options */
    options?: any[];
    /** Chiều rộng popup chọn */
    widthPopup?: string | number;
    /** Chiều cao popup chọn */
    heightPopup?: string | number;
    /** Icon của nhóm chọn */
    iconGroup?: string;
    /** Sự kiện thêm mới */
    handAddNew?: any;
    /** Hàm validate option */
    validateOption?: any;
    /** Trường lấy options */
    optionsField?: string;
    /** Danh sách cột hiển thị trong bảng chọn */
    columns?: IFColumnSelectTable[];
    /** Tuỳ chỉnh hiển thị option */
    formatOptionLabel?: (ele: any) => JSX.Element;
    /** Component footer trong menu chọn */
    footerComponent?: () => JSX.Element;
    /** Load options động */
    loadOptions?: (keyword: string, callback: (rs: any[]) => void) => void;
    /** Sự kiện mở menu */
    onOpenMenu?: (row: any, col: IColumnTable, indexRow: number) => void;
    /** Tuỳ chỉnh xác định hàng được chọn */
    compareFunction?: (rowOption?: any, rowData?: any) => boolean;
};
/** Cấu hình cho kiểu số */
type ISettingNumericElement = {
    /** Giá trị nhỏ nhất */
    min?: number;
    /** Giá trị lớn nhất */
    max?: number;
    /** Số chữ số thập phân */
    fraction?: number;
    /** Cho phép giá trị âm */
    allowNegative?: boolean;
};
/** Định nghĩa cột bảng */
type IColumnTable = {
    /** Tên thuộc tính */
    field: string;
    /** Tên thuộc tính lọc*/
    fieldFilter?: string;
    /** Tiêu đề hiển thị ở header */
    headerText?: string;
    /** Khóa chính */
    isPrimarykey?: boolean;
    /** Duy nhất trong bảng */
    isUnikey?: boolean;
    /** Có tính tổng */
    haveSum?: boolean;
    /** Có tooltip */
    haveToolTip?: boolean;
    /** Chiều rộng cột */
    width?: number | string;
    /** Chiều rộng tối thiểu */
    minWidth?: number | string;
    /** Chiều rộng tối đa */
    maxWidth?: number | string;
    /** Cho phép chỉnh sửa */
    editEnable?: boolean;
    /** Có hiển thị không */
    visible?: boolean;
    /** Kiểu chỉnh sửa */
    type?: IColumnType;
    /** Căn lề */
    textAlign?: ITextAlign;
    /** Cố định trái/phải */
    fixedType?: "left" | "right" | undefined;
    /** Danh sách thao tác */
    commandItems?: ICommandItem[];
    /** Placeholder trong ô input */
    placeholder?: string;
    /** Cấu hình cho kiểu numeric */
    numericSettings?: ISettingNumericElement;
    /** Cấu hình cho kiểu select */
    selectSettings?: ISettingSelectElement;
    /** Cấu hình cho kiểu form */
    formSettings?: ISettingFormElement;
    /** Danh sách cột con */
    columns?: IColumnTable[];
    /** Không cho phép dán giá trị */
    disablePaste?: boolean;
    /** Kiểu lọc cột */
    filterType?: IFilterType;
    /** Cho phép lọc cột */
    allowFilter?: boolean;
    /**Giá trị trường callback khi copy xuống các dòng dưới */
    callbackValue?: (row: any) => any;
    /** Validate giá trị */
    validate?: (value: any, row: any) => string | undefined;
    /** Điều kiện disable cột */
    disabledCondition?: (row: any) => boolean;
    /** Callback khi thay đổi giá trị */
    callback?: (value: any, indexRow: number, item: any) => void;
    /** Template hiển thị khi không ở chế độ edit */
    template?: (row: any, indexRow: number) => JSX.Element | string | number | undefined;
    /** Xác định loại edit dựa trên điều kiện */
    typeCondition?: (row: any) => string;
    /** Sự kiện khi paste dữ liệu */
    onPaste?: (dataRow: any, dataPaste: any) => void;
    /** Xác thực dữ liệu được paste */
    onPasteValidate?: (dataPaste: string, dataRow: any, rowIndex: number) => Promise<any>;
    /**Không có tác dụng */
    rowspan?: number;
};
/** Cấu hình phân trang */
type IFTableEditPaging = {
    /** Bật phân trang */
    allowPaging?: boolean;
    /** Phân trang phía client */
    pagingClient?: boolean;
    /** Trang hiện tại */
    currentPage?: number;
    /** Hàm cập nhật trang hiện tại */
    setCurrentPage?: Dispatch<SetStateAction<number>>;
    /** Hàm cập nhật số dòng mỗi trang */
    setPageSize?: Dispatch<SetStateAction<number>>;
    /** Số dòng mỗi trang */
    pageSize?: number;
    /** Tổng số dòng */
    totalItem?: number;
    /** Các lựa chọn số dòng/trang */
    pageOptions?: number[];
};
/** Cấu hình các nút thao tác trên bảng */
type IFTableEditButton = {
    /** Vô hiệu hóa nút xóa tất cả */
    deleteAllDisable?: boolean;
    /** Vô hiệu hóa nút chèn sau */
    insertAfterDisable?: boolean;
    /** Vô hiệu hóa nút chèn trước */
    insertBeforeDisable?: boolean;
    /** Vô hiệu hóa nút nhân bản */
    duplicateDisable?: boolean;
};
/** Cấu hình toolbar bảng */
type IFTableEditToolbar = {
    /** Hiển thị thanh công cụ trên */
    showTopToolbar?: boolean;
    /** Danh sách toolbar trên */
    toolbarOptions?: IFToolbarOptions[];
    /** Danh sách toolbar dưới */
    toolbarBottomOptions?: IFToolbarOptions[];
    /** Hiển thị thanh công cụ dưới */
    showBottomToolbar?: boolean;
};
/** Cấu hình tìm kiếm trong bảng */
type IFTableEditSearchSetting = {
    /** Bật tìm kiếm */
    searchEnable?: boolean;
    /** Tìm kiếm phía client */
    searchClient?: boolean;
    /** Từ khóa tìm kiếm */
    searchTerm?: string;
    /** Các trường dùng để tìm kiếm */
    keyField?: string[];
    /** Hàm cập nhật từ khóa */
    setSearchTerm?: Dispatch<SetStateAction<string>>;
};
/** Cấu hình định dạng số, ngày... */
type IFTableEditFormat = {
    /** Định dạng ngày */
    dateFormat?: string;
    /** Định dạng ngày giờ */
    datetimeFormat?: string;
    /** Ký tự phân cách phần thập phân */
    decimalSeparator?: string;
    /** Ký tự phân cách phần nghìn */
    thousandSeparator?: string;
    /** Màu số âm */
    colorNegative?: string;
    /** Tiền tố số âm */
    prefixNegative?: string;
    /** Hậu tố số âm */
    suffixNegative?: string;
};
/** Cấu hình page size */
type IFPageSize = {
    /** Số dòng mỗi trang */
    pageSize: number;
};
/** Cấu hình current page */
type IFCurrentPage = {
    /** Trang hiện tại */
    currentPage: number;
};
/** Cấu hình current page kèm trang cũ */
type IFCurrentPageConfig = {
    /** Trang hiện tại */
    currentPage: number;
    /** Trang cũ */
    oldPage: number;
};
/** Header bảng hỗ trợ merge cột */
type IHeaderColumnTable = {
    /** Tên thuộc tính */
    field: string;
    /** Tên thuộc tính lọc*/
    fieldFilter?: string;
    /** Tiêu đề header */
    headerText?: string;
    /** Chiều rộng */
    width?: number | string;
    /** Chiều rộng tối thiểu */
    minWidth?: number | string;
    /** Chiều rộng tối đa */
    maxWidth?: number | string;
    /** Hiển thị/ẩn */
    visible?: boolean;
    /** Số dòng chiếm (rowspan) */
    rowspan?: number;
    /** Cột con */
    columns?: IColumnTable[];
    /** Căn lề */
    textAlign?: ITextAlign;
    /** Kiểu lọc cột */
    filterType?: IFilterType;
    /** Cho phép lọc cột */
    allowFilter?: boolean;
    /** Cố định trái/phải */
    fixedType?: "left" | "right" | undefined;
    /** Cấu hình cho kiểu numeric */
    numericSettings?: ISettingNumericElement;
    /** Kiểu chỉnh sửa */
    type?: IColumnType;
    /** Thứ tự cột */
    index?: number;
};
type IFColumnSelectTable = {
    /** Tên thuộc tính trường dữ liệu */
    field: string;
    /** Tiêu đề hiển thị ở phần header của cột */
    headerText: string;
    /** Cờ cho phép hiển thị hoặc ẩn cột (mặc định là true) */
    visible?: boolean;
    /** Căn lề nội dung trong cột: trái, phải, giữa */
    textAlign?: "left" | "right" | "center";
    /** Loại dữ liệu của cột: văn bản, số, ngày, ngày giờ */
    type?: "text" | "numeric" | "date" | "datetime";
    /** Template tùy chỉnh nội dung hiển thị trong ô */
    template?: any;
    /** Điều kiện thay đổi kiểu dữ liệu của cột */
    typeCondition?: any;
    /** Số chữ số sau dấu phẩy (dùng cho số thực) */
    fraction?: number;
    /** Chiều rộng cột (tính bằng pixel) */
    width?: number;
    /** Chiều rộng tối đa của cột */
    maxWidth?: number;
    /** Chiều rộng tối thiểu của cột */
    minWidth?: number;
};
type IFTableSelectFormat = {
    /** Định dạng ngày (vd: 'dd/MM/yyyy') */
    dateFormat?: string;
    /** Định dạng ngày giờ (vd: 'dd/MM/yyyy HH:mm:ss') */
    datetimeFormat?: string;
    /** Ký tự phân cách phần thập phân (vd: ',') */
    decimalSeparator?: string;
    /** Ký tự phân cách hàng nghìn (vd: '.') */
    thousandSeparator?: string;
    /** Màu hiển thị số âm (vd: 'red') */
    colorNegative?: string;
    /** Tiền tố hiển thị trước số âm (vd: '(') */
    prefixNegative?: string;
    /** Hậu tố hiển thị sau số âm (vd: ')') */
    suffixNegative?: string;
};
type FromItemsField = {
    /** Tên thuộc tính (dùng làm key khi thao tác dữ liệu) */
    name: string;
    /** Nhãn hiển thị cho trường dữ liệu */
    label: string;
    /** Loại trường dữ liệu: văn bản, số, chọn, chọn có thể tạo mới */
    type: "text" | "numeric" | "select" | "selectCreatable";
    /** Trường có bị disable hay không (không cho chỉnh sửa) */
    disabled?: boolean;
    /** Số chữ số sau dấu phẩy (chỉ áp dụng với loại 'numeric') */
    fraction?: number;
    /** Giá trị tối thiểu (chỉ áp dụng với loại 'numeric') */
    min?: number;
    /** Giá trị tối đa (chỉ áp dụng với loại 'numeric') */
    max?: number;
    /** Danh sách lựa chọn (chỉ áp dụng với loại 'select' và 'selectCreatable') */
    options?: any[];
};
type IColumnsAgg = {
    field: string;
    value: any;
    /** Kiểu xem cột */
    type?: string;
};
type IFOrderTable = {
    key: string;
    direction: "asc" | "desc";
};
type IFFilterTable = {
    key: string;
    value: any;
    ope: "startswith" | "endswith" | "contains" | "equal" | "notequal" | "greaterthan" | "greaterthanorequal" | "lessthan" | "lessthanorequal";
};

type IFTableEditProps = {
    idTable?: string;
    dataSource: any[];
    selectEnable?: boolean;
    defaultValue?: any;
    columns: IColumnTable[];
    height?: number;
    maxHeight?: number;
    minHeight?: number;
    isMulti?: boolean;
    editDisable?: boolean;
    addDisable?: boolean;
    haveSum?: boolean;
    disableAutoKey?: boolean;
    formatSetting?: IFTableEditFormat;
    pagingSetting?: IFTableEditPaging;
    buttonSetting?: IFTableEditButton;
    toolbarSetting?: IFTableEditToolbar;
    searchSetting?: IFTableEditSearchSetting;
    selectedItem?: any;
    setDataSource?: any;
    allowFilter?: boolean;
    allowOrder?: boolean;
    optionsFilter?: any;
    settingColumns?: IFSettingColumns[];
    setSelectedItem?: Dispatch<SetStateAction<any>>;
    commandClick?: (data: any) => void;
    handleSelect?: (data: any) => void;
    dataSourceChange?: (data: any[]) => void;
    rowChange?: (row: any, indexRow: number, field: string) => void;
    onDuplicate?: (newData: any, index: number) => void;
    saveSettingColumn?: (data: IFSettingColumns[]) => void;
    resetDefaultColumns?: () => void;
};
type IFRef = {
    refeshFocusRow: any;
};
declare const TableEdit: React.ForwardRefExoticComponent<IFTableEditProps & React.RefAttributes<IFRef>>;

declare const messageHtmlBoxConfirm: (t: TFunction<"translation", undefined>, message: any[], handle: any, data: any, title?: string, btnOk?: string, btnCancel?: string) => void;
declare const messageHtmlBoxError: (t: TFunction<"translation", undefined>, message: any[], title?: string, btnCancel?: string) => void;
declare const messageBoxConfirmDelete: (t: TFunction<"translation", undefined>, handle: any, data: any) => void;
declare const messageBoxConfirm: (t: TFunction<"translation", undefined>, handle: any, data: any, message: string, title?: string, btnOk?: string, btnCancel?: string) => void;
declare const messageBoxError: (t: TFunction<"translation", undefined>, message: string, title?: string, btnCancel?: string) => void;
declare const notificationError: (param: string) => string;
declare const notificationSuccess: (param: string) => string;
declare const messageBoxConfirm2: (t: TFunction<"translation", undefined>, data: any, data2: any, message: string) => Promise<boolean>;

declare const useOnClickOutside: (ref: any, handler: any) => void;
declare const checkThousandSeparator: (thousandSeparator: any, decimalSeparator: any) => any;
declare const checkDecimalSeparator: (thousandSeparator: any, decimalSeparator: any) => any;
declare const isNullOrUndefined: (d: any) => boolean;
declare const generateUUID: () => string;
/**
 * format chuỗi kí tự số
 * @param str chuỗi số cần format
 * @param decimalSeparator kí tự thập phân
 * @param thousandSeparator kí tự phân cách hàng nghìn
 * @param fraction số kí tự thập phân
 * @param isDone đã nhập xong
 * @returns
 */
declare const formartNumberic: (str: string | number, decimalSeparator: string, thousandSeparator: string, fraction?: number, isDone?: boolean, haveNegative?: boolean) => string;
declare const roundNumber: (num: number, fraction: number) => number;
declare const formatDateTime: (data: any, format?: string) => string;
declare const FindNodeByPath: (tree: any[], path: string) => {
    parent: any[];
    lastIndex: number | undefined;
    firstIndex: number;
    node: any;
} | null;
/**
 * Tính toán cấu trúc bảng từ dữ liệu column dạng cây:
 * - Tạo header dạng nhiều cấp (header theo chiều dọc)
 * - Chuyển cột thành dạng phẳng để render nội dung
 * - Tính toán vị trí cố định trái/phải (fixed column) để hiển thị sticky
 *
 * @param columns Mảng cấu trúc cây đại diện cho các cột của bảng
 * @returns {
 *   levels: IHeaderColumnTable[][]       // Các hàng header theo cấp
 *   flat: IColumnTable[]      // Danh sách cột phẳng
 *   objWidthFixLeft: Record<number, number>      // Offset trái cho cột fixed left
 *   objWidthFixRight: Record<number, number>     // Offset phải cho cột fixed right
 *   lastObjWidthFixLeft: number          // Chỉ số cột cuối cùng fixed left
 *   fisrtObjWidthFixRight: number        // Chỉ số cột đầu tiên fixed right
 * }
 */
declare const calculateTableStructure: (columns: any[], settingColumns?: {
    field: string;
    headerText?: string;
    visible?: boolean;
    fixedType?: "left" | "right";
    width?: number | string;
}[]) => {
    levels: any[][];
    flat: any[];
    flatVisble: any[];
    objWidthFixLeft: Record<number, number>;
    objWidthFixRight: Record<number, number>;
    lastObjWidthFixLeft: number;
    fisrtObjWidthFixRight: number;
    objHeaderWidthFixRight: Record<string, number>;
    objHeaderWidthFixLeft: Record<string, number>;
    indexFirstEdit: number;
    indexLastEdit: number;
};

type IFDataProps$1 = {
    buttonWidth?: number;
    tabParent?: boolean;
    tabChild?: boolean;
    resourceCodeParent?: string;
    resourceCode: string;
    resources: any[];
    renderModal?: any;
    windowSize?: any;
};
declare const TabsMenuComponent: ({ buttonWidth, tabParent, tabChild, resourceCodeParent, resources, resourceCode, windowSize, renderModal }: IFDataProps$1) => react_jsx_runtime.JSX.Element;

type Props$1 = {
    id?: string;
    value: any;
    options: any[];
    fieldValue?: string;
    fieldLabel?: string;
    textAlign?: 'left' | 'right' | 'center';
    placeholder?: string;
    invalid?: boolean;
    menuWidth?: number;
    width?: number;
    isMulti?: boolean;
    noHeader?: boolean;
    maxHeight?: number;
    columns?: IFColumnSelectTable[];
    isClearable?: boolean;
    isDisabled?: boolean;
    allowCreate?: boolean;
    showFooter?: boolean;
    formatSetting?: IFTableSelectFormat;
    component?: string | HTMLElement | React__default.RefObject<HTMLElement> | undefined;
    formatOptionLabel?: (ele: any) => JSX.Element;
    loadOptions?: (keyword: string, callback: (rs: any[]) => void) => void;
    onKeyDown?: (e: React__default.KeyboardEvent<HTMLInputElement>) => any;
    onOpenMenu?: () => void;
    handleAdd?: (e?: any) => void;
    onPaste?: (e: React__default.ClipboardEvent<HTMLInputElement>) => void;
    onCloseMenu?: () => void;
    footerComponent?: () => JSX.Element;
    onChange: (val: any) => void;
    compareFunction?: (row?: any) => boolean | undefined;
};
declare const SelectTable: React__default.ForwardRefExoticComponent<Props$1 & React__default.RefAttributes<unknown>>;

type IFColumnSelectTableTree = {
    field: string;
    headerText: string;
    visible?: boolean;
    textAlign?: 'left' | 'right' | 'center';
    type?: 'text' | 'numeric' | 'date' | 'datetime';
    template?: any;
    typeCondition?: any;
    fraction?: number;
    width?: number;
    maxWidth?: number;
    minWidth?: number;
};
type IFTableTreeSelectFormat = {
    dateFormat?: string;
    decimalSeparator?: string;
    thousandSeparator?: string;
    colorNegative?: string;
    prefixNegative?: string;
    suffixNegative?: string;
};
type Props = {
    id?: string;
    component?: any;
    footerComponent?: any;
    fieldValue?: string;
    fieldLabel?: string;
    onChange: any;
    textAlign?: 'left' | 'right' | 'center';
    placeholder?: string;
    invalid?: any;
    loadOptions?: any;
    menuWidth?: number;
    width?: number;
    rowData?: any;
    value: any;
    onKeyDown?: any;
    formatOptionLabel?: any;
    handleAdd?: any;
    options: any[];
    isMulti?: boolean;
    noHeader?: boolean;
    maxHeight?: number;
    columns?: IFColumnSelectTableTree[];
    fieldChildren?: string;
    isClearable?: boolean;
    isDisabled?: boolean;
    showFooter?: boolean;
    selectChilds?: boolean;
    formatSetting?: IFTableTreeSelectFormat;
    onOpenMenu?: any;
    onPaste?: any;
};
declare const SelectTableTree: React__default.ForwardRefExoticComponent<Props & React__default.RefAttributes<unknown>>;

interface IFDataStyleSetting {
    color: string;
    backgroundColor: string;
    fontFamily: string;
    fontSize: number;
    bold: boolean;
    italic: boolean;
    underline: boolean;
}
interface IFDataInputStyle {
    value: IFDataStyleSetting;
    onChange: any;
    disabled?: boolean;
    disabledColor?: boolean;
    disabledBackgroundColor?: boolean;
    disabledFontFamily?: boolean;
    disabledFontSize?: boolean;
    disabledBold?: boolean;
    disabledItalic?: boolean;
    disabledUnderline?: boolean;
}
declare const InputStyleComponent: (props: IFDataInputStyle) => react_jsx_runtime.JSX.Element;

type IFDataProps = {
    openModal: boolean;
    typeModal: string;
    handleModal: any;
    windowSize: any;
    dataItem: any;
    columns: any;
    setCheckDetailExport?: any;
    columnGroups?: any[];
};
declare const ExportExcelComponent: ({ openModal, typeModal, handleModal, windowSize, dataItem, columns, columnGroups }: IFDataProps) => react_jsx_runtime.JSX.Element;

interface IFDataExcel {
    step: number;
    file?: any;
    sheetId?: string;
    headerRow?: number;
    dataMap: IFDataMapExcel[];
}
interface IFDataMapExcel {
    field: string;
    headerDefault: string[];
    header: string;
    dataType: 'numeric' | 'string' | 'date' | 'datetime' | 'boolean';
    column?: string;
    disableEdit?: boolean;
    isRequired?: boolean;
}

type IFNumberFormat = {
    dateFormat?: string;
    decimalSeparator?: string;
    thousandSeparator?: string;
    colorNegative?: string;
    prefixNegative?: string;
    suffixNegative?: string;
};

interface IFPropsDetail {
    control: Control<IFDataExcel>;
    watch: UseFormWatch<IFDataExcel>;
    errors: FieldErrors<IFDataExcel>;
    setValue: UseFormSetValue<IFDataExcel>;
    getValues: UseFormGetValues<IFDataExcel>;
    formatNumber?: IFNumberFormat;
    pageOptions: number[];
    pageSizeDefault: number;
    windowSize: any;
    getExcelTemplate?: any;
    optionField: any[];
    dataInvalid: any[];
    dataValid: any[];
    dataValidate: any[];
    dataError: any[];
    headerValidateExcelColumns: any[];
    headerHandleErrorExcelColumns: any[];
}
declare const ImportExcelComponent: (props: IFPropsDetail) => react_jsx_runtime.JSX.Element;

type IFSteps = {
    id: string;
    content: JSX.Element;
    subtitle?: JSX.Element | string;
    title: JSX.Element | string;
    icon?: JSX.Element | string;
    done?: boolean;
    loading?: boolean;
    disable?: boolean;
};
type IFProps = {
    steps: IFSteps[];
    activeStep: number;
    setActiveStep?: (stepper: number) => void;
    className?: string;
    headerClassName?: string;
    contentClassName?: string;
    contentWrapperClassName?: string;
    heightContent?: number | string;
    widthContent?: number | string;
    type?: 'vertical' | 'horizontal' | 'modern-horizontal' | 'modern-vertical';
    separator?: JSX.Element;
};
declare const Wizard: React.ForwardRefExoticComponent<IFProps & React.RefAttributes<unknown>>;

type TableViewProps = {
    idTable: string;
    dataSource: any[];
    rowHeight?: number;
    height?: number;
    columns: IColumnTable[];
    selectEnable?: boolean;
    isMutil?: boolean;
    isLoading?: boolean;
    formatSetting?: IFTableEditFormat;
    allowFilter?: boolean;
    allowOrder?: boolean;
    optionsFilter?: any;
    pagingSetting?: IFTableEditPaging;
    toolbarSetting?: IFTableEditToolbar;
    searchSetting?: IFTableEditSearchSetting;
    columnsAggregate?: IColumnsAgg[];
    selectedItem?: any;
    isVirtualList?: boolean;
    setSelectedItem?: Dispatch<SetStateAction<any>>;
    setColumns?: (columns: IColumnTable[]) => void;
    commandClick?: (data: any) => void;
    changeFilter?: (data: IFFilterTable[]) => void;
    changeOrder?: (data: IFOrderTable[]) => void;
    handleSelect?: (data: any) => void;
};
declare const TableView: React__default.FC<TableViewProps>;

export { ExportExcelComponent, FindNodeByPath, ImportExcelComponent, InputStyleComponent, SelectTable, SelectTableTree, TableView, TabsMenuComponent, Wizard, calculateTableStructure, checkDecimalSeparator, checkThousandSeparator, TableEdit as default, formartNumberic, formatDateTime, generateUUID, isNullOrUndefined, messageBoxConfirm, messageBoxConfirm2, messageBoxConfirmDelete, messageBoxError, messageHtmlBoxConfirm, messageHtmlBoxError, notificationError, notificationSuccess, roundNumber, useOnClickOutside };
export type { FromItemsField, IColumnTable, IColumnsAgg, ICommandItem, IFColumnSelectTable, IFColumnSelectTableTree, IFCurrentPage, IFCurrentPageConfig, IFFilterTable, IFOrderTable, IFPageSize, IFPropsDetail, IFSettingColumns, IFTableEditButton, IFTableEditFormat, IFTableEditPaging, IFTableEditSearchSetting, IFTableEditToolbar, IFTableSelectFormat, IFTableTreeSelectFormat, IFToolbarOptions, IHeaderColumnTable, ISettingFormElement, ISettingNumericElement, ISettingSelectElement };
