@esvndev/es-react-table-interface 1.9.58 → 1.9.60

package/dist/component/ExternalInterface/View/ViewBuilderUI/view-builder-types.d.ts

@@ -0,0 +1,317 @@
+export type ViewScope = 'personal' | 'group' | 'system';
+export type ViewBuilderMode = 'add' | 'edit';
+export type ViewBuilderAction = 'add' | 'edit' | 'delete';
+export type FieldDataType = 'text' | 'number' | 'percent' | 'date' | 'boolean' | 'status' | 'choice' | 'user' | 'lookup' | 'organization' | 'email' | 'phone' | 'url' | 'image' | 'file' | 'multiLookup' | 'duration' | 'address' | 'dimension' | 'composite';
+export type PreviewDevice = 'desktop' | 'tablet' | 'mobile';
+export type PreviewState = 'data' | 'grouped' | 'empty' | 'loading' | 'error' | 'permission';
+export type LoadingMode = 'serverPaging' | 'virtualScroll' | 'infiniteScroll' | 'loadMore';
+export type OptionItem<T extends string = string> = {
+    value: T;
+    label: string;
+    description?: string;
+};
+export type FieldMetadata = {
+    field: string;
+    label: string;
+    description?: string;
+    dataType: FieldDataType;
+    sortable: boolean;
+    filterable: boolean;
+    groupable: boolean;
+    aggregatable: boolean;
+    defaultWidth: number;
+    defaultRenderer: string;
+    defaultFormat: string;
+    sensitive?: boolean;
+    hidden?: boolean;
+    secondaryField?: string;
+    startField?: string;
+    endField?: string;
+    sourceFields?: string[];
+};
+export type ColumnRendererOptions = Record<string, unknown>;
+export declare const VIEW_COLUMN_FIELDS: readonly ["title", "description", "sortOrder", "width", "textAlign", "freeze", "wrapText", "allowSorting", "allowFiltering", "orderBySort", "orderBy", "allowGroup", "groupSort", "isSumary", "isSearchKeyword", "isHidden", "isActiveExcel"];
+export type ViewColumnConfig = {
+    id: string;
+    field: string;
+    title: string;
+    description?: string;
+    colVirtual: string;
+    colTemplate: string;
+    visible: boolean;
+    isActive: boolean;
+    isChoose?: boolean;
+    order: number;
+    widthMode: 'fixed' | 'auto' | 'fill';
+    width: number;
+    minWidth: number;
+    maxWidth: number;
+    textAlign: 'left' | 'center' | 'right';
+    freeze: undefined | 'left' | 'right';
+    wrapText?: boolean;
+    overflow: 'ellipsis' | 'wrap' | 'singleLine';
+    tooltip: boolean;
+    rendererOptions: ColumnRendererOptions;
+    format: string;
+    renderer?: string;
+    prefix?: string;
+    suffix?: string;
+    emptyText?: string;
+    maxLength?: number;
+    sortable: boolean;
+    filterable: boolean;
+    allowSorting?: boolean;
+    allowFiltering?: boolean;
+    orderBy?: string;
+    orderBySort?: number;
+    allowGroup?: boolean;
+    groupSort?: number;
+    groupable: boolean;
+    resizable: boolean;
+    sensitive: boolean;
+    sourceFields?: string[];
+    calculated?: boolean;
+    dataType?: FieldDataType;
+    type?: string;
+    typeDecimal?: any;
+    optionTemplate?: any;
+    typeDefaultValue?: 'text' | 'multiText' | 'number' | 'multiNumber' | 'bit';
+    operator?: any;
+    value: any;
+    label: any;
+    isSearchKeyword?: boolean;
+    isHidden?: boolean;
+    isActiveExcel?: boolean;
+    isSumary?: boolean;
+};
+export type RendererOptionInputType = 'text' | 'number' | 'checkbox' | 'select' | 'field' | 'multiField' | 'color' | 'iconMap' | 'colorMap';
+export type RendererOptionDefinition = {
+    key: string;
+    label: string;
+    inputType: RendererOptionInputType;
+    required?: boolean;
+    options?: OptionItem[];
+    min?: number;
+    max?: number;
+    step?: number;
+    defaultValue?: unknown;
+    visibleWhen?: Record<string, unknown>;
+    description?: string;
+};
+export type FilterCondition = {
+    id: string;
+    colVirtual: string;
+    optionTemplate?: string;
+    typeDefaultValue?: 'text' | 'multiText' | 'number' | 'multiNumber' | 'bit';
+    defaultValue: any;
+    operator: string;
+    value?: unknown;
+    valueTo?: unknown;
+    locked?: boolean;
+};
+export type FilterGroup = {
+    id: string;
+    logic: 'AND' | 'OR';
+    conditions: FilterCondition[];
+};
+export type SortRule = {
+    id: string;
+    field: string;
+    orderBy: 'asc' | 'desc';
+    nullOrder: 'first' | 'last';
+    caseSensitive: boolean;
+    order: number;
+};
+export type QuickFilterConfig = {
+    id: string;
+    field: string;
+    control: string;
+    label?: string;
+    placeholder?: string;
+    defaultValue?: unknown;
+    required?: boolean;
+    clearable?: boolean;
+    order: number;
+};
+export type GroupRule = {
+    id: string;
+    field: string;
+    direction: 'asc' | 'desc';
+    subtotal: boolean;
+    emptyLabel: string;
+    order: number;
+};
+export type AggregateRule = {
+    id: string;
+    field: string;
+    fn: string;
+    label?: string;
+    format?: string;
+    position: 'groupFooter' | 'tableFooter' | 'both';
+    order: number;
+};
+export type ConditionalFormatRule = {
+    id: string;
+    name: string;
+    enabled: boolean;
+    field: string;
+    operator: string;
+    value?: unknown;
+    valueTo?: unknown;
+    textColor?: string;
+    backgroundColor?: string;
+    icon?: string;
+    fontWeight?: 'normal' | 'medium' | 'semibold' | 'bold';
+    applyTo: 'cell' | 'row';
+    priority: number;
+    stopIfTrue: boolean;
+};
+export type ViewActionConfig = {
+    id: string;
+    label: string;
+    enabled: any;
+    placement: 'toolbar' | 'row' | 'contextMenu';
+    selection: 'none' | 'single' | 'multiple';
+    order: number;
+    permissionAction?: string;
+    permissionSubject?: string;
+    requireConfirmation?: boolean;
+};
+export type ViewPermissionTargetType = 'user' | 'role' | 'department' | 'position' | 'job';
+export type ViewPermissionTarget = {
+    id: string;
+    name: string;
+    code?: string;
+    userId?: string;
+    roleId?: string;
+    employeeId?: string;
+    email?: string;
+};
+export type ViewPrivilegeCode = 'OPEN' | 'EDIT' | 'DELETE';
+export type AudiencePermission = {
+    id: string;
+    targetType: ViewPermissionTargetType;
+    targetIds: string[];
+    targets: ViewPermissionTarget[];
+    privilegeCodes: ViewPrivilegeCode[];
+};
+export type PermissionManagedSnapshot = {
+    users: Record<string, ViewPrivilegeCode[]>;
+    roles: Record<string, ViewPrivilegeCode[]>;
+};
+export type ResolvedPermissionUser = {
+    employeeId: string;
+    employeeCode?: string;
+    employeeName: string;
+    userId: string;
+    accountName?: string;
+    email?: string;
+    departmentName?: string;
+    positionName?: string;
+    jobName?: string;
+    sourceNames: string[];
+    privilegeCodes: ViewPrivilegeCode[];
+};
+export type ResolvedPermissionRole = {
+    roleId: string;
+    roleName: string;
+    privilegeCodes: ViewPrivilegeCode[];
+};
+export type ViewDisplayConfig = {
+    density: 'compact' | 'standard' | 'comfortable';
+    rowHeight: number;
+    striped: boolean;
+    showGridLines: boolean;
+    stickyHeader: boolean;
+    showRowNumber: boolean;
+    showCheckbox: boolean;
+    showColumnChoose: boolean;
+    allowResize: boolean;
+    allowReorder: boolean;
+    showTooltip: boolean;
+    emptyMessage: string;
+    loadingMode: LoadingMode;
+    pageSize: number;
+    customPageSize?: number;
+    pagerPosition: 'top' | 'bottom' | 'both' | 'stickyBottom';
+    showTotalCount: boolean;
+    autoRefreshSeconds: number;
+    pauseRefreshWhenInactive?: boolean;
+    skipRefreshWhileEditing?: boolean;
+    defaultNumberFormat: string;
+    defaultPercentFormat: string;
+    defaultDateFormat: string;
+    defaultCurrency: string;
+    locale: string;
+    timezone: string;
+    emptyValue: string;
+};
+export type ViewDefinition = {
+    id: string;
+    code: string;
+    name: string;
+    description: string;
+    resourceCode: string;
+    moduleCode: string;
+    folder?: string;
+    tags: string[];
+    scope: ViewScope;
+    isDefault: boolean;
+    columns: ViewColumnConfig[];
+    filterEnabled: boolean;
+    filterGroups: FilterGroup[];
+    sorts: SortRule[];
+    quickFilters: QuickFilterConfig[];
+    groups: GroupRule[];
+    aggregates: AggregateRule[];
+    conditionalFormats: ConditionalFormatRule[];
+    actions: ViewActionConfig[];
+    audiences: AudiencePermission[];
+    permissionManagedSnapshot?: PermissionManagedSnapshot;
+    display: ViewDisplayConfig;
+    createdBy?: string;
+    organizationId?: string;
+    parentId?: string;
+    oldViewId?: string;
+    viewId?: string;
+    viewName?: string;
+    subSystem?: string;
+    storeProcedure?: string;
+    dbName?: string;
+    parentView?: string;
+    continue?: boolean;
+    detail: any[];
+    table: any[];
+    optionTable: any[];
+    optionTemplate: any[];
+    tableGroup: any[];
+    tableSort: any[];
+    isTree: boolean;
+    parentIdDefaultIsNull?: boolean;
+    parentIdDefault?: string;
+    tree_isGetParent?: boolean;
+    isGroup: boolean;
+    isGroupClient?: boolean;
+    hiddenColumnGroup?: boolean;
+    showGroupIcon?: boolean;
+    disablePrint?: boolean;
+    disableExcelList?: boolean;
+    displayChildSidebar?: boolean;
+    showSum?: boolean;
+    showSumTotal?: boolean;
+    striped?: boolean;
+    showView?: boolean;
+    groupData: string;
+    more: string;
+    product?: string;
+    breakText?: string;
+    whereKeyOrKey?: string;
+    isFieldParent?: string;
+    isFieldChild?: string;
+};
+export type ViewBuilderResult = {
+    action: ViewBuilderAction;
+    data: ViewDefinition;
+};
+export declare const normalizeWidth: (value: unknown, fallback?: number) => number;
+export declare const normalizePageSize: (value: unknown, fallback?: number) => number;

package/dist/component/ExternalInterface/View/ViewBuilderUI/view-builder-validator.d.ts

@@ -0,0 +1,6 @@
+import type { FieldMetadata, ViewDefinition } from './view-builder-types';
+export type ViewValidation = {
+    errors: string[];
+    warnings: string[];
+};
+export declare const validateView: (view: ViewDefinition, metadata: FieldMetadata[]) => ViewValidation;

package/dist/component/ExternalInterface/View/ViewBuilderUI/view-builder-wizard.d.ts

@@ -0,0 +1,16 @@
+import React from 'react';
+import type { FieldMetadata, ViewBuilderMode, ViewBuilderResult, ViewColumnConfig, ViewDefinition } from './view-builder-types';
+export type ViewBuilderWizardProps = {
+    mode: ViewBuilderMode;
+    initialData: ViewDefinition;
+    metadata?: FieldMetadata[];
+    defaultColumns?: ViewColumnConfig[];
+    rows?: Record<string, unknown>[];
+    canAssignPermission?: boolean;
+    canDelete?: boolean;
+    onPreview?: (data: ViewDefinition) => void;
+    onSubmit: (result: ViewBuilderResult) => void;
+    onCancel: () => void;
+    onClear?: () => void;
+};
+export declare const ViewBuilderWizard: ({ mode, initialData, metadata: metadataProp, rows: rowsProp, canAssignPermission, canDelete, onPreview, onSubmit, onCancel, onClear }: ViewBuilderWizardProps) => React.JSX.Element;

package/dist/component/ExternalInterface/View/ViewBuilderUI/view-permission-data.d.ts

@@ -0,0 +1,41 @@
+import type { AudiencePermission, PermissionManagedSnapshot, ResolvedPermissionRole, ResolvedPermissionUser, ViewPermissionTarget, ViewPermissionTargetType, ViewPrivilegeCode } from './view-builder-types';
+export type PermissionCatalogOption = ViewPermissionTarget & {
+    loginId?: string;
+    key?: string;
+    value: string;
+    label: string;
+    email?: string;
+    employee?: any;
+    countEmployee?: number;
+    children?: PermissionCatalogOption[];
+    isDisabled?: boolean;
+    disabled?: boolean;
+};
+export type PermissionCatalog = Record<ViewPermissionTargetType, PermissionCatalogOption[]>;
+export type PermissionResolveResult = {
+    users: ResolvedPermissionUser[];
+    roles: ResolvedPermissionRole[];
+    countByRule: Record<string, number>;
+};
+export type SyncGenericViewPermissionsArgs = {
+    desiredRules: AudiencePermission[];
+    previousManagedSnapshot: PermissionManagedSnapshot;
+    viewCode: string;
+    productCode: string;
+    organizationId: string;
+};
+export type SyncGenericViewPermissionResult = {
+    nextManagedSnapshot: PermissionManagedSnapshot;
+};
+export declare const createEmptyPermissionManagedSnapshot: () => PermissionManagedSnapshot;
+export declare const createPermissionManagedSnapshot: (resolved: PermissionResolveResult) => PermissionManagedSnapshot;
+export declare const collectManagedPermissionDeleteIds: (previous: Record<string, ViewPrivilegeCode[]>, desired: Map<string, Set<ViewPrivilegeCode>>, current: Map<string, Map<string, string>>) => string[];
+export declare const createNextManagedPermissionRecord: (previous: Record<string, ViewPrivilegeCode[]>, desired: Map<string, Set<ViewPrivilegeCode>>, actuallyAdded: Record<string, ViewPrivilegeCode[]>) => Record<string, ViewPrivilegeCode[]>;
+export declare const normalizePermissionRules: (rules: AudiencePermission[]) => AudiencePermission[];
+export declare const loadPermissionCatalog: (organizationId: string) => Promise<PermissionCatalog>;
+export declare const resolvePermissionUsers: (rules: AudiencePermission[], organizationId: string, options?: {
+    includeRoleMembers?: boolean;
+    enrichUserProfiles?: boolean;
+}) => Promise<PermissionResolveResult>;
+export declare const hydratePermissionRulesFromGeneric: (rules: AudiencePermission[], viewCode: string, productCode: string, organizationId: string) => Promise<AudiencePermission[]>;
+export declare const syncGenericViewPermissions: ({ desiredRules, previousManagedSnapshot, viewCode, productCode, organizationId }: SyncGenericViewPermissionsArgs) => Promise<SyncGenericViewPermissionResult>;

package/dist/component/ExternalInterface/View/index.d.ts

@@ -0,0 +1,24 @@
+import React from 'react';
+type ModalViewProps = {
+    openModal: boolean;
+    handleModal: () => void;
+    viewId?: string;
+    thisView?: string;
+    typeModal?: 'Edit' | 'Del' | 'Add';
+    setLoadView?: React.Dispatch<React.SetStateAction<boolean>>;
+    processEnv?: any;
+    windowSize: {
+        innerHeight: number;
+        innerWidth: number;
+    };
+    t?: any;
+    canDelView?: boolean;
+    canEditView?: boolean;
+    onEditView?: any;
+    canAddView?: boolean;
+    onAddView?: any;
+    viewRows: any[];
+    onImportView?: (jsonData: any) => void;
+};
+declare const ModalView: ({ openModal, handleModal, processEnv, setLoadView, viewId, windowSize, canEditView, canDelView, onEditView, canAddView, onAddView, viewRows: providedViewRows, onImportView, t }: ModalViewProps) => React.JSX.Element;
+export default ModalView;

package/dist/component/ExternalInterface/columns.d.ts

@@ -1,5 +1,5 @@
 import { ColumnTable } from "es-grid-template";
-export declare const renderColumns: ({ optionFreeze, optionType, watch, optionTree, optionTypeTemplate, optionDataType, typeModal, t, optionColumn, allScreen, optionTextAlign, isParent, externalT }: {
+export declare const renderColumns: ({ optionFreeze, optionType, watch, optionTree, optionTypeTemplate, optionDataType, typeModal, t, optionColumn, allScreen, optionTextAlign, isParent, externalT, optionWrap }: {
     allScreen: any[];
     optionColumn: any;
     optionFreeze: any[];
@@ -8,12 +8,13 @@ export declare const renderColumns: ({ optionFreeze, optionType, watch, optionTr
     optionTree: any[];
     optionTextAlign: any[];
     optionDataType: any[];
+    optionWrap: any[];
     optionTypeTemplate: any[];
     typeModal: string;
     t: any;
     externalT: any;
     isParent: boolean;
-}) => ColumnTable<RowI>[];
+}) => any[];
 export declare const renderColumnsSort: ({ watch, t }: {
     watch: any;
     optionColumn: any;
@@ -68,4 +69,8 @@ export interface RowI {
     widthPicture?: string;
     heightPicture?: string;
     isActiveExcel?: any;
+    allowSorting?: any;
+    allowFiltering?: any;
+    allowGroup?: any;
+    groupSort?: any;
 }

package/dist/component/ExternalInterface/index.d.ts

@@ -6,7 +6,7 @@ export { default as ModalComponentSetView } from './modalSetView';
 export { default as ModalSetView } from './modalSetView';
 export { default as ModalSetViewPage } from './modalSetView';
 export { HeaderExternalInterface } from '../Header/Header';
-export { ToolbarTemplate, listFilterDate } from '../ToolbarTemplate/ToolbarTemplate';
+export { ToolbarTemplate, listFilterDate, renderListDateTemplate } from '../ToolbarTemplate/ToolbarTemplate';
 export { default as TableConfigPage } from '../table_configs';
 export { SelectComp } from '../../libs/select/select';
 export { createEsExternalTranslator, esExternalLocales, translateEsExternal, useEsExternalTranslator } from '../../i18n';

package/dist/component/ExternalInterface/modalSetView.d.ts

@@ -1,4 +1,33 @@
 import React from "react";
+import { IDataView } from "../table_configs/modalSetting";
+export interface IData extends IDataView {
+    id?: string;
+    viewId?: string;
+    viewName?: string;
+    subSystem?: string;
+    storeProcedure?: string;
+    dbName?: string;
+    typeSubmit?: string;
+    detail: any[];
+    listActive: any[];
+    listInactive: any[];
+    table: any[];
+    optionTable: any[];
+    optionTemplate: any[];
+    parent: any;
+    displayType?: 'list' | 'compact' | 'table' | 'card' | 'calendar';
+    scope?: 'private' | 'shared' | 'public';
+    active?: boolean;
+    defaults?: {
+        myDefault?: boolean;
+        departmentDefault?: boolean;
+        departmentId?: string;
+        organizationDefault?: boolean;
+        organizationId?: string;
+        systemDefault?: boolean;
+        allowUserEdit?: boolean;
+    };
+}
 declare const ModalComponentSetView: (props: {
     typeModal: "Edit" | "Del" | "Add";
     setTypeModal: any;
@@ -14,5 +43,8 @@ declare const ModalComponentSetView: (props: {
     setView: any;
     permissionSubject: any;
     outside: boolean;
+    gridColumns?: any[];
+    previewRows?: Record<string, unknown>[];
+    builderEnabled?: boolean;
 }) => React.JSX.Element;
 export default ModalComponentSetView;

package/dist/component/ExternalInterface/modalView.d.ts

@@ -0,0 +1,21 @@
+import React from "react";
+import type { IExternalInterface } from "../../interface";
+declare const ModalView: (props: {
+    typeModal: "Edit" | "Del" | "Add";
+    openModalOrder: boolean;
+    handleModalOrder: any;
+    viewId: string;
+    thisView: string;
+    setLoadView: any;
+    processEnv?: any;
+    t: any;
+    setView?: any;
+    gridColumns?: any[];
+    previewRows?: Record<string, unknown>[];
+    paramToolbar?: any[];
+    canAssignPermission?: boolean;
+    canDeleteView?: boolean;
+    externalInterfaceProps?: IExternalInterface;
+    importedJsonData?: any;
+}) => React.JSX.Element;
+export default ModalView;

package/dist/component/ToolbarTemplate/ToolbarTemplate.d.ts

@@ -1,6 +1,15 @@
 import React from "react";
 import { IToolbarTemplate } from "../../ultility/Export";
 import "../../ultility/css/css.scss";
+/**
+ * Dùng để xây dựng thanh toolbar phía trên bảng
+ */
+type TDateFilterItem = {
+    value: number | null;
+    label: string;
+    type: Date[];
+};
+export declare const renderListDateTemplate: (item: any, index: number, lang: string, dateFilterOptions: TDateFilterItem[], disabled?: boolean) => React.JSX.Element;
 export declare const listFilterDate: (t?: any) => ({
     value: null;
     label: any;
@@ -19,3 +28,4 @@ export declare const ToolbarTemplate: (props: IToolbarTemplate[]) => ({
     position: "left" | "Top" | "Bottom";
     align: "left" | "right" | "center";
 })[];
+export {};

package/dist/component/export/component/icon/index.d.ts

@@ -0,0 +1,3 @@
+import React from "react";
+declare const IconCustom: (props: any) => React.JSX.Element | null;
+export default IconCustom;

package/dist/component/export/component/input/index.d.ts

@@ -0,0 +1,3 @@
+import React from 'react';
+import { IPropLabel_input } from '../type';
+export declare const renderLabel: (props: IPropLabel_input) => React.JSX.Element;

package/dist/component/export/component/input/input-checkbox/index.d.ts

@@ -0,0 +1,4 @@
+import React from "react";
+import { IFormInput } from '../../type';
+declare const CheckboxInput: (props: IFormInput) => React.JSX.Element;
+export default CheckboxInput;

package/dist/component/export/component/input/input-number/index.d.ts

@@ -0,0 +1,4 @@
+import React from "react";
+import { IFFormInput_InputNumber } from "../../type";
+declare const NumberInput: (props: IFFormInput_InputNumber) => React.JSX.Element;
+export default NumberInput;

package/dist/component/export/component/input/input-style/fonts.d.ts

@@ -0,0 +1,4 @@
+export declare const OptionFont: {
+    value: number;
+    label: string;
+}[];

package/dist/component/export/component/input/input-style/index.d.ts

@@ -0,0 +1,4 @@
+import React from "react";
+import { IFDataInputStyle } from '../../type';
+declare const InputStyleComponent: (props: IFDataInputStyle) => React.JSX.Element;
+export { InputStyleComponent };

package/dist/component/export/component/input/input-style/input-box.d.ts

@@ -0,0 +1,4 @@
+import React from "react";
+import { IFFormInput_Style } from '../../type';
+declare const StyleInput: (props: IFFormInput_Style) => React.JSX.Element;
+export default StyleInput;

package/dist/component/export/component/input/input-text/index.d.ts

@@ -0,0 +1,4 @@
+import React from "react";
+import { IFFormInput_InputText } from '../../type';
+declare const TextInput: (props: IFFormInput_InputText) => React.JSX.Element;
+export default TextInput;

package/dist/component/export/component/modal-export-excel/default-data.d.ts

@@ -0,0 +1,3 @@
+import { IFDataExportExcelSetting } from "../type";
+declare const defaultStyleExportSetting: IFDataExportExcelSetting;
+export default defaultStyleExportSetting;

package/dist/component/export/component/modal-export-excel/index.d.ts

@@ -0,0 +1,4 @@
+import React from 'react';
+import { IFDataProps_ExportExcel } from '../type';
+declare const ExportExcelComponent: ({ openModal, typeModal, handleModal, windowSize, dataItem, columns, columnGroups, stateid, url, dataOption, t }: IFDataProps_ExportExcel) => React.JSX.Element;
+export { ExportExcelComponent };

package/dist/component/export/component/modal-header/index.d.ts

@@ -0,0 +1,4 @@
+import { IFDataProps_ModelHeader } from '../type';
+import React from 'react';
+declare const ModalHeader: (props: IFDataProps_ModelHeader) => React.JSX.Element;
+export default ModalHeader;

package/dist/component/export/component/modal-import-excel/index.d.ts

@@ -0,0 +1,4 @@
+import React from 'react';
+import { IFPropsDetail } from '../type';
+declare const ImportExcelComponent: (props: IFPropsDetail) => React.JSX.Element;
+export { ImportExcelComponent };

package/dist/component/export/component/modal-import-excel/tab-handle-error.d.ts

@@ -0,0 +1,12 @@
+import React from 'react';
+import { IFNumberFormat } from '../type';
+export interface IFPropsDetail {
+    dataError: any[];
+    windowSize: any;
+    formatNumber?: IFNumberFormat;
+    pageOptions: number[];
+    pageSizeDefault: number;
+    headerHandleErrorExcelColumns: any[];
+}
+declare const TabHandleErrorImportExcel: (props: IFPropsDetail) => React.JSX.Element;
+export default TabHandleErrorImportExcel;

package/dist/component/export/component/modal-import-excel/tab-merge.d.ts

@@ -0,0 +1,4 @@
+import { IFPropsDetail_TabMerge_ImportExcel } from '../type';
+import React from 'react';
+declare const TabMergeImportExcel: (props: IFPropsDetail_TabMerge_ImportExcel) => React.JSX.Element;
+export default TabMergeImportExcel;

package/dist/component/export/component/modal-import-excel/tab-select-file.d.ts

@@ -0,0 +1,4 @@
+import React from 'react';
+import { IFPropsDetail_TabSelect_ImportExcel } from '../type';
+declare const TabSelectFileImportExcel: (props: IFPropsDetail_TabSelect_ImportExcel) => React.JSX.Element;
+export default TabSelectFileImportExcel;

package/dist/component/export/component/modal-import-excel/tab-validate.d.ts

@@ -0,0 +1,4 @@
+import React from 'react';
+import { IFPropsDetail_ImportInvalid } from '../type';
+declare const TabValidateImportExcel: (props: Partial<IFPropsDetail_ImportInvalid>) => React.JSX.Element;
+export default TabValidateImportExcel;

package/dist/component/export/component/modal-import-excel/utils.d.ts

@@ -0,0 +1,7 @@
+import { Dispatch, SetStateAction } from 'react';
+import { UseFormSetValue } from 'react-hook-form';
+import { IFDataMapExcel } from '../type';
+export declare const getSheetsExcel: (file: any, setValue?: UseFormSetValue<any>, setOptionSheetName?: Dispatch<SetStateAction<any[]>>) => void;
+export declare const getColumnsSheetExcel: (file: any, headerRow: number, sheetName: string, handleSetColumns: any) => void;
+export declare const mapDataImportExcel: (dataSheet: any[], headerRow: number, dataMap: IFDataMapExcel[], handleValidate: any) => Promise<any[]>;
+export declare const connectString: (t: any, props: string[]) => any;

package/dist/component/export/component/notifications.d.ts

@@ -0,0 +1,9 @@
+import { TEsExternalTranslator } from '../../../i18n';
+export declare const messageHtmlBoxConfirm: (t: TEsExternalTranslator, message: any[], handle: any, data: any, title?: string, btnOk?: string, btnCancel?: string) => void;
+export declare const messageHtmlBoxError: (t: TEsExternalTranslator, message: any[], title?: string, btnCancel?: string) => void;
+export declare const messageBoxConfirmDelete: (t: TEsExternalTranslator, handle: any, data: any) => void;
+export declare const messageBoxConfirm: (t: TEsExternalTranslator, handle: any, data: any, message: string, title?: string, btnOk?: string, btnCancel?: string) => void;
+export declare const messageBoxError: (t: TEsExternalTranslator, message: string, title?: string, btnCancel?: string) => void;
+export declare const notificationError: (param: string) => string;
+export declare const notificationSuccess: (param: string) => string;
+export declare const messageBoxConfirm2: (t: TEsExternalTranslator, data: any, data2: any, message: string) => Promise<boolean>;

package/dist/component/export/component/request/index.d.ts

@@ -0,0 +1,4 @@
+export declare const downloadTemplateApiCall: (data?: any, config?: any, timeout?: number) => Promise<Blob | null | undefined>;
+export declare const exportApiCall: (data?: any, config?: any, timeout?: number) => Promise<Blob | null | undefined>;
+export declare const importApiCallCheckInvalidData: (data?: any, config?: any, timeout?: number) => Promise<any>;
+export declare const importApiCall: (data?: any, config?: any, timeout?: number) => Promise<any>;