import { Maybe } from '@m4l/core';
import { Theme } from '@mui/material/styles';
import { MFBaseProps } from '../MFLoader/types';
import { Column, RowsChangeData, RenderCellProps, DataGridProps as NativeDataGridProps } from 'react-data-grid';
import { MenuAction, MenuItemAction } from '../MenuActions/types';
import { ActionsSlots, ColumnIconFormatterSlots, ColumnsConfigSlots, ControlNavigateSlots, DataGridSlots, RowsCountSlots, TableSlots, TextEditorSlots } from './slots/DataGridEnum';
import { OverridesStyleRules } from '@mui/material/styles/overrides';
import { DATAGRID_PREFIX_NAME } from './constants';
import { IGridConfigExtended, ViewMode } from './contexts/DataGridContext/types';
import { Sizes } from '@m4l/styles';
import { PagerProps } from '../Pager';
import { SettingsProps } from './views/TableView/subcomponents/Settings/types';
import { ReactNode } from 'react';
export type GridFormatterPropss<T, SR> = RenderCellProps<T, SR>;
export type { ColumnUncertaintyFormatter, ColumnPointsFormatter, ColumnNestedValueFormatter, } from './formatters';
export declare type ColumnType = 'string' | 'date' | 'number' | 'boolean' | 'custom';
export declare type ColumnAlign = 'left' | 'center' | 'right';
export declare type FieldPresence = 'initialized' | 'fixed' | 'optional';
export declare interface GridRow {
    id: number;
}
export declare type SortDirection = 'ASC' | 'DESC';
export interface SortColumn {
    readonly columnKey: string;
    readonly direction: SortDirection;
}
declare module 'react-data-grid' {
    interface Column<TRow, TSummaryRow = unknown> {
        visible?: boolean;
        hidden?: boolean;
        fixed?: boolean;
        type: ColumnType;
        exportable?: boolean;
        align?: ColumnAlign;
        isDraggable?: boolean;
        withFilter?: boolean;
        withinHeaderRenderer?: React.FunctionComponent<RenderHeaderCellProps<TRow, TSummaryRow>>;
        customFilter?: (row: TRow, value: string) => boolean;
        customSort?: (a: TRow, b: TRow) => number;
        /** @deprecated Usa renderCell en lugar de formatter. Este atributo será removido en una futura versión. */
        formatter?: (props: any) => JSX.Element;
        /** @deprecated Usa renderEditCell en lugar de editor. Este atributo será removido en una futura versión. */
        editor?: Maybe<(props: RenderEditCellProps<TRow, TSummaryRow>) => ReactNode>;
        /**
         * Si true, la columna puede ser agrupada/desagrupada por el usuario.
         * Solo aplica para TreeDataGrid.
         */
        groupable?: boolean;
        /**
         * Si true, la columna está agrupada por defecto.
         * - Con `groupable: true`: el usuario puede cambiar la agrupación.
         * - Sin `groupable` o `groupable: false`: agrupación estática, no se puede cambiar.
         * Solo aplica para TreeDataGrid.
         */
        grouped?: boolean;
    }
}
export declare type RowKey = string | number;
/**
 * Define una celda específica que tendrá un color de fondo personalizado.
 * rowKey - Identificador único de la fila (el mismo que usa rowKeyGetter)
 * columnKey - Identificador de la columna (el key de la columna)
 * color - Color de fondo a aplicar (puede ser hex como '#FF0000', rgb, etc.)
 */
export interface RowCellBackground<TKey extends RowKey = RowKey> {
    rowKey: TKey;
    columnKey: string;
    color: string;
}
/**
 * Función que retorna el color de fondo para una celda específica.
 * Esta variante es más óptima para muchas filas porque solo se llama
 * para las celdas visibles durante la virtualización.
 * @param rowKey - Identificador único de la fila
 * @param columnKey - Identificador de la columna
 * @returns El color de fondo (hex, rgb, etc.) o undefined/null para transparente
 */
export type RowCellsBackgroundGetter<TKey extends RowKey = RowKey> = (rowKey: TKey, columnKey: string) => string | undefined | null;
/**
 * Tipo union que permite array o función para rowCellsBackground.
 *
 * - Array: Más simple de usar, pero procesa todas las celdas al inicio
 * - Función: Más óptima para muchas filas, solo se llama para celdas visibles
 */
export type RowCellsBackgroundProp<TKey extends RowKey = RowKey> = RowCellBackground<TKey>[] | RowCellsBackgroundGetter<TKey>;
export declare interface WithActionsProps {
    withActions?: boolean;
}
export declare interface PagerState {
    page: number;
    rowsPerPage: number;
    totalRecords: number;
}
export declare const initialPagerState: PagerState;
export declare type RowHeightVariants = 'standard' | 'compact' | 'confortable';
export declare type RowHeights = number | number[];
/** Interface para la configuracion de las columnas de la tabla */
export interface ColumnConfig {
    key: string;
    width?: Maybe<string | number>;
    visible?: boolean;
    position?: number;
    frozen?: Maybe<boolean>;
}
type KeyConfig = keyof IGridConfigExtended;
/**
 * Tipo que representa un cambio de configuración del DataGrid.
 */
export interface ChangeConfig<T extends KeyConfig = KeyConfig> {
    reason: T;
    userConfig: IGridConfigExtended[T];
}
/**
 * @deprecated Usar `ChangeConfig` en su lugar. Este tipo será eliminado en futuras versiones.
 */
export type ChangeUserColumn = ChangeConfig;
/**
 * Callback que se ejecuta cuando cambia cualquier configuración del DataGrid.
 * Maneja todas las vistas genéricamente a través de IGridConfigExtended.
 */
export type OnChangeConfig = (props: ChangeConfig) => void;
/**
 * @deprecated Usar `OnChangeConfig` en su lugar. Este tipo será eliminado en futuras versiones.
 */
export type OnChangeUserColumns = OnChangeConfig;
export type SortApplied = {
    columnKey: string;
    removable: boolean;
    direction: Lowercase<SortDirection>;
};
export type SortAction = 'add' | 'remove';
export type SortChangeAdd = {
    action: 'add';
    columnKey: string;
    label: string;
    direction: Lowercase<SortDirection>;
};
export type SortChangeRemove = {
    action: 'remove';
    columnKey: string;
};
export type SortChangeEvent = SortChangeAdd | SortChangeRemove;
interface SortColumnConfig {
    name: string;
    skipColumnValidation?: boolean;
}
export interface SortSettings {
    sortsColumns: (string | SortColumnConfig)[];
    sortsApplied: SortApplied[];
    onChange: (event: SortChangeEvent) => void;
}
/**---------------------------------------------------------------- */
export type FilterChangeAdd = {
    action: 'add';
    columnKey: string;
};
export type FilterChangeOpenPopover = {
    action: 'openPopoverMenuFields';
};
export type FilterChangeEvent = FilterChangeAdd | FilterChangeOpenPopover;
interface FilterColumn {
    name: string;
    multiple: boolean;
    skipColumnValidation?: boolean;
}
export type FilterApplied = {
    columnKey: string;
    isValid: boolean;
};
export interface FilterSettings {
    filterColumns: FilterColumn[];
    filtersApplied: FilterApplied[];
    onChange: (event: FilterChangeEvent) => void;
}
/**
 * Tipo extendido de MenuItemAction específico para DataGrid.
 * Agrega la propiedad `isDefault` para acciones que se ejecutan al hacer double-click en una fila.
 */
export interface DataGridMenuItemAction extends MenuItemAction {
    /**
     * Si true, esta acción se ejecutará al hacer double-click en la fila del DataGrid.
     * Solo una acción debe tener isDefault: true por fila.
     */
    isDefault?: boolean;
}
/**
 * Tipo de acciones para DataGrid. Igual que MenuAction pero con soporte para isDefault.
 */
export type DataGridRowAction = DataGridMenuItemAction | Exclude<MenuAction, MenuItemAction>;
export type RowActionsGetter<TRow> = (row: TRow) => DataGridRowAction[];
export type RowKeyGetter<TRow, TKey extends RowKey = RowKey> = (row: TRow) => TKey;
/**--------------------Termina tipado de filtros-------------------------------------------- */
export interface GridProps<TRow, TSummaryRow, TKey extends RowKey = RowKey> extends Omit<NativeDataGridProps<TRow, TSummaryRow>, 'rowKeyGetter' | 'rows' | 'columns' | 'onRowsChange' | 'selectedRows' | 'onSelectedRowsChange' | 'renderers'> {
    id: string;
    withActions?: boolean;
    columns: readonly Column<TRow, TSummaryRow>[];
    /**
     * Propiedad que define la configuración de los sorts aplicados.
     */
    externalSortSettings?: SortSettings;
    /**
     * Propiedad que define la configuración de los filtros aplicados.
     */
    externalFilterSettings?: FilterSettings;
    rows: TRow[];
    initialRowHeightVariant?: RowHeightVariants;
    rowHeaderHeights?: RowHeights;
    rowHeights?: RowHeights;
    rowActionsGetter?: (row: TRow) => MenuAction[];
    rowKeyGetter: (row: TRow) => TKey;
    selectedRows?: ReadonlySet<TKey>;
    onSelectedRowsChange?: (mapRowsSelected: ReadonlySet<TKey>) => void;
    checkedRows?: ReadonlySet<TKey>;
    onCheckedRowsChange?: (mapRowsSelected: ReadonlySet<TKey>) => void;
    /**
     * Define si la selección de filas es múltiple (checkboxes) o única (radio buttons).
     *
     * - `true` (default): Permite seleccionar múltiples filas con checkboxes
     * - `false`: Permite seleccionar solo una fila con radio buttons
     */
    checkedRowsMultiple?: boolean;
    onRowsChange?: Maybe<(rows: TRow[], data: RowsChangeData<TRow, TSummaryRow>) => void>;
    /**
     * Initial DataGrid configuration (widths, order, visibility, viewMode).
     * Must be provided from network cookies; localStorage is not used.
     */
    defaultConfig?: IGridConfigExtended;
    /**
     * Callback que se ejecuta cuando cambia cualquier configuración del DataGrid.
     * @param props - Objeto con `reason` (tipo de cambio) y `userConfig` (nueva configuración)
     */
    onChangeConfig?: OnChangeConfig;
    /**
     * @deprecated Usar `defaultConfig` en su lugar. Esta prop será eliminada en futuras versiones.
     */
    defaultUserColumns?: IGridConfigExtended;
    /**
     * @deprecated Usar `onChangeConfig` en su lugar. Esta prop será eliminada en futuras versiones.
     */
    onChangeUserColumns?: OnChangeUserColumns;
    /**
     * Tamaño del componente
     * @default 'medium'
     */
    size?: Extract<Sizes, 'small' | 'medium'>;
    /**
     * Modo por defecto de visualización.
     *
     * IMPORTANTE: Si se especifica 'cards', es obligatorio proporcionar `cardsViewConfig`.
     */
    defaultViewMode?: ViewMode;
    /**
     * Configuración de la vista de "cards"
     * Incluye habilitación, configuración de columnas y renderizado personalizado.
     *
     * IMPORTANTE: Es obligatorio si `defaultViewMode` es 'cards'.
     */
    cardsViewConfig?: CardsViewConfig<TRow>;
    /**
     * Configuración de la vista "list" (vertical list of extended rows).
     * Same API as cards: columnsConfig (default) or customRender. Independent from cards; does not reuse card components.
     * Obligatorio si `defaultViewMode` es 'list'.
     */
    listViewConfig?: ListViewConfig<TRow>;
    /**
     * Key de la fila a la que se debe hacer scroll y highlight automáticamente.
     * Útil cuando se agrega un nuevo elemento y se quiere enfocar en él.
     */
    focusOnRowKey?: TKey;
    /**
     * Si true, el scroll automático al focusOnRowKey usa animación smooth.
     * Si false, el scroll es instantáneo (sin animación).
     * @default true
     */
    smoothScroll?: boolean;
    /**
     * Colores de fondo para celdas específicas.
     * - Array: `[{ rowKey, columnKey, color }]`
     * - Función: `(rowKey, columnKey) => color | undefined` (más óptima para muchas filas)
     */
    rowCellsBackground?: RowCellsBackgroundProp<TKey>;
    /**
     * Enables or disables column reordering (drag-and-drop headers and settings modal move buttons).
     * @default true
     */
    reorderable?: boolean;
}
export declare const DATAGRID_TEST_ID = "m4ldatagrid";
export declare const PREFIX_TEST_ATTRIBUTE = "data-testid";
export declare const TEST_PROP_COLUMNS = "data-testid-m4ldatagrid-columns";
export declare interface DataGridProps<TRow, TSummaryRow, TKey extends RowKey = RowKey> extends GridProps<TRow, TSummaryRow, TKey> {
    actionsProps: ActionsProps;
    dataTestId?: string;
    customHeader?: React.ReactNode;
    visibleCustomHeader?: boolean;
}
/**
 * Configuration to open the export microfrontend via AreasProvider (events_emit EMMIT_EVENT_HOST_EMERGE_WINDOW).
 * The DataGrid must be rendered inside HostToolsProvider and AreasProvider (e.g. MFIsolationApp or host app)
 * so that the export icon can emit the event and the host adds the window.
 */
export interface DataGridExportConfig {
    /** Module id of the export microfrontend (backend module id). */
    moduleId: string;
    /** Microfrontend loader props (prefix, debugPort, cache). */
    mfProps: MFBaseProps;
    /**
     * Optional. Called when the user clicks export to build params for the export MF
     * (e.g. current filters, selected row ids, column keys). Returned object is passed as dynamicParams.
     */
    getDynamicParams?: () => Record<string, unknown>;
    /** Window title. */
    title: string;
    /** Icon URL for the window. */
    iconUrl?: string;
    /** Modal dimensions and constraints. Export always opens as modal. */
    modalProps?: {
        width: number;
        height: number;
        minWindowWidth?: number;
        minWindowHeight?: number;
    };
}
export interface ActionsProps {
    withSettings?: boolean;
    settingsProps?: SettingsProps;
    withRowsCount?: boolean;
    withPager?: boolean;
    pagerOptions?: PagerProps;
    withLocalFilters?: boolean;
    leftActions?: React.ReactNode;
    rightActions?: React.ReactNode;
    /**
     * Export via AreasProvider: when the user clicks the export icon, the DataGrid emits
     * EMMIT_EVENT_HOST_EMERGE_WINDOW with this config so the host opens the export MF.
     * The export icon is only shown when at least one column has `exportable: true` and exportConfig is set.
     */
    exportConfig?: DataGridExportConfig;
}
/**
 * Props para el hook useModalDetail
 */
export interface UseModalDetailProps<TRow> {
    columns: readonly Column<TRow, any>[];
    viewMode: ViewMode;
    onRowsChange?: Maybe<(rows: TRow[], data: RowsChangeData<TRow, any>) => void>;
    /**
     * Array completo de todas las filas (necesario para reconstruir el array al editar en el modal)
     */
    rows: readonly TRow[];
}
/**
 * Configuración de una columna específica en vista "cards"
 */
export interface CardColumnConfig {
    /**
     * Key de la columna (debe coincidir con la key de la columna)
     */
    columnKey: string;
    /**
     * Si se debe mostrar el título/label de esta columna en la card (Solo si no existe una config previa)
     */
    showTitle: boolean;
}
/**
 * Cards con columnsConfig
 */
export interface CardsViewConfigWithColumns<TRow = unknown> {
    columnsConfig: CardColumnConfig[];
    customRender?: never;
    /**
     * When true, shows the expand (details) button on each card to open the detail modal.
     * @default true
     */
    showExpandButton?: boolean;
    /**
     * Optional handler when the expand button is clicked. When provided, this is called
     * instead of opening the detail modal. When not provided, default behavior is to open the detail modal.
     */
    onExpandClick?: (row: TRow) => void;
}
/**
 * Cards con customRender
 */
export interface CardsViewConfigWithCustomRender<TRow> {
    columnsConfig?: never;
    customRender: {
        renderContent: (row: TRow) => React.ReactNode;
        minHeight: number;
    };
}
/**
 * Configuración para la vista de "cards"
 *
 * IMPORTANTE:
 * Es OBLIGATORIO configurar al menos 1 columna cuando customRender=undefined
 * Se ignora completamente si customRender está definido
 * @throws Error si customRender=undefined y array está vacío
 */
export type CardsViewConfig<TRow> = CardsViewConfigWithColumns<TRow> | CardsViewConfigWithCustomRender<TRow>;
/**
 * List view with columnsConfig (default list rows, same column shape as cards).
 * Same expand/detail API as cards: showExpandButton and onExpandClick.
 */
export interface ListViewConfigWithColumns<TRow = unknown> {
    columnsConfig: CardColumnConfig[];
    customRender?: never;
    /**
     * When true, shows the expand (details) button on each list row to open the detail modal.
     * @default true
     */
    showExpandButton?: boolean;
    /**
     * Optional handler when the expand button is clicked. When provided, this is called
     * instead of opening the detail modal. When not provided, default behavior is to open the detail modal.
     */
    onExpandClick?: (row: TRow) => void;
}
/**
 * List view with customRender (custom row content).
 * minHeight is not required — TanStack Virtual measures row heights dynamically.
 */
export interface ListViewConfigWithCustomRender<TRow> {
    columnsConfig?: never;
    customRender: {
        renderContent: (row: TRow) => React.ReactNode;
        minHeight?: number;
    };
}
/**
 * Configuration for the "list" view. Same API as cards: default (columnsConfig) or custom (customRender).
 * List view is independent from cards; it works with extended card-style rows but does not reuse card components.
 */
export type ListViewConfig<TRow> = ListViewConfigWithColumns<TRow> | ListViewConfigWithCustomRender<TRow>;
/**
 * Opciones para el procesamiento de columnas
 */
export interface ProcessedColumnsOptions {
    /**
     * Si es true, aplica el filtro de visibilidad configurado por el usuario.
     * Si es false, muestra TODAS las columnas.
     * @default true
     */
    applyVisibilityFilter?: boolean;
}
/**
 * Props para el hook useCardContent
 */
export interface CardContentProps<TRow> {
    row: TRow;
    columns: readonly Column<TRow, any>[];
    originalColumns: readonly Column<TRow, any>[];
    onRowsChange?: Maybe<(rows: TRow[], data: RowsChangeData<TRow, any>) => void>;
    /**
     * Array completo de todas las filas (necesario para reconstruir el array al editar)
     */
    rows: readonly TRow[];
    /**
     * Índice de la fila actual en el array de filas
     */
    rowIndex: number;
}
/**
 * Props para el hook useListContent
 * (mismo shape que CardContentProps, separado por semántica).
 */
export interface ListContentProps<TRow> {
    row: TRow;
    columns: readonly Column<TRow, any>[];
    originalColumns: readonly Column<TRow, any>[];
    onRowsChange?: Maybe<(rows: TRow[], data: RowsChangeData<TRow, any>) => void>;
    /**
     * Array completo de todas las filas (necesario para reconstruir el array al editar)
     */
    rows: readonly TRow[];
    /**
     * Índice de la fila actual en el array de filas
     */
    rowIndex: number;
}
/**
 * Configuración de densidad para el DataGrid.
 * Define las alturas de filas, headers y la variante inicial.
 */
export interface DataGridDensityConfig {
    rowHeights: RowHeights;
    rowHeaderHeights: RowHeights;
    initialRowHeightVariant: RowHeightVariants;
}
export type DataGridOwnerState<TRow, TSummaryRow, TKey extends RowKey = RowKey> = Pick<DataGridProps<TRow, TSummaryRow, TKey>, 'visibleCustomHeader' | 'size'> & {
    currentRowHeightVariant?: RowHeightVariants;
    currentRowHeight?: number;
    viewMode?: ViewMode;
    isActive?: boolean;
    hasActions?: boolean;
    hasCheckedRows?: boolean;
};
export type DataGridSlotsType = DataGridSlots | TextEditorSlots | ActionsSlots | RowsCountSlots | ColumnsConfigSlots | TableSlots | ControlNavigateSlots | ColumnIconFormatterSlots;
export type DataGridStyles = OverridesStyleRules<DataGridSlotsType, typeof DATAGRID_PREFIX_NAME, Theme>;
/**
 * Props específicas de TreeDataGrid (de react-data-grid)
 * Estas props controlan la funcionalidad de agrupación jerárquica.
 *
 * NOTA: groupBy se calcula automáticamente desde columnsConfig.grouped
 * ordenadas por groupOrder. El desarrollador define grouped/groupable en columns.
 */
export interface TreeProps<TRow> {
    /**
     * Función que agrupa las filas por una columna.
     *
     * OPCIONAL: Si no se pasa, usa un rowGrouper genérico que agrupa
     * por el valor directo de la columna (row[columnKey]).
     *
     * Solo necesitas pasar un rowGrouper personalizado si quieres
     * transformar los valores antes de agrupar, por ejemplo:
     * - Agrupar fechas por mes ("Enero 2024")
     * - Agrupar números por rango ("$40k - $60k")
     * @see defaultRowGrouper en helpers/defaultRowGrouper
     */
    rowGrouper?: (rows: readonly TRow[], columnKey: string) => Record<string, readonly TRow[]>;
    /** IDs de grupos expandidos */
    expandedGroupIds?: ReadonlySet<unknown>;
    /** Callback cuando cambian los grupos expandidos */
    onExpandedGroupIdsChange?: (expandedGroupIds: Set<unknown>) => void;
}
/**
 * Props completas de TreeDataGrid.
 * Extiende DataGridProps pero sin cardsViewConfig ni defaultViewMode
 * ya que TreeDataGrid solo soporta vista de tabla.
 */
export interface TreeDataGridProps<TRow, TSummaryRow, TKey extends RowKey = RowKey> extends Omit<DataGridProps<TRow, TSummaryRow, TKey>, 'cardsViewConfig' | 'defaultViewMode'>, TreeProps<TRow> {
}
/**
 * Props para TableView con soporte opcional para TreeDataGrid
 */
export type TableViewProps<TRow, TSummaryRow, TKey extends RowKey = RowKey> = GridProps<TRow, TSummaryRow, TKey> & {
    /** Props para TreeDataGrid. Si se pasan, usa TreeDataGrid en lugar de DataGrid */
    treeProps?: TreeProps<TRow>;
};
//# sourceMappingURL=types.d.ts.map