@scmlatam/web-ui 0.2.11 → 0.2.13

package/dist/src/rb-components/form/FormShell.d.ts

@@ -1,15 +1,38 @@
-import { ReactNode } from 'react';
-type FormShellSize = "s" | "m" | "l";
+import { default as React, ReactNode } from 'react';
+export type FormShellSize = "s" | "m" | "l";
 export interface FormShellProps {
     open: boolean;
     title?: ReactNode;
+    /**
+     * Nombre accesible utilizado cuando no existe
+     * un título visible.
+     */
+    ariaLabel?: string;
     alert?: ReactNode;
     children?: ReactNode;
     footer?: ReactNode;
     onClose?: () => void;
     loading?: boolean;
+    loadingLabel?: string;
     closeLabel?: string;
     size?: FormShellSize;
+    /**
+     * Permite mover el formulario desde el header.
+     */
+    draggable?: boolean;
+    /**
+     * Permite cerrar el formulario con Escape.
+     */
+    closeOnEscape?: boolean;
+    /**
+     * Permite cerrar el formulario al presionar
+     * directamente sobre el backdrop.
+     */
+    closeOnBackdrop?: boolean;
+    className?: string;
+    headerClassName?: string;
+    bodyClassName?: string;
+    footerClassName?: string;
 }
-export declare function FormShell({ open, title, alert, children, footer, onClose, loading, closeLabel, size, }: FormShellProps): import("react/jsx-runtime").JSX.Element | null;
+export declare function FormShell({ open, title, ariaLabel, alert, children, footer, onClose, loading, loadingLabel, closeLabel, size, draggable, closeOnEscape, closeOnBackdrop, className, headerClassName, bodyClassName, footerClassName, }: FormShellProps): React.JSX.Element | null;
 export default FormShell;

package/dist/src/rb-components/form/index.d.ts

@@ -1,2 +1,4 @@
 export { default as FormShell } from './FormShell';
-export type { FormShellProps } from './FormShell';
+export type { FormShellProps, FormShellSize, } from './FormShell';
+export { FormField, FormGrid, } from './FormLayout';
+export type { FormFieldProps, FormFieldSpan, FormGridColumnGap, FormGridProps, FormGridRowGap, } from './FormLayout';

package/dist/src/rb-components/index.d.ts

@@ -5,3 +5,4 @@ export * from './form';
 export * from './ui';
 export * from './table';
 export * from './navigation';
+export * from './tree-panel';

package/dist/src/rb-components/list/RbList.d.ts

@@ -0,0 +1,48 @@
+import { HTMLAttributes, LiHTMLAttributes, ReactElement, ReactNode } from 'react';
+export type RbListVariant = "plain" | "outlined";
+export type RbListSize = "s" | "m";
+export interface RbListProps extends HTMLAttributes<HTMLUListElement> {
+    children?: ReactNode;
+    variant?: RbListVariant;
+    size?: RbListSize;
+    divided?: boolean;
+    /**
+     * Contenido mostrado cuando la lista no tiene
+     * elementos.
+     *
+     * Puede ser texto o cualquier ReactNode.
+     * Usa null para no mostrar un estado vacío.
+     */
+    emptyState?: ReactNode;
+}
+export interface RbListItemProps extends Omit<LiHTMLAttributes<HTMLLIElement>, "children"> {
+    /**
+     * Texto o contenido principal.
+     *
+     * El contenedor del contenido hereda
+     * automáticamente la clase p1.
+     */
+    children: ReactNode;
+    /**
+     * Único ícono ubicado antes del contenido
+     * principal.
+     */
+    icon?: ReactElement;
+    /**
+     * Botones o acciones ubicados al costado
+     * derecho.
+     */
+    actions?: ReactNode;
+    /**
+     * Activa la representación visual del elemento
+     * seleccionado.
+     */
+    selected?: boolean;
+    /**
+     * Bloquea la interacción de la fila y de las
+     * acciones contenidas en ella.
+     */
+    disabled?: boolean;
+}
+export declare const RbList: import('react').ForwardRefExoticComponent<RbListProps & import('react').RefAttributes<HTMLUListElement>>;
+export declare const RbListItem: import('react').ForwardRefExoticComponent<RbListItemProps & import('react').RefAttributes<HTMLLIElement>>;

package/dist/src/rb-components/list/index.d.ts

@@ -0,0 +1,2 @@
+export { RbList, RbListItem } from './RbList';
+export type { RbListProps, RbListItemProps, RbListSize, RbListVariant, } from './RbList';

package/dist/src/rb-components/navigation/PillsTabs.d.ts

@@ -43,5 +43,5 @@ export type PillsTabsProps<Value extends string = string> = {
     className?: string;
     ariaLabel?: string;
 };
-export declare function PillsTabs<Value extends string = string>({ value, items, onChange, className, ariaLabel, }: PillsTabsProps<Value>): import("react/jsx-runtime").JSX.Element;
+export declare function PillsTabs<Value extends string = string>({ value, items, onChange, className, ariaLabel, }: PillsTabsProps<Value>): React.JSX.Element;
 export default PillsTabs;

package/dist/src/rb-components/shell/Breadcrumbs.d.ts

@@ -29,5 +29,5 @@ interface BreadcrumbsProps {
         value: string;
     }) => ReactNode;
 }
-export default function Breadcrumbs({ items, separator, className, queryKeys, includeHome, homeLabel, homeTo, labelFormatter, }: BreadcrumbsProps): import("react/jsx-runtime").JSX.Element | null;
+export default function Breadcrumbs({ items, separator, className, queryKeys, includeHome, homeLabel, homeTo, labelFormatter, }: BreadcrumbsProps): import("react").JSX.Element | null;
 export {};

package/dist/src/rb-components/shell/DashboardShell.d.ts

@@ -1,3 +1,3 @@
 import { DashboardProps } from '../../components/core/types/types';
-declare const DashboardShell: ({ sidebar, routes, account }: DashboardProps) => import("react/jsx-runtime").JSX.Element;
+declare const DashboardShell: ({ sidebar, routes, account }: DashboardProps) => import("react").JSX.Element;
 export { DashboardShell };

package/dist/src/rb-components/shell/ShellContent.d.ts

@@ -1,3 +1,3 @@
 import { ContentPageProps } from '../../components/core/types/types';
-declare const ShellContent: ({ routes }: ContentPageProps) => import("react/jsx-runtime").JSX.Element;
+declare const ShellContent: ({ routes }: ContentPageProps) => import("react").JSX.Element;
 export { ShellContent };

package/dist/src/rb-components/sidebar/Sidebar.d.ts

@@ -1,3 +1,3 @@
 import { SidebarProps } from '../../components/core/types/types';
-declare const Sidebar: ({ items, signOut, tooltips, state, setState, getWidth, }: SidebarProps) => import("react/jsx-runtime").JSX.Element;
+declare const Sidebar: ({ items, signOut, tooltips, state, setState, getWidth, }: SidebarProps) => import("react").JSX.Element;
 export { Sidebar };

package/dist/src/rb-components/sidebar/SidebarContent.d.ts

@@ -1,3 +1,3 @@
 import { ContentProps } from '../../components/core/types/types';
-declare const SidebarContent: (props: ContentProps) => import("react/jsx-runtime").JSX.Element;
+declare const SidebarContent: (props: ContentProps) => import("react").JSX.Element;
 export { SidebarContent };

package/dist/src/rb-components/sidebar/SidebarFooter.d.ts

@@ -1,3 +1,3 @@
 import { FooterProps } from '../../components/core/types/types';
-declare const SidebarFooter: (props: FooterProps) => import("react/jsx-runtime").JSX.Element;
+declare const SidebarFooter: (props: FooterProps) => import("react").JSX.Element;
 export { SidebarFooter };

package/dist/src/rb-components/sidebar/SidebarHeader.d.ts

@@ -1,3 +1,3 @@
 import { HeaderProps } from '../../components/core/types/types';
-declare const SidebarHeader: (props: HeaderProps) => import("react/jsx-runtime").JSX.Element;
+declare const SidebarHeader: (props: HeaderProps) => import("react").JSX.Element;
 export { SidebarHeader };

package/dist/src/rb-components/table/RbExcelTable.d.ts

@@ -0,0 +1,7 @@
+import { default as React } from 'react';
+import { RbTableBaseRow } from './types';
+import { RbExcelTableProps, RbExcelTableRef } from './excel/excel.types';
+export declare const RbExcelTable: <Row extends RbTableBaseRow>(props: RbExcelTableProps<Row> & {
+    ref?: React.ForwardedRef<RbExcelTableRef<Row>>;
+}) => React.ReactElement;
+export default RbExcelTable;

package/dist/src/rb-components/table/RbTable.d.ts

@@ -1,2 +1,3 @@
+import { default as React } from 'react';
 import { RbTableBaseRow, RbTableProps } from './types';
-export declare function RbTable<Row extends RbTableBaseRow = RbTableBaseRow>({ columns, rows, loading, getRowKey, title, description, toolbarLeft, toolbarRight, showToolbar, toolbarClassName, emptyText, emptyState, className, rootClassName, bodyClassName, size, fill, density, onRowClick, onCellContextMenu, rowClassName, getCellClassName, getRowClassName, checkboxSelection, rowSelectionModel, setRowSelectionModel, onRowSelectionModelChange, isRowSelectable, disableRowSelectionOnClick, pinnedColumns, initialState, paginate, defaultRowsPerPage, rowsPerPageOptions, resultsLabel, viewAllLabel, prevAriaLabel, nextAriaLabel, footer, footerActions, hideFooter, }: RbTableProps<Row>): import("react/jsx-runtime").JSX.Element;
+export declare function RbTable<Row extends RbTableBaseRow = RbTableBaseRow>({ columns, rows, loading, getRowKey, title, description, toolbarLeft, toolbarRight, showToolbar, toolbarClassName, emptyText, emptyState, className, rootClassName, bodyClassName, size, fill, density, onRowClick, onCellContextMenu, rowClassName, getCellClassName, getRowClassName, checkboxSelection, rowSelectionModel, setRowSelectionModel, onRowSelectionModelChange, isRowSelectable, disableRowSelectionOnClick, pinnedColumns, initialState, paginate, paginationMode, paginationModel, setPaginationModel, onPaginationModelChange, rowCount, defaultRowsPerPage, rowsPerPageOptions, resultsLabel, viewAllLabel, prevAriaLabel, nextAriaLabel, footer, footerActions, hideFooter, }: RbTableProps<Row>): React.JSX.Element;

package/dist/src/rb-components/table/RbTableToolbar.d.ts

@@ -1,20 +1,4 @@
 import { default as React } from 'react';
-/**
- * ----------------------------------------------------------------------------
- * RB TABLE TOOLBAR
- * ----------------------------------------------------------------------------
- *
- * Toolbar base para RbTable.
- *
- * Reglas:
- * - El consumo debe ser simple.
- * - toolbarLeft puede ser cualquier nodo.
- * - toolbarRight puede tener filtros, botones o acciones.
- * - Se mantiene en una fila lo más posible.
- * - Los campos se achican antes de saltar.
- * - Cuando ya no caben, recién pasan a más filas.
- * - La responsividad depende del ancho real de la toolbar, no del viewport.
- */
 export type RbTableToolbarProps = {
     title?: React.ReactNode;
     description?: React.ReactNode;
@@ -22,5 +6,5 @@ export type RbTableToolbarProps = {
     right?: React.ReactNode;
     className?: string;
 };
-export declare function RbTableToolbar({ title, description, left, right, className, }: RbTableToolbarProps): import("react/jsx-runtime").JSX.Element | null;
+export declare function RbTableToolbar({ title, description, left, right, className, }: RbTableToolbarProps): React.JSX.Element | null;
 export default RbTableToolbar;

package/dist/src/rb-components/table/excel/RbExcelEditableCell.d.ts

@@ -0,0 +1,12 @@
+import { default as React } from 'react';
+import { RbExcelEditorContext, RbExcelTableColumn, RbExcelValidationError } from './excel.types';
+import { RbTableBaseRow } from '../types';
+type RbExcelEditableCellProps<Row extends RbTableBaseRow> = {
+    column: RbExcelTableColumn<Row>;
+    context: Omit<RbExcelEditorContext<Row>, "onChange">;
+    value: unknown;
+    error?: RbExcelValidationError;
+    onChange: (value: unknown) => void;
+};
+export declare function RbExcelEditableCell<Row extends RbTableBaseRow>({ column, context, value, error, onChange, }: RbExcelEditableCellProps<Row>): string | number | bigint | boolean | Iterable<React.ReactNode> | Promise<string | number | bigint | boolean | React.ReactPortal | React.ReactElement<unknown, string | React.JSXElementConstructor<any>> | Iterable<React.ReactNode> | null | undefined> | React.JSX.Element | null | undefined;
+export default RbExcelEditableCell;

package/dist/src/rb-components/table/excel/RbExcelValidationAlert.d.ts

@@ -0,0 +1,11 @@
+import { RbExcelTableLabels, RbExcelValidationResult } from './excel.types';
+import { RbTableBaseRow } from '../types';
+type RbExcelValidationAlertProps<Row extends RbTableBaseRow> = {
+    result?: RbExcelValidationResult<Row>;
+    importError?: string | null;
+    labels: RbExcelTableLabels;
+    maxMessages: number;
+    showSuccess: boolean;
+};
+export declare function RbExcelValidationAlert<Row extends RbTableBaseRow>({ result, importError, labels, maxMessages, showSuccess, }: RbExcelValidationAlertProps<Row>): import("react").JSX.Element | null;
+export default RbExcelValidationAlert;

package/dist/src/rb-components/table/excel/excel.helpers.d.ts

@@ -0,0 +1,16 @@
+import { RbExcelFieldType, RbExcelValueSource } from './excel.types';
+export declare function getRbExcelValueAtPath(value: unknown, path: string): unknown;
+export declare function setRbExcelValueAtPath<Row>(row: Row, path: string, value: unknown): Row;
+export declare function isRbExcelEmptyValue(value: unknown): boolean;
+export declare function isRbExcelEmptyRow(row: unknown[]): boolean;
+export declare function normalizeRbExcelHeader(value: unknown): string;
+export declare function formatRbExcelDate(value: unknown): string;
+export declare function formatRbExcelTime(value: unknown): string;
+export declare function parseRbExcelValue(value: unknown, type?: RbExcelFieldType, source?: RbExcelValueSource): unknown;
+export declare function isValidRbExcelDate(value: unknown): boolean;
+export declare function isValidRbExcelTime(value: unknown): boolean;
+export declare function isValidRbExcelNumber(value: unknown): boolean;
+export declare function readRbExcelFile(file: File, sheet?: number | string): Promise<{
+    rawRows: unknown[][];
+    sheetName: string;
+}>;

package/dist/src/rb-components/table/excel/excel.types.d.ts

@@ -0,0 +1,361 @@
+import { default as React } from 'react';
+import { RbTableAlign, RbTableBaseRow, RbTableProps, RbTableRowId } from '../types';
+export type RbExcelFieldType = "text" | "date" | "time" | "number";
+export type RbExcelValueSource = "upload" | "edit";
+export type RbExcelRowsChangeSource = "upload" | "edit" | "clear";
+export type RbExcelValidationErrorSource = "required" | "type" | "column" | "row";
+export type RbExcelRowsChangeMeta<Row extends RbTableBaseRow> = {
+    source: RbExcelRowsChangeSource;
+    file?: File;
+    row?: Row;
+    rowId?: RbTableRowId;
+    field?: string;
+    value?: unknown;
+    previousValue?: unknown;
+};
+export type RbExcelParseContext<Row extends RbTableBaseRow> = {
+    source: RbExcelValueSource;
+    field: string;
+    columnIndex: number;
+    rowIndex: number;
+    rawRow?: unknown[];
+    currentValues?: Record<string, unknown>;
+    row?: Row;
+};
+export type RbExcelCellContext<Row extends RbTableBaseRow> = {
+    row: Row;
+    rowId: RbTableRowId;
+    rowIndex: number;
+    field: string;
+    value: unknown;
+    rows: Row[];
+};
+export type RbExcelEditorContext<Row extends RbTableBaseRow> = RbExcelCellContext<Row> & {
+    error?: RbExcelValidationError;
+    disabled: boolean;
+    onChange: (value: unknown) => void;
+};
+export type RbExcelRenderContext<Row extends RbTableBaseRow> = RbExcelCellContext<Row> & {
+    error?: RbExcelValidationError;
+};
+export type RbExcelValidationErrorInput = {
+    /**
+     * Campo asociado al error.
+     *
+     * Cuando se entrega, la celda correspondiente queda marcada visualmente.
+     * Cuando se omite, el error se considera general de la fila.
+     */
+    field?: string;
+    /**
+     * Mensaje visible del error.
+     *
+     * Para i18n, el proyecto consumidor puede enviar directamente:
+     * message: t("bulkLoad.validation.invalidType")
+     */
+    message: string;
+    /**
+     * Código opcional para identificar el error sin depender del texto.
+     */
+    code?: string;
+};
+export type RbExcelValidationError = RbExcelValidationErrorInput & {
+    rowId: RbTableRowId;
+    rowIndex: number;
+    source: RbExcelValidationErrorSource;
+};
+export type RbExcelValidationResult<Row extends RbTableBaseRow> = {
+    valid: boolean;
+    rows: Row[];
+    errors: RbExcelValidationError[];
+    errorCount: number;
+    affectedRows: RbTableRowId[];
+};
+export type RbExcelImportContext = {
+    file: File;
+    sheetName: string;
+    rawRows: unknown[][];
+};
+export type RbExcelCreateRowContext = {
+    rowIndex: number;
+    generatedId: RbTableRowId;
+    rawRow: unknown[];
+};
+export type RbExcelTableColumn<Row extends RbTableBaseRow> = {
+    /**
+     * Propiedad que se lee y actualiza en la fila.
+     *
+     * Admite rutas anidadas:
+     * segment.startTime
+     */
+    field: string;
+    /**
+     * Título visible de la columna.
+     *
+     * Puede utilizar directamente i18n:
+     * header: t("bulkLoad.columns.startTime")
+     */
+    header: React.ReactNode;
+    /**
+     * Posición de la columna dentro del Excel.
+     *
+     * Si se omite, se utiliza la posición dentro del array columns.
+     */
+    excelIndex?: number;
+    /**
+     * Encabezado que debe buscarse en el archivo Excel.
+     *
+     * Tiene prioridad sobre excelIndex.
+     */
+    excelHeader?: string;
+    type?: RbExcelFieldType;
+    editable?: boolean;
+    required?: boolean;
+    disabled?: boolean;
+    show?: boolean;
+    width?: number | string;
+    minWidth?: number | string;
+    minWidthPx?: number;
+    align?: RbTableAlign;
+    placeholder?: string;
+    /**
+     * Props adicionales para el input estándar de edición.
+     */
+    editorProps?: Omit<React.InputHTMLAttributes<HTMLInputElement>, "value" | "defaultValue" | "onChange" | "disabled" | "type">;
+    /**
+     * Sobrescribe la transformación automática del valor.
+     */
+    parse?: (value: unknown, context: RbExcelParseContext<Row>) => unknown;
+    /**
+     * Validación específica de una celda.
+     *
+     * Puede retornar:
+     * - null cuando es válido.
+     * - string con el mensaje.
+     * - objeto con field, message y code.
+     *
+     * El mensaje puede venir directamente desde i18n.
+     */
+    validate?: (value: unknown, context: RbExcelCellContext<Row>) => string | RbExcelValidationErrorInput | null | undefined | Promise<string | RbExcelValidationErrorInput | null | undefined>;
+    /**
+     * Permite leer valores desde estructuras personalizadas.
+     */
+    valueGetter?: (row: Row) => unknown;
+    /**
+     * Permite actualizar estructuras personalizadas.
+     *
+     * Debe retornar una nueva fila.
+     */
+    valueSetter?: (row: Row, value: unknown, context: RbExcelCellContext<Row>) => Row;
+    /**
+     * Editor completamente personalizado.
+     */
+    renderEditor?: (context: RbExcelEditorContext<Row>) => React.ReactNode;
+    /**
+     * Render personalizado cuando editable es false.
+     */
+    render?: (context: RbExcelRenderContext<Row>) => React.ReactNode;
+    headerClassName?: string;
+    cellClassName?: string;
+};
+/**
+ * Todos los textos visibles propios de RbExcelTable.
+ *
+ * Puede completarse con traducciones de i18n desde el proyecto consumidor.
+ */
+export type RbExcelTableLabels = {
+    /**
+     * Tooltips y aria-label de las acciones.
+     */
+    download: string;
+    upload: string;
+    validate: string;
+    /**
+     * Textos utilizados durante estados de carga.
+     */
+    uploading: string;
+    validating: string;
+    /**
+     * Estado vacío.
+     */
+    empty: string;
+    /**
+     * Mensajes generales de validación.
+     */
+    validationSuccess: string;
+    /**
+     * Puede ser un string estático o una función para pluralización.
+     *
+     * Ejemplo:
+     * validationErrorTitle: (count) =>
+     *   t("bulkLoad.validation.errorTitle", { count })
+     */
+    validationErrorTitle: string | ((count: number) => string);
+    /**
+     * Formatea cada error dentro de la lista.
+     *
+     * Ejemplo:
+     * validationErrorRow: (row, message) =>
+     *   t("bulkLoad.validation.rowError", {
+     *     row,
+     *     message,
+     *   })
+     */
+    validationErrorRow: (rowNumber: number, message: string) => string;
+    /**
+     * Mensajes automáticos por columna.
+     */
+    required: (column: string) => string;
+    invalidDate: (column: string) => string;
+    invalidTime: (column: string) => string;
+    invalidNumber: (column: string) => string;
+    /**
+     * Fallback cuando una validación custom lanza una excepción.
+     */
+    columnValidationError: (column: string) => string;
+    rowValidationError: (rowNumber: number) => string;
+    /**
+     * Mensajes relacionados con la importación.
+     */
+    importErrorTitle: string;
+    importErrorMessage: string;
+    noWorksheet: string;
+    /**
+     * Errores de estructura de las filas importadas.
+     */
+    invalidCreatedRow: (rowNumber: number) => string;
+    invalidTransformedRow: (rowNumber: number) => string;
+    /**
+     * Texto mostrado cuando existen más errores que maxValidationMessages.
+     */
+    moreErrors: (count: number) => string;
+};
+export type RbExcelTableActionConfig = {
+    /**
+     * Muestra u oculta la acción.
+     */
+    show?: boolean;
+    /**
+     * Reemplaza el ícono por defecto.
+     */
+    icon?: React.ReactNode;
+    /**
+     * Contenido normal del Tooltip.
+     */
+    tooltip?: React.ReactNode;
+    /**
+     * Tooltip mostrado mientras la acción está cargando.
+     */
+    loadingTooltip?: React.ReactNode;
+    /**
+     * Texto accesible normal.
+     */
+    ariaLabel?: string;
+    /**
+     * Texto accesible mientras la acción está cargando.
+     */
+    loadingAriaLabel?: string;
+    /**
+     * Clases adicionales para IconButton.
+     */
+    className?: string;
+};
+export type RbExcelTableActionValue = boolean | RbExcelTableActionConfig;
+export type RbExcelTableActions = {
+    download: RbExcelTableActionValue;
+    upload: RbExcelTableActionValue;
+    validate: RbExcelTableActionValue;
+};
+export type RbExcelTableRef<Row extends RbTableBaseRow> = {
+    validate: () => Promise<RbExcelValidationResult<Row>>;
+    openFilePicker: () => void;
+    clear: () => void;
+    getRows: () => Row[];
+};
+export type RbExcelTableProps<Row extends RbTableBaseRow> = {
+    columns: RbExcelTableColumn<Row>[];
+    /**
+     * Modo controlado.
+     */
+    rows?: Row[];
+    /**
+     * Modo no controlado.
+     */
+    defaultRows?: Row[];
+    onRowsChange?: (rows: Row[], meta: RbExcelRowsChangeMeta<Row>) => void;
+    /**
+     * Construye la fila final después de leer una línea del Excel.
+     */
+    createRow?: (values: Record<string, unknown>, context: RbExcelCreateRowContext) => Row;
+    /**
+     * Transformación final opcional de todas las filas importadas.
+     */
+    transformImportedRows?: (rows: Row[], context: RbExcelImportContext) => Row[] | Promise<Row[]>;
+    /**
+     * Valida reglas que involucran más de una celda
+     * o información externa.
+     *
+     * Los mensajes pueden venir directamente desde i18n.
+     */
+    validateRow?: (row: Row, context: {
+        rowId: RbTableRowId;
+        rowIndex: number;
+        rows: Row[];
+    }) => RbExcelValidationErrorInput[] | Promise<RbExcelValidationErrorInput[]>;
+    onValidationChange?: (result: RbExcelValidationResult<Row>) => void;
+    onImportSuccess?: (rows: Row[], context: RbExcelImportContext) => void;
+    onImportError?: (error: Error, file: File) => void;
+    templateUrl?: string;
+    templateFilename?: string;
+    onDownloadTemplate?: () => void | Promise<void>;
+    /**
+     * Número o nombre de la hoja.
+     *
+     * Por defecto utiliza la primera hoja.
+     */
+    sheet?: number | string;
+    /**
+     * Fila que contiene los encabezados.
+     *
+     * Comienza en 0.
+     */
+    headerRowIndex?: number;
+    /**
+     * Primera fila de datos.
+     *
+     * Por defecto es headerRowIndex + 1.
+     */
+    dataStartRowIndex?: number;
+    skipEmptyRows?: boolean;
+    acceptedFileTypes?: string;
+    /**
+     * Valida automáticamente después de cargar el archivo.
+     */
+    validateAfterImport?: boolean;
+    /**
+     * Después de la primera validación, mantiene los errores
+     * sincronizados mientras se editan las celdas.
+     */
+    revalidateOnEdit?: boolean;
+    showValidationAlert?: boolean;
+    showValidationSuccess?: boolean;
+    maxValidationMessages?: number;
+    title?: React.ReactNode;
+    description?: React.ReactNode;
+    toolbarLeft?: React.ReactNode;
+    toolbarRight?: React.ReactNode;
+    /**
+     * Permite mostrar, ocultar o personalizar las acciones.
+     */
+    actions?: Partial<RbExcelTableActions>;
+    /**
+     * Permite reemplazar todos los textos visibles.
+     */
+    labels?: Partial<RbExcelTableLabels>;
+    disabled?: boolean;
+    readOnly?: boolean;
+    className?: string;
+    generateRowId?: (context: Pick<RbExcelCreateRowContext, "rowIndex" | "rawRow">) => RbTableRowId;
+    tableProps?: Omit<RbTableProps<Row>, "rows" | "columns" | "title" | "description" | "toolbarLeft" | "toolbarRight" | "loading"> & {
+        loading?: boolean;
+    };
+};

package/dist/src/rb-components/table/index.d.ts

@@ -1,9 +1,13 @@
 export { RbTable } from './RbTable';
+export { RbExcelTable } from './RbExcelTable';
 export { RbTableToolbar } from './RbTableToolbar';
 export { RbToolbarActionButton } from './toolbar/RbToolbarActionButton';
 export { RbToolbarDateRangeField } from './toolbar/RbToolbarDateRangeField';
 export { RbToolbarMultiSelectField } from './toolbar/RbToolbarMultiSelectField';
 export { RbToolbarSearchField } from './toolbar/RbToolbarSearchField';
 export { RbToolbarSelectField } from './toolbar/RbToolbarSelectField';
+export { formatRbExcelDate, formatRbExcelTime, getRbExcelValueAtPath, isRbExcelEmptyValue, isValidRbExcelDate, isValidRbExcelNumber, isValidRbExcelTime, parseRbExcelValue, setRbExcelValueAtPath, } from './excel/excel.helpers';
+export type { RbExcelCellContext, RbExcelCreateRowContext, RbExcelEditorContext, RbExcelFieldType, RbExcelImportContext, RbExcelParseContext, RbExcelRenderContext, RbExcelRowsChangeMeta, RbExcelRowsChangeSource, RbExcelTableActions, RbExcelTableColumn, RbExcelTableLabels, RbExcelTableProps, RbExcelTableRef, RbExcelValidationError, RbExcelValidationErrorInput, RbExcelValidationErrorSource, RbExcelValidationResult, RbExcelValueSource, } from './excel/excel.types';
+export * from './toolbar';
 export type { RbToolbarDateRangeValue, RbToolbarDateRangeFieldProps, } from './toolbar/RbToolbarDateRangeField';
-export type { RbAnyTableColumn, RbLegacyGridColumn, RbRowSelectionModel, RbRowsPerPageOption, RbTableAlign, RbTableBaseRow, RbTableCellParams, RbTableColumn, RbTableDensity, RbTableInitialState, RbTablePinnedColumns, RbTableProps, RbTableRowId, RbTableRowParams, RbTableSize, RbTableCellContextMenuParams, RbTableCellContextMenuPosition, } from './types';
+export type { RbAnyTableColumn, RbLegacyGridColumn, RbRowSelectionModel, RbRowsPerPageOption, RbTableAlign, RbTableBaseRow, RbTableCellParams, RbTableColumn, RbTableDensity, RbTableInitialState, RbTablePaginationMode, RbTablePaginationModel, RbTablePinnedColumns, RbTableProps, RbTableRowId, RbTableRowParams, RbTableSize, RbTableCellContextMenuParams, RbTableCellContextMenuPosition, } from './types';

package/dist/src/rb-components/table/toolbar/RbToolbarActionButton.d.ts

@@ -1,17 +1,9 @@
 import { default as React } from 'react';
-/**
- * ----------------------------------------------------------------------------
- * RB TOOLBAR ACTION BUTTON
- * ----------------------------------------------------------------------------
- *
- * - variant="secondaryPrimary": botón con texto.
- * - variant="icon": acción solo ícono.
- */
 export type RbToolbarActionButtonVariant = "secondaryPrimary" | "icon";
 export type RbToolbarActionButtonProps = React.ButtonHTMLAttributes<HTMLButtonElement> & {
     variant?: RbToolbarActionButtonVariant;
     icon?: React.ReactNode;
     loading?: boolean;
 };
-export declare function RbToolbarActionButton({ children, icon, loading, disabled, variant, className, type, ...props }: RbToolbarActionButtonProps): import("react/jsx-runtime").JSX.Element;
+export declare function RbToolbarActionButton({ children, icon, loading, disabled, variant, className, type, ...props }: RbToolbarActionButtonProps): React.JSX.Element;
 export default RbToolbarActionButton;

package/dist/src/rb-components/table/toolbar/RbToolbarActions.d.ts

@@ -0,0 +1,7 @@
+import { default as React } from 'react';
+export type RbToolbarActionsProps = React.HTMLAttributes<HTMLDivElement>;
+type RbToolbarActionsComponent = React.ForwardRefExoticComponent<RbToolbarActionsProps & React.RefAttributes<HTMLDivElement>> & {
+    rbToolbarActions?: boolean;
+};
+export declare const RbToolbarActions: RbToolbarActionsComponent;
+export default RbToolbarActions;

package/dist/src/rb-components/table/toolbar/RbToolbarDateRangeField.d.ts

@@ -19,5 +19,5 @@ export type RbToolbarDateRangeFieldProps = {
     disabled?: boolean;
     className?: string;
 };
-export declare function RbToolbarDateRangeField({ label, value, onChange, initialValue, calendars, disabled, className, }: RbToolbarDateRangeFieldProps): import("react/jsx-runtime").JSX.Element;
+export declare function RbToolbarDateRangeField({ label, value, onChange, initialValue, calendars, disabled, className, }: RbToolbarDateRangeFieldProps): import("react").JSX.Element;
 export default RbToolbarDateRangeField;