@apia/table 3.0.1 → 3.0.6

package/dist/index.d.ts

@@ -1,25 +1,788 @@
-export { ResponsiveTable } from './ResponsiveTable.js';
-export { ResponsiveTableContext, useResponsiveTableContext } from './ResponsiveTableContext.js';
-export { responsiveTableActions, responsiveTableStore, useResponsiveTable } from './store/index.js';
-export { DocNameCellRenderer } from './renderers/DocNameCellRenderer.js';
-export { AccordionCell, TAccordionCellRenderer, TAccordionCellRendererProps } from './renderers/AccordionCell.js';
-export { AccordionDocNameCellRenderer, TDocNameCellRenderer, TDocNameCellRendererProps } from './renderers/AccordionDocNameCellRenderer.js';
-export { AccordionElement, IAccordionElement } from './renderers/AccordionElement.js';
-export { AccordionHTMLCellRenderer } from './renderers/AccordionHTMLCellRenderer.js';
-export { AccordionRenderer } from './renderers/AccordionRenderer.js';
-export { AdditionalColumnDefaultRenderer } from './renderers/AdditionalColumnDefaultRenderer.js';
-export { DefaultCellRenderer } from './renderers/DefaultCellRenderer.js';
-export { DefaultRowRenderer } from './renderers/DefaultRowRenderer.js';
-export { HTMLCellRenderer } from './renderers/HTMLCellRenderer.js';
-export { IsLoadingRenderer } from './renderers/IsLoadingRenderer.js';
-export { makeAccordionAsyncRenderer } from './renderers/makeAccordionAsyncRenderer.js';
-export { makeAsyncRenderer } from './renderers/makeAsyncRenderer.js';
-export { NoRegistersRenderer } from './renderers/NoRegistersRenderer.js';
-export { PriorityAccordionRenderer } from './renderers/PriorityAccordionRenderer.js';
-export { PriorityRenderer, getPriorityHandler } from './renderers/PriorityRenderer.js';
-export { RowStatesRenderer } from './renderers/RowStatesRenderer.js';
-export { StatusAccordionRenderer } from './renderers/StatusAccordionRenderer.js';
-export { StatusRenderer, getStatusRendererClassName } from './renderers/StatusRenderer.js';
-export { TableRenderer } from './renderers/TableRenderer.js';
-export { TColoredElement, TResponsiveTableCell, TResponsiveTableCellRenderer, TResponsiveTableCellRendererProps, TResponsiveTableColumn, TResponsiveTableContext, TResponsiveTableContextProps, TResponsiveTableRow, TResponsiveTableRowRenderer, TResponsiveTableRowRendererProps, TResponsiveTableRowState, TResponsiveTableRowsSelectionEvent, TResponsiveTableSortChangeEvent, TResponsiveTableSortValue, TResponsiveTableStoreProps, TResponsiveTableWithRendererElement, defaultLabels } from './types.js';
+import * as React from 'react';
+import React__default, { FunctionComponent, ReactNode, FC } from 'react';
+import { BoxProps } from '@apia/theme';
+import { IconType } from '@meronex/icons';
+import * as _apia_util from '@apia/util';
+import { TApiaFilter, TModify, TId } from '@apia/util';
+import * as _reduxjs_toolkit from '@reduxjs/toolkit';
+import { PayloadAction } from '@reduxjs/toolkit';
+import * as immer_dist_internal from 'immer/dist/internal';
+import * as _reduxjs_toolkit_dist_configureStore from '@reduxjs/toolkit/dist/configureStore';
+import * as redux_thunk from 'redux-thunk';
+import * as redux from 'redux';
+
+type TAccordionCellRendererProps<CellProps = Record<string, unknown>> = {
+    cell: TResponsiveTableCell<CellProps>;
+    column: TResponsiveTableColumn;
+    columnIndex: number;
+    row: TResponsiveTableRow;
+    rowIndex: number;
+};
+type TAccordionCellRenderer<CellProps = Record<string, unknown>> = FunctionComponent<TAccordionCellRendererProps<CellProps>>;
+declare const AccordionCell: TAccordionCellRenderer<Record<string, unknown>>;
+
+type TColoredElement = {
+    background?: string;
+    color?: string;
+};
+/**
+ * Se encontró en algunos casos particulares que
+ * el servidor devuelve Up y Down para referirse
+ * al orden actual de una columna.
+ */
+type TResponsiveTableSortValue = null | 'A' | 'D' | 'Down' | 'Up';
+/**
+ * Cada vez que se hace click en el botón del
+ * cabezal de una columna, si la columna tiene
+ * habilitado el ordenamiento, se emite un
+ * evento de este tipo, informando cuál columna
+ * emitió el evento, y cuál es el nuevo sortValue.
+ */
+type TResponsiveTableSortChangeEvent = {
+    name: string;
+    column: TResponsiveTableColumn;
+    columnIndex: number;
+    /**
+     * Es el orden que la columna debería tener
+     * si no hay ningún motivo para evitar que
+     * la acción de ordenamiento se lleve a cabo.
+     *
+     * Es importante notar que el componente
+     * responsiveTable no realiza ninguna acción
+     * de ordenamiento por defecto, sino que es
+     * quien la usa, quien debe realizar las
+     * acciones correspondientes e informarlo a
+     * la tabla actualizando los registros y el
+     * estado de la columna correspondiente.
+     */
+    sortValue: TResponsiveTableSortValue;
+};
+/**
+ * Cada celda admite un renderer, que recibe
+ * propiedades personalizadas. Este tipo define
+ * cuál es la forma de esas propiedades.
+ */
+type TResponsiveTableCellRendererProps<RendererPropsType extends Partial<Record<keyof RendererPropsType, unknown>> = Record<string, unknown>, HTML = HTMLTableCellElement> = {
+    cell: TResponsiveTableCell<RendererPropsType>;
+    column: TResponsiveTableColumn;
+    row: TResponsiveTableRow;
+} & React__default.AllHTMLAttributes<HTML>;
+type TResponsiveTableCellRenderer<RendererPropsType extends Partial<Record<keyof RendererPropsType, unknown>> = Record<string, unknown>> = React__default.FunctionComponent<TResponsiveTableCellRendererProps<RendererPropsType>>;
+/**
+ * Algunos elementos de la tabla admiten un
+ * Renderer personalizado. Dichos elementos
+ * extienden este tipo.
+ */
+type TResponsiveTableWithRendererElement<RendererPropsType extends Partial<Record<keyof RendererPropsType, unknown>> = Record<string, unknown>> = {
+    /**
+     * Si se desea, el elemento admite un componente
+     * personalizado para encargarse del renderizado
+     * del mismo en el modo responsivo. De esta forma, se puede proveer
+     * de comportamiento específico a cualquier
+     * elemento de la tabla.
+     */
+    AccordionRenderer?: TAccordionCellRenderer<any>;
+    /**
+     * Son las propiedades que se desean pasar al
+     * componente de renderizado personalizado que
+     * se haya establecido.
+     *
+     * Estas props serán obviadas en caso de que
+     * no haya componente de renderizado personalizado.
+     */
+    rendererProps?: RendererPropsType;
+    /**
+     * Si se desea, el elemento admite un componente
+     * personalizado para encargarse del renderizado
+     * del mismo. De esta forma, se puede proveer
+     * de comportamiento específico a cualquier
+     * elemento de la tabla.
+     */
+    Renderer?: TResponsiveTableCellRenderer<any>;
+};
+type TResponsiveTableCell<RendererPropsType extends Partial<Record<keyof RendererPropsType, unknown>> = Record<string, unknown>> = {
+    children?: ReactNode;
+} & TResponsiveTableWithRendererElement<RendererPropsType> & Partial<Pick<HTMLTableCellElement, 'ariaLabel' | 'className' | 'colSpan' | 'id' | 'rowSpan' | 'title'>> & TColoredElement;
+/**
+ * Cada celda admite un renderer, que recibe
+ * propiedades personalizadas. Este tipo define
+ * cuál es la forma de esas propiedades.
+ */
+type TResponsiveTableRowRendererProps<RendererPropsType extends Partial<Record<keyof RendererPropsType, unknown>> = Record<string, unknown>> = {
+    row: TResponsiveTableRow<RendererPropsType>;
+    rowIndex: number;
+} & React__default.AllHTMLAttributes<HTMLTableRowElement>;
+type TResponsiveTableRowRenderer<RendererPropsType extends Partial<Record<keyof RendererPropsType, unknown>> = Record<string, unknown>> = React__default.FunctionComponent<TResponsiveTableRowRendererProps<RendererPropsType>>;
+type TResponsiveTableRow<RendererPropsType extends Partial<Record<keyof RendererPropsType, unknown>> = Record<string, unknown>> = TBasicRow & TColoredElement & {
+    accordionButtonProps?: {
+        rightButtons?: React__default.ReactNode;
+        onUserPressEnter?: (ev: React__default.KeyboardEvent) => unknown;
+    };
+    cells: TResponsiveTableCell[];
+    /**
+     * Si se pasa en true, la fila se mostrará como un separador
+     */
+    separator?: boolean;
+    initiallySelected?: boolean;
+    renderer?: TResponsiveTableRowRenderer<RendererPropsType>;
+    rendererProps?: RendererPropsType;
+    /**
+     * Permite pasar propiedades arbitrarias a un row y recuperarlas en los
+     * eventos de onClick por ejemplo.
+     */
+    rowProps?: RendererPropsType;
+    isHidden?: boolean;
+    /**
+     * Los estados de la fila agregan un ícono en la columna
+     * especial que es la que se muestra a la izquierda y
+     * contiene, cuando existe, el botón de más información.
+     */
+    states?: TResponsiveTableRowState[];
+} & Partial<Pick<HTMLTableCellElement, 'ariaLabel' | 'colSpan' | 'className' | 'rowSpan' | 'title'>>;
+type TResponsiveTableRowState = {
+    /**
+     * Es un className que se agregará al elemento <tr>
+     */
+    className?: string;
+    Icon: IconType;
+    color?: string;
+    tooltip: string;
+};
+type TResponsiveTableColumn = TResponsiveTableWithRendererElement & {
+    /** Con esta propiedad se puede pasar parámetros opcionales */
+    additionalData?: Record<string, unknown>;
+    /**
+     * Determina si la columna admite ordenamiento.
+     */
+    allowSorting?: boolean;
+    children?: React__default.ReactNode;
+    /**
+     * Cuando la columna admite ordenamiento, muestra
+     * una flecha indicando el orden actual. Esta
+     * propiedad establece si la flecha apunta hacia
+     * arriba, abajo, o si la flecha es un guión.
+     */
+    currentSorting?: TResponsiveTableSortValue;
+    /** *
+     * Valor para decirle al server cuál columna se está ordenando
+     */
+    dataSortBy?: string;
+    hidden?: boolean;
+    /**
+     * Normalmente, todas las columnas se van a mostrar
+     * como renglones en el acordión, cuando este es
+     * expandido.
+     *
+     * Si este flag es pasado en true, la columna
+     * correspondiente no se va a mostrar en modo
+     * responsivo.
+     */
+    hideFromAccordion?: boolean;
+    /**
+     * Elemento id del dom.
+     */
+    id?: string;
+    /**
+     * Es el texto que se mostrará en el cabezal.
+     */
+    label: string;
+    maxWidth?: number | string;
+    minWidth?: number | string;
+    /**
+     * El nombre de la columna debe ser único, se utiliza
+     * para realizar la asosiación entre las columnas
+     * y los filtros, así como con los eventos de orden.
+     */
+    name: string;
+    /**
+     * Si se pasa required: true, se pone un asterisco
+     * rojo en el cabezal de la columna para señalar que
+     * la columna es requerida.
+     */
+    required?: boolean;
+    /**
+     * Algunas columnas podrán mostrarse mediante un botón
+     * "mostrar más", para ello deberán ser marcadas con
+     * esta prop en true.
+     */
+    showAsAdditional?: boolean;
+    /**
+     * Cuando no se pasa esta propiedad en ninguna columna,
+     * la aplicación encuentra la primera fila sin celdas
+     * vacías y la utiliza como título.
+     *
+     * En cambio, si al menos una columna tiene este flag
+     * en true, el título de cada fila del acordión estará
+     * compuesto por los valores de estas columnas.
+     */
+    showInAccordionTitle?: boolean;
+    /**
+     * Elemento title de html (El tooltip).
+     */
+    title?: string;
+    width?: number | string;
+} & Partial<Pick<HTMLTableCellElement, 'ariaLabel' | 'className' | 'colSpan' | 'rowSpan'>>;
+type TResponsiveTableStoreProps = {
+    /**
+     * Habla sobre el orden de las filas en función de
+     * las columnas. Esta propiedad habilita/deshabilita
+     * el ordenado de las columnas al hacer click en los
+     * cabezales.
+     *
+     * La tabla admite ordenamiento por defecto, a menos
+     * que esta prop venga en false. En caso de que se
+     * pase false no importa qué digan las columnas,
+     * el ordenamiento no estará habilitado.
+     */
+    allowSorting?: boolean;
+    columns: TResponsiveTableColumn[];
+    filters?: TApiaFilter[];
+    rows: TResponsiveTableRow<any>[];
+    /**
+     * Por defecto, la tabla permitirá seleccionar
+     * múltiples valores, a menos que esta prop venga
+     * en false.
+     */
+    isMultiple?: boolean;
+    label?: string;
+    /**
+     * Es normal que una tabla tenga paginación y que en cada página haya una
+     * cantidad distinta de estados. Si se quiere mantener consistencia en el
+     * tamaño de las páginas, es posible reservar un tamaño para una cantidad
+     * definida de estados con este parámetro.
+     */
+    reserveColumnsForStates?: number;
+};
+type TResponsiveTableRowsSelectionEvent = {
+    index: number;
+    row: TResponsiveTableRow;
+}[];
+type TResponsiveTableContextProps = TResponsiveTableStoreProps & Pick<ISelectableState, 'allowRowsKeyboardSorting' | 'allowEdition' | 'allowSelection'> & {
+    /**
+     * Cuando se actualiza el array de rows de la tabla
+     * desde las props del ResponsiveTableContext, se
+     * reinicia el estado de selección de acuerdo a cómo
+     * viene definido en el prop. **Si esta prop se pasa
+     * en true**, este comportamiento es deshabilitado.
+     */
+    avoidReparseSelectionOnRowChange?: boolean;
+    children?: React__default.ReactNode;
+    className?: string;
+    /**
+     * Permite redefinir el comportamiento de los breakpoints pasando un índice
+     * personalizado. Cuando es pasado, deja de prestar atención al breakpoint
+     * de la pantalla y comienza a prestar atención a este índice.
+     */
+    currentBreakPoint?: number;
+    customLabels?: typeof defaultLabels;
+    /**
+     * Se puede utilizar este booleano para que la tabla
+     * deshabilite las opciones de filtrado y ordenado mientras
+     * se está ejecutando una acción ajax.
+     */
+    isLoading?: boolean;
+    /**
+     * La tabla debe tener un nombre único que será usado para
+     * acceder a las propiedades de la misma en el store. En caso
+     * de que no se pase ninguno, la tabla lo generará
+     * automaticamente.
+     */
+    name?: string;
+    onFilterChange?: (ev: TApiaFilter) => void | Promise<boolean>;
+    onFilterBlur?: (ev: TApiaFilter) => unknown;
+    onFilterPressEnter?: (ev: TApiaFilter) => unknown;
+    onChangeSelection?: (ev: TResponsiveTableRowsSelectionEvent) => unknown;
+    /**
+     * Este evento será llamado cada vez que el usuario esté
+     * haciendo foco en la tabla, tenga una selección de
+     * filas no vacía y presione la tecla Enter.
+     */
+    onSelectRows?: (ev: TResponsiveTableRowsSelectionEvent, focusedRowIndex: number) => unknown;
+    /**
+     * Es llamado cada vez que el usuario hace click en el botón
+     * del cabezal de la columna. **Importante:** la tabla no
+     * realizará ninguna acción de ordenamiento, sino solamente
+     * avisar de que el usuario desea que las filas sean ordenadas
+     * por alguna columna en particular.
+     */
+    onSortChange?: (ev: TResponsiveTableSortChangeEvent) => unknown;
+    /**
+     * Si se pasa selectionHandler, la tabla no realizará ningún control de eventos de teclado o mouse.
+     */
+    SelectionHandler?: FC<TKeyHandlerProps>;
+    variant?: string;
+};
+/**
+ * Los callbacks del responsiveTable estarán
+ * disponibles a través de un contexto, de
+ * forma que cualquier elemento activo que
+ * desee informar de un evento en particular
+ * pueda hacerlo en forma sencilla.
+ */
+type TResponsiveTableContext = TModify<Pick<TResponsiveTableContextProps, 'currentBreakPoint' | 'name' | 'onChangeSelection' | 'onFilterBlur' | 'onFilterChange' | 'onFilterPressEnter' | 'onSelectRows' | 'onSortChange' | 'label' | 'SelectionHandler'>, {
+    labels: typeof defaultLabels;
+    name: string;
+}>;
+declare global {
+    interface Window {
+        FINDER_NO_DATA: string;
+        ORDER_ASC_LABEL: string;
+        ORDER_DESC_LABEL: string;
+        GNR_TOT_RECORDS: string;
+        GNR_TOT_RECORDS_REACHED: string;
+        QUERY_MORE_DATA: string;
+        LBL_MAXIMIZE: string;
+        LBL_MINIMIZE: string;
+        BTN_FILE_INFO_TOOLTIP: string;
+        NAV_FIRST_PAGE: string;
+        NAV_PREVIOUS_PAGE: string;
+        NAV_INPUT_LABEL: string;
+        PAGE: string;
+        NAV_NEXT_PAGE: string;
+        NAV_LAST_PAGE: string;
+        BTN_DELETE_FILTERS: string;
+        NAV_REFRESH: string;
+    }
+}
+declare const defaultLabels: {
+    noRegisters: string;
+};
+
+type TResponsiveTableIndexColumns = {
+    index: number;
+    column: TResponsiveTableColumn;
+}[];
+type TResponsiveTableState = Omit<TResponsiveTableStoreProps, 'columns' | 'rows' | 'filters'> & ISelectableState<TResponsiveTableStoreProps['columns'][0], NonNullable<TResponsiveTableStoreProps['filters']>[0], TResponsiveTableStoreProps['rows'][0]> & {
+    accordionIndexColumns: TResponsiveTableIndexColumns;
+    isLoading: boolean;
+};
+type TResponsiveTableSlice = Record<string, TResponsiveTableState>;
+type TResponsiveTableAction<P = Record<string, unknown>, T extends string = string, M = never, E = never> = PayloadAction<P & {
+    tableName: string;
+}, T, M, E>;
+
+/**
+ * Representa la intención de establecer foco en
+ * un elemento de la grilla y alterar el estado
+ * de la misma.
+ */
+interface INewFocus {
+    altKey?: boolean;
+    ctrlKey?: boolean;
+    isFocused?: boolean;
+    newFocusedRow?: number;
+    newFocusedColumn?: number;
+    shouldSelectNewFocused?: boolean;
+    shiftKey?: boolean;
+}
+/**
+ * Contiene las partes importantes para el handler
+ * de un evento de teclado.
+ */
+type THandleKey = {
+    ev: React__default.KeyboardEvent;
+};
+/**
+ * Son los elementos mínimos que toda columna debe
+ * tener para ser parte de esta grilla.
+ */
+interface IBasicColumn {
+    currentSorting?: TResponsiveTableSortValue;
+    name: string;
+}
+/**
+ * Son los elementos mínimos que todo filtro debe
+ * tener para ser parte de esta grilla.
+ */
+interface IBasicFilter {
+    /**
+     * LEGACY: El nombre de la columna a la que
+     * pertenece este filtro. Puede no tener columna
+     * y entonces será tratado como filtro adicional.
+     *
+     * Me gustaría nombrarlo columnName pero se
+     * estableció así desde el principio del desarrollo
+     * y está impregnado en todo el desarrollo, haciendo
+     * imposible cambiar su nombre con sencillez.
+     */
+    column?: string;
+    showAsAdditional?: boolean;
+}
+type TBasicRow = {
+    /**
+     * Si esta propiedad es pasada en true, esta fila
+     * no podrá ser seleccionada.
+     */
+    forbidSelection?: boolean;
+    /**
+     * El id es obligatorio para los rows, ya que de
+     * esta forma se logra mejorar el performance.
+     */
+    id: string;
+    /**
+     * Si esta propiedad es pasada como true, esta fila
+     * será bloqueada.
+     */
+    isLocked?: boolean;
+};
+/**
+ * Esta interfaz representa el estado de selección
+ * en una grilla. Los tipos ColumnType y RowType
+ * son opcionales y solamente se ofrecen como una
+ * utilidad para la implementación.
+ */
+interface ISelectableState<ColumnType extends IBasicColumn = IBasicColumn, FilterType extends IBasicFilter = IBasicFilter, RowType extends TBasicRow | string = TBasicRow | string> {
+    /**
+     * IMPORTANTE: Por defecto la grilla no permitirá edición,
+     * para permitirlo, se debe especificar allowEdition: true.
+     */
+    allowEdition?: boolean;
+    /**
+     * Si esta propiedad se pasa en true, es posible
+     * reordenar las filas de la tabla. Para ello es
+     * necesario estar en foco en la tabla y presionar
+     * ctrl+m para mover una fila de lugar. Se presiona
+     * Enter o Escape para salir del modo orden.
+     */
+    allowRowsKeyboardSorting?: boolean;
+    /**
+     * Por defecto, la grilla permitirá la selección de filas,
+     * para evitar este comportamiento se debe pasar
+     * allowSelection: false.
+     */
+    allowSelection?: boolean;
+    /**
+     * Es importante conocer las columnas para no hacer foco
+     * en una columna que no exista.
+     */
+    columns: ColumnType[];
+    draggingRow?: number;
+    /**
+     * Es importante conocer cuáles filas están expandidas de
+     * modo que al filtrar las filas no seleccionables, las
+     * expandidas no se van a tomar en cuenta.
+     */
+    expandedRows: number[];
+    /**
+     * La grilla debe conocer los filtros que se aplican a ella
+     * para saber si existe fila de filtros o no.
+     */
+    filters: FilterType[];
+    focusedRow: number;
+    focusedColumn: number;
+    hasNonAdditionalFilters: boolean;
+    /**
+     * Hay grillas que admiten edición, con este booleano
+     * es posible evitar que el keyHandler altere el
+     * estado de la selección cuando la grilla está en ese
+     * modo.
+     */
+    isEditionMode?: boolean;
+    /**
+     * Para efectuar las acciones de foco, es necesario saber
+     * si la grilla tiene el foco activo, de modo de evitar
+     * que el foco se dispare cuando se está trabajando con
+     * otros controles.
+     */
+    isFocused: boolean;
+    /**
+     * Indica si se pueden seleccionar muchas filas o una
+     * sola.
+     */
+    isMultiple?: boolean;
+    /**
+     * Es importante conocer las filas para no hacer foco
+     * en una fila que no exista.
+     */
+    nonAdditionalColumnsCount: number;
+    rows: RowType[];
+    /**
+     * **Controller2**
+     * Permite definir en qué fila se hará scroll, solamente tiene efecto al cambiar
+     */
+    scrollIntoViewRow?: number;
+    /**
+     * Representa cuáles filas fueron seleccionadas por el
+     * usuario. El array resultante es el conjunto de índices
+     * de filas seleccionadas. Este array es actualizado
+     * automáticamente por el keyHandler.
+     */
+    selectedRows: number[];
+    statesColumns: number;
+}
+type TKeyHandlerProps = BoxProps & {
+    /**
+     * Se emite un evento cada vez que el usuario modifica
+     * la selección actual.
+     */
+    onChangeSelection?: (newRows: TResponsiveTableRowsSelectionEvent) => unknown;
+    onSelectRows?: (newRows: TResponsiveTableRowsSelectionEvent, focusedIndex: number) => unknown;
+};
+
+declare const ResponsiveTable: React__default.MemoExoticComponent<React__default.ForwardRefExoticComponent<BoxProps & React__default.RefAttributes<HTMLDivElement>>>;
+
+declare const Sort: React__default.MemoExoticComponent<({ tableName }: {
+    tableName?: string | undefined;
+}) => React__default.JSX.Element>;
+
+declare const Additional: React__default.MemoExoticComponent<({ tableName }: {
+    tableName?: string | undefined;
+}) => React__default.JSX.Element>;
+
+declare const Responsive: React__default.MemoExoticComponent<({ tableName }: {
+    tableName?: string | undefined;
+}) => React__default.JSX.Element>;
+
+interface IPagination {
+    appliedFilters?: number;
+    /**
+     * Este valor determina si el boton de eliminar filtros debe mostrarse como si hubieran filtros sin aplicar (en caso de que haya filtros aplicados por defecto) o si debe mostrarse como si todos los filtros con valor estan aplicados a la busqueda actual. Se deberia verificar con el slice de redux correspondiente a la tabla.
+     */
+    areAllFiltersApplied?: boolean;
+    className?: string;
+    currentPage: number | string;
+    disabled?: boolean;
+    disableReduced?: boolean;
+    hideMaximizeButton?: boolean;
+    hideRefreshButton?: boolean;
+    isLoading?: boolean;
+    /**
+     * Valor obtenido del buttonsSlice para bloquear los botones de la paginacion mientras se estan ejecutando acciones
+     */
+    isPerforming?: boolean;
+    /**
+     * Se usa principalmente en grillas de ejecución para indicar al pagination
+     * que debe usar el fieldId de la misma y no el de un listado global.
+     */
+    listId?: TId;
+    /**
+     * Si se pasa un método onDeleteFilters, aparece el botón "Eliminar filtros"
+     * cerca del refresh
+     */
+    onDeleteFilters?: () => unknown;
+    onPageChange: (page: number) => unknown;
+    onRefresh: (page: number) => unknown;
+    pageCount: number | string;
+    reachedMax?: boolean | undefined;
+    hasMore?: boolean | undefined;
+    /**
+     * Si la cantidad de registros se obtiene desde un lugar distinto de Redux,
+     * se puede pasar como number directamente
+     */
+    recordsCount?: number;
+    showMaximizeOnSmallBreakpoints?: boolean;
+    variant?: 'primary' | 'secondary' | 'datagrid';
+}
+declare const Pagination: React__default.MemoExoticComponent<({ appliedFilters, areAllFiltersApplied, className, currentPage, disabled, disableReduced, hasMore, hideMaximizeButton, hideRefreshButton, isLoading, isPerforming, listId: outerListId, onDeleteFilters, onPageChange, onRefresh, pageCount, recordsCount: outerRecordsCount, reachedMax, showMaximizeOnSmallBreakpoints, variant, }: IPagination) => React__default.JSX.Element>;
+
+declare function useResponsiveTableContext(tableName?: string): TResponsiveTableContext;
+declare const ResponsiveTableContext: React__default.MemoExoticComponent<({ allowEdition, allowRowsKeyboardSorting, allowSelection, allowSorting, avoidReparseSelectionOnRowChange, children, className, currentBreakPoint, customLabels, columns, filters, rows, label, isMultiple, name, onChangeSelection, onFilterBlur, onFilterChange, onFilterPressEnter, onSelectRows, onSortChange, reserveColumnsForStates, SelectionHandler, variant, }: TResponsiveTableContextProps) => React__default.JSX.Element>;
+
+type TypedUseSelectorHook<TState> = <TSelected>(selector: (state: TState) => TSelected, equalityFn?: (a: TSelected, b: TSelected) => boolean) => TSelected;
+declare const responsiveTableStore: _reduxjs_toolkit_dist_configureStore.ToolkitStore<{
+    responsiveTableSlice: TResponsiveTableSlice;
+}, redux.AnyAction, [redux_thunk.ThunkMiddleware<{
+    responsiveTableSlice: TResponsiveTableSlice;
+}>]>;
+declare const useResponsiveTable: TypedUseSelectorHook<{
+    responsiveTableSlice: TResponsiveTableSlice;
+}>;
+
+declare const responsiveTableActions: _reduxjs_toolkit.CaseReducerActions<{
+    controller2UpdateSelectionState(state: immer_dist_internal.WritableDraft<TResponsiveTableSlice>, { payload: { tableName, ...payload }, }: {
+        payload: Partial<TResponsiveTableState> & {
+            tableName: string;
+        };
+        type: string;
+    }): void;
+    handleKey(state: immer_dist_internal.WritableDraft<Record<string, ISelectableState<IBasicColumn, IBasicFilter, string | TBasicRow>>>, { payload }: {
+        payload: THandleKey & {
+            id: string;
+        };
+        type: string;
+    }): void;
+    selectionStateUpdate(state: immer_dist_internal.WritableDraft<Record<string, ISelectableState<IBasicColumn, IBasicFilter, string | TBasicRow>>>, { payload: { id, ...payload } }: {
+        payload: Partial<ISelectableState<IBasicColumn, IBasicFilter, string | TBasicRow>> & {
+            id: string;
+        };
+        type: string;
+    }): void;
+    setNewFocused(state: immer_dist_internal.WritableDraft<Record<string, ISelectableState<IBasicColumn, IBasicFilter, string | TBasicRow>>>, { payload: { id, ...payload } }: {
+        payload: INewFocus & {
+            id: string;
+        };
+        type: string;
+    }): void;
+    updateByClick(state: immer_dist_internal.WritableDraft<Record<string, ISelectableState<IBasicColumn, IBasicFilter, string | TBasicRow>>>, { payload: { id, colIndex, rowIndex, ariaColIndex, ariaRowIndex, isFocused, ...payload }, }: {
+        payload: (_apia_util.TRequireOnlyOne<{
+            ariaRowIndex: number;
+            rowIndex: number;
+        }> & _apia_util.TRequireOnlyOne<{
+            ariaColIndex?: number | undefined;
+            colIndex: number;
+        }> & Pick<INewFocus, "isFocused" | "altKey" | "ctrlKey" | "shiftKey">) & {
+            id: string;
+        };
+        type: string;
+    }): void;
+    update(state: immer_dist_internal.WritableDraft<TResponsiveTableSlice>, { payload: { tableName, handleFocus, ...rest }, }: {
+        payload: Partial<TResponsiveTableState> & {
+            isFocused?: boolean | undefined;
+            handleFocus?: boolean | undefined;
+        } & {
+            tableName: string;
+        };
+        type: string;
+    }): void;
+    addRows(state: immer_dist_internal.WritableDraft<TResponsiveTableSlice>, { payload }: TResponsiveTableAction<{
+        newRows: TResponsiveTableRow[];
+    }>): void;
+    deleteRows(state: immer_dist_internal.WritableDraft<TResponsiveTableSlice>, { payload }: TResponsiveTableAction<{
+        rowIndices: number[];
+    }>): void;
+    destroy(state: immer_dist_internal.WritableDraft<TResponsiveTableSlice>, { payload: { tableName } }: TResponsiveTableAction): void;
+    swapFocusedRow(state: immer_dist_internal.WritableDraft<TResponsiveTableSlice>, { payload: { newIndex, tableName }, }: {
+        payload: {
+            newIndex: number;
+        } & {
+            tableName: string;
+        };
+        type: string;
+    }): void;
+}, "responsiveTableSlice">;
+
+/**
+ * Este controlador maneja la selección en una forma más directa que el anterior, manipulando los elementos del DOM directamente, y persistiendo en el store estas propiedades para garantizar la consistencia en los renderizados posteriores.
+ *
+ * Esto permite una experiencia más fluida en el manejo del foco. Además, al no depender del estado para calcular las propiedades, se tiene un mayor control sobre qué elementos son afectados y de qué manera, permitiendo
+ */
+declare class Controller2 {
+    readonly tableName: string;
+    constructor(tableName: string);
+    private events;
+    setEvents(events: {
+        onChangeSelection?: (newRows: TResponsiveTableRowsSelectionEvent) => unknown;
+        onSelectRows?: (newRows: TResponsiveTableRowsSelectionEvent, focusedIndex: number) => unknown;
+    }): void;
+    private unsubscribe;
+    private el;
+    setRef: (el: HTMLElement) => void;
+    handleClickEvent: (ev: MouseEvent) => void;
+    handleKeyDownEvent: (ev: KeyboardEvent) => void;
+    /**
+     * Returns a copy of the current state object
+     */
+    getState(): {
+        allowSorting?: boolean | undefined;
+        isMultiple?: boolean | undefined;
+        label?: string | undefined;
+        reserveColumnsForStates?: number | undefined;
+        allowEdition?: boolean | undefined;
+        allowRowsKeyboardSorting?: boolean | undefined;
+        allowSelection?: boolean | undefined;
+        columns: TResponsiveTableColumn[];
+        draggingRow?: number | undefined;
+        expandedRows: number[];
+        filters: _apia_util.TApiaFilter[];
+        focusedRow: number;
+        focusedColumn: number;
+        hasNonAdditionalFilters: boolean;
+        isEditionMode?: boolean | undefined;
+        isFocused: boolean;
+        nonAdditionalColumnsCount: number;
+        rows: TResponsiveTableRow<any>[];
+        scrollIntoViewRow?: number | undefined;
+        selectedRows: number[];
+        statesColumns: number;
+        accordionIndexColumns: TResponsiveTableIndexColumns;
+        isLoading: boolean;
+    };
+    setState(state: Partial<TResponsiveTableState>): void;
+    updateSelectionState(): void;
+}
+declare function makeController2(tableName: string): [Controller2, FC<TKeyHandlerProps>];
+
+type TDocNameCellRendererProps$1 = {
+    docName: string;
+    docUrl: string;
+};
+declare const DocNameCellRenderer: TResponsiveTableCellRenderer<TDocNameCellRendererProps$1>;
+
+type TDocNameCellRendererProps = {
+    docName: string;
+    docUrl: string;
+};
+type TDocNameCellRenderer = TAccordionCellRendererProps<TDocNameCellRendererProps>;
+declare const AccordionDocNameCellRenderer: TAccordionCellRenderer<TDocNameCellRendererProps>;
+
+interface IAccordionElement {
+    row: TResponsiveTableRow;
+    rowIndex: number;
+}
+declare const AccordionElement: React__default.MemoExoticComponent<({ row, rowIndex }: IAccordionElement) => React__default.JSX.Element | null>;
+
+declare const AccordionHTMLCellRenderer: TAccordionCellRenderer<{
+    html: string;
+}>;
+
+declare const AccordionRenderer: React__default.MemoExoticComponent<() => React__default.JSX.Element>;
+
+declare const AdditionalColumnDefaultRenderer: React__default.MemoExoticComponent<({ column, cell, }: TResponsiveTableCellRendererProps) => React__default.JSX.Element>;
+
+declare const DefaultCellRenderer: React__default.ForwardRefExoticComponent<{
+    cell: TResponsiveTableCell<Record<string, unknown>>;
+    column: TResponsiveTableColumn;
+    row: TResponsiveTableRow<Record<string, unknown>>;
+} & React__default.AllHTMLAttributes<HTMLTableCellElement> & React__default.RefAttributes<HTMLTableCellElement>>;
+
+declare const DefaultRowRenderer: TResponsiveTableRowRenderer;
+
+declare const HTMLCellRenderer: TResponsiveTableCellRenderer<{
+    html: string;
+}>;
+
+declare const IsLoadingRenderer: () => React.JSX.Element;
+
+declare function makeAccordionAsyncRenderer(additionalInfoGetter: (row: TResponsiveTableRow) => Promise<{
+    label?: string;
+    name: string;
+}[]>): TResponsiveTableCellRenderer;
+
+declare function makeAsyncRenderer(additionalInfoGetter: (row: TResponsiveTableRow) => Promise<{
+    label?: string;
+    name: string;
+    newline?: boolean;
+}[]>): TResponsiveTableCellRenderer;
+
+declare const NoEllipsisCellRenderer: React__default.MemoExoticComponent<React__default.ForwardRefExoticComponent<{
+    cell: TResponsiveTableCell<Record<string, unknown>>;
+    column: TResponsiveTableColumn;
+    row: TResponsiveTableRow<Record<string, unknown>>;
+} & React__default.AllHTMLAttributes<HTMLTableCellElement> & React__default.RefAttributes<HTMLTableCellElement>>>;
+
+declare const NoRegistersRenderer: () => React.JSX.Element;
+
+declare const PriorityAccordionRenderer: TAccordionCellRenderer;
+
+declare function getPriorityHandler(priority: string | undefined): string | undefined;
+declare const PriorityRenderer: TResponsiveTableCellRenderer<{
+    src: string;
+}>;
+
+declare const RowStatesRenderer: React__default.MemoExoticComponent<({ state, }: {
+    state: TResponsiveTableRowState;
+}) => React__default.JSX.Element>;
+
+declare const StatusAccordionRenderer: TAccordionCellRenderer;
+
+declare function getStatusRendererClassName(cellValue: string, columnName: string): string;
+declare const StatusRenderer: TResponsiveTableCellRenderer<{
+    src: string;
+}>;
+
+declare const TableRenderer: React__default.MemoExoticComponent<({ variant }: {
+    variant?: string | undefined;
+}) => React__default.JSX.Element>;
+
+export { AccordionCell, AccordionDocNameCellRenderer, AccordionElement, AccordionHTMLCellRenderer, AccordionRenderer, Additional, AdditionalColumnDefaultRenderer, Controller2, DefaultCellRenderer, DefaultRowRenderer, DocNameCellRenderer, HTMLCellRenderer, type IAccordionElement, IsLoadingRenderer, NoEllipsisCellRenderer, NoRegistersRenderer, Pagination, PriorityAccordionRenderer, PriorityRenderer, Responsive, ResponsiveTable, ResponsiveTableContext, RowStatesRenderer, Sort, StatusAccordionRenderer, StatusRenderer, type TAccordionCellRenderer, type TAccordionCellRendererProps, type TColoredElement, type TDocNameCellRenderer, type TDocNameCellRendererProps, type TResponsiveTableCell, type TResponsiveTableCellRenderer, type TResponsiveTableCellRendererProps, type TResponsiveTableColumn, type TResponsiveTableContext, type TResponsiveTableContextProps, type TResponsiveTableRow, type TResponsiveTableRowRenderer, type TResponsiveTableRowRendererProps, type TResponsiveTableRowState, type TResponsiveTableRowsSelectionEvent, type TResponsiveTableSortChangeEvent, type TResponsiveTableSortValue, type TResponsiveTableStoreProps, type TResponsiveTableWithRendererElement, TableRenderer, defaultLabels, getPriorityHandler, getStatusRendererClassName, makeAccordionAsyncRenderer, makeAsyncRenderer, makeController2, responsiveTableActions, responsiveTableStore, useResponsiveTable, useResponsiveTableContext };
 //# sourceMappingURL=index.d.ts.map