@archbase/components 3.0.0

package/dist/admin/types.d.ts

@@ -0,0 +1,65 @@
+import { ReactNode } from 'react';
+import { URLSearchParamsInit } from 'react-router-dom';
+export type ArchbaseNavigationGroup = {
+    label: string;
+    icon: any;
+    name: string;
+    hint: string;
+    indexOrder: number;
+};
+export type ArchbaseNavigationItem = {
+    label: string;
+    icon: any;
+    link?: string | undefined;
+    routeParams?: URLSearchParamsInit;
+    initiallyOpened?: boolean;
+    links?: ArchbaseNavigationItem[];
+    category: string | undefined | null;
+    color: any | undefined;
+    component?: ReactNode;
+    showInSidebar: boolean;
+    disabled?: boolean | Function;
+    redirect?: string;
+    customTitle?: string;
+    keepAlive?: boolean;
+    group?: ArchbaseNavigationGroup;
+    hideDisabledItem?: boolean;
+};
+export type ArchbaseCommandColor = {
+    backgroundColor: string;
+    color: string;
+};
+export type ArchbaseCommandMenu = {
+    id: any;
+    command: () => void;
+    category: string;
+    color: ArchbaseCommandColor;
+    name: string;
+};
+export interface ArchbaseOwner {
+    uuid: string;
+    name: string;
+    logo: string;
+    code: string;
+}
+export interface ArchbaseCompany {
+    uuid: string;
+    name: string;
+    logo: string;
+    code: string;
+}
+export type ArchbaseTabItem = {
+    id: string;
+    title: string;
+    path: string;
+    content: React.ReactNode;
+    iconClass: any;
+    closeButton: boolean;
+    active: boolean;
+    redirect?: string;
+    customTitle?: string;
+};
+export type LocationDataItem = {
+    navItemUUID: string;
+    params: any;
+};

package/dist/buttons/ActionsDemo.d.ts

@@ -0,0 +1,2 @@
+import { ArchbaseAction } from './ArchbaseActionButtons';
+export declare const ActionsDemo: ArchbaseAction[];

package/dist/buttons/ArchbaseActionButtons.d.ts

@@ -0,0 +1,61 @@
+import React, { ReactNode } from 'react';
+export interface ActionButtonsCustomComponentsDefinition {
+    largeButtonType?: React.ElementType;
+    largeButtonProps?: any;
+    mediumButtonType?: React.ElementType;
+    mediumButtonProps?: any;
+    smallButtonType?: React.ElementType;
+    smallButtonProps?: any;
+}
+export interface ArchbaseAction {
+    /** Id da Action */
+    id: string;
+    /** Ícone do Action Button */
+    icon?: ReactNode;
+    /** Cor do Action Button */
+    color?: string;
+    /** Título da Action Button */
+    label: string;
+    /** Ação a ser executada ao clicar no Action Button */
+    executeAction: () => void;
+    /** Indicador se o Action Button está habilitado para executar a ação */
+    enabled: boolean;
+    /** Detalhamento da ação para ajudar o usuário*/
+    hint?: string;
+}
+export interface ArchbaseActionButtonsOptions {
+    /** Limite que determina a partir de quantos px o botão maior será renderizado*/
+    largerBreakPoint?: string;
+    /** Limite que determina a partir de quantos px o botão menor será renderizado*/
+    smallerBreakPoint?: string;
+    /** Espaçamento do botão maior */
+    largerSpacing?: string;
+    /** Espaçamento do botão menor */
+    smallerSpacing?: string;
+    /** Variação do botão maior */
+    largerButtonVariant?: string;
+    /** Variação do botão menor */
+    smallerButtonVariant?: string;
+    /** Variação do item do menu */
+    menuItemVariant?: string;
+    /** Variação do botão do menu */
+    menuButtonVariant?: string;
+    /** Cor do botão do menu */
+    menuButtonColor?: string;
+    /** Posição do dropdown do menu */
+    menuDropdownPosition?: 'bottom' | 'left' | 'right' | 'top' | 'bottom-end' | 'bottom-start' | 'left-end' | 'left-start' | 'right-end' | 'right-start' | 'top-end' | 'top-start';
+    /** Posição do menu */
+    menuPosition?: 'right' | 'left';
+    menuItemApplyActionColor?: boolean;
+}
+export interface ArchbaseActionButtonsProps {
+    /** Lista de ações */
+    actions: ArchbaseAction[];
+    /**  Variação padrão para todo o componente, que será sobrescrito pela variação mais específica de options */
+    variant?: string;
+    /** Opções de personalização */
+    options?: ArchbaseActionButtonsOptions;
+    /** Definição dos componentes personalizados */
+    customComponents?: ActionButtonsCustomComponentsDefinition;
+}
+export declare function ArchbaseActionButtons({ actions, variant, customComponents, options }: ArchbaseActionButtonsProps): import("react/jsx-runtime").JSX.Element;

package/dist/buttons/index.d.ts

@@ -0,0 +1,2 @@
+export { ArchbaseActionButtons } from './ArchbaseActionButtons';
+export type { ArchbaseActionButtonsProps, ArchbaseActionButtonsOptions, ArchbaseAction, ActionButtonsCustomComponentsDefinition, } from './ArchbaseActionButtons';

package/dist/charts/ArchbaseTimeline.d.ts

@@ -0,0 +1,24 @@
+export interface ArchbaseTimelineItem {
+    startTime: Date;
+    endTime: Date;
+    type: string;
+}
+export interface ArchbaseTimelineProps {
+    data: any[];
+    formatData: (value: any) => ArchbaseTimelineItem;
+    height?: string | number;
+    width?: string | number;
+    scale?: number;
+    decimalPlaces?: 0 | 1 | 2 | 3;
+    startTime?: Date;
+    endTime?: Date;
+    tickRate?: number;
+    itemHeight?: number;
+    withGridline?: boolean;
+    withOnHoverVerticalLine?: boolean;
+    tickLabelAngle?: number;
+    verticalLineColor?: string;
+    verticalLineStrokeWidth?: number;
+    verticalLineStrokeOpacity?: number;
+}
+export declare function ArchbaseTimeline({ data, formatData, width, height, scale: customScale, decimalPlaces, startTime, endTime, tickRate, itemHeight, withGridline, withOnHoverVerticalLine, tickLabelAngle, verticalLineColor, verticalLineStrokeWidth, verticalLineStrokeOpacity, }: ArchbaseTimelineProps): import("react/jsx-runtime").JSX.Element;

package/dist/charts/index.d.ts

@@ -0,0 +1,3 @@
+export { ArchbaseTimeline } from './ArchbaseTimeline';
+export type { ArchbaseTimelineItem, ArchbaseTimelineProps } from './ArchbaseTimeline';
+export * from './vis-timeline';

package/dist/charts/vis-timeline/ArchbaseVisTimeline.d.ts

@@ -0,0 +1,9 @@
+import type { ArchbaseVisTimelineProps, TimelineItem } from './ArchbaseVisTimeline.types';
+/**
+ * Componente wrapper para vis-timeline
+ * Implementação leve usando vis-timeline diretamente
+ */
+export declare function ArchbaseVisTimeline<T extends TimelineItem = TimelineItem>({ items, groups, options: customOptions, start, end, range, width, height, minHeight, orientation, layout, editable, selectable, multiselect, zoomable, moveable, showCurrentTime, showCustomTime, showMajorLabels, showMinorLabels, style, className, backgroundColor, itemColor, groupColor, disabled, loading, error, noData, onLoad, onError, on, ariaLabel, title, timelineRef, }: ArchbaseVisTimelineProps<T>): import("react/jsx-runtime").JSX.Element;
+export declare namespace ArchbaseVisTimeline {
+    var displayName: string;
+}

package/dist/charts/vis-timeline/ArchbaseVisTimeline.types.d.ts

@@ -0,0 +1,284 @@
+import type { CSSProperties, ReactNode } from 'react';
+/**
+ * Tipos de dados para itens da timeline
+ */
+export type TimelineItemType = 'box' | 'point' | 'range' | 'background';
+/**
+ * Item básico da timeline
+ */
+export interface TimelineItem {
+    /** ID único do item */
+    id: string | number;
+    /** Conteúdo a ser exibido */
+    content: string | ReactNode;
+    /** Data/hora de início */
+    start: Date | string | number;
+    /** Data/hora de fim (para ranges) */
+    end?: Date | string | number;
+    /** Tipo do item */
+    type?: TimelineItemType;
+    /** Grupo ao qual pertence */
+    group?: string | number;
+    /** ClassName customizado */
+    className?: string;
+    /** Estilo inline */
+    style?: CSSProperties;
+    /** Tooltip */
+    title?: string;
+    /** Editável */
+    editable?: boolean;
+    /** Dados adicionais */
+    data?: any;
+}
+/**
+ * Grupo da timeline
+ */
+export interface TimelineGroup {
+    /** ID único do grupo */
+    id: string | number;
+    /** Conteúdo do grupo */
+    content: string | ReactNode;
+    /** Order do grupo */
+    order?: number;
+    /** ClassName customizado */
+    className?: string;
+    /** Estilo inline */
+    style?: CSSProperties;
+    /** Título */
+    title?: string;
+}
+/**
+ * Opções de zoom da timeline
+ */
+export interface TimelineZoomOptions {
+    /** Zoom mínimo (ms por pixel) */
+    min?: number;
+    /** Zoom máximo (ms por pixel) */
+    max?: number;
+    /** Habilitar zoom com scroll */
+    zoomKey?: string | null;
+}
+/**
+ * Opções de movimento (pan)
+ */
+export interface TimelineMoveOptions {
+    /** Habilitar movimento arrastando */
+    moveable?: boolean;
+    /** Habilitar movimento com setas */
+    moveOnKey?: boolean;
+}
+/**
+ * Configuração de orientação da timeline
+ */
+export type TimelineOrientation = 'bottom' | 'top' | 'none' | 'both';
+/**
+ * Modo de layout
+ */
+export type TimelineLayout = 'box' | 'list';
+/**
+ * Opções de formatação de data
+ */
+export interface TimelineDateFormatOptions {
+    /** Formato para datas longas */
+    long?: string;
+    /** Formato para datas curtas */
+    short?: string;
+    /** Locale para formatação */
+    locale?: string;
+}
+/**
+ * Eventos da timeline
+ */
+export interface TimelineEvents {
+    /** Ao clicar em um item */
+    onItemClick?: (item: TimelineItem) => void;
+    /** Ao clicar duas vezes em um item */
+    onItemDoubleClick?: (item: TimelineItem) => void;
+    /** Ao clicar no fundo */
+    onCanvasClick?: (time: Date) => void;
+    /** Ao clicar duas vezes no fundo */
+    onCanvasDoubleClick?: (time: Date) => void;
+    /** Ao alterar a seleção */
+    onSelect?: (items: TimelineItem[] | TimelineGroup[]) => void;
+    /** Ao mudar o range visível */
+    onRangeChange?: (start: Date, end: Date) => void;
+    /** Ao arrastar um item */
+    onItemDrag?: (item: TimelineItem, callback: () => void) => void;
+    /** Ao mover um item */
+    onItemMove?: (item: TimelineItem, callback: () => void) => void;
+    /** Ao remover um item */
+    onItemRemove?: (item: TimelineItem, callback: () => void) => void;
+    /** Ao adicionar um item */
+    onItemAdd?: (item: TimelineItem, callback: () => void) => void;
+    /** Ao mudar os grupos */
+    onGroupDrag?: (group: TimelineGroup, callback: () => void) => void;
+}
+/**
+ * Props do componente ArchbaseVisTimeline
+ */
+export interface ArchbaseVisTimelineProps<T extends TimelineItem = TimelineItem> {
+    /** Itens da timeline */
+    items?: T[];
+    /** Grupos da timeline */
+    groups?: TimelineGroup[];
+    /** Opções da timeline */
+    options?: TimelineOptions;
+    /** --- Dados --- */
+    /** Período inicial */
+    start?: Date | string | number;
+    /** Período final */
+    end?: Date | string | number;
+    /** Período inicial e final */
+    range?: [Date | string | number, Date | string | number];
+    /** --- Layout --- */
+    /** Largura */
+    width?: string | number;
+    /** Altura */
+    height?: string | number;
+    /** Altura mínima */
+    minHeight?: string | number;
+    /** Orientação da timeline */
+    orientation?: TimelineOrientation;
+    /** Modo de layout */
+    layout?: TimelineLayout;
+    /** --- Funcionalidades --- */
+    /** Habilitar edição de itens */
+    editable?: boolean | {
+        updateTime?: boolean;
+        updateGroup?: boolean;
+        add?: boolean;
+        remove?: boolean;
+    };
+    /** Habilitar seleção */
+    selectable?: boolean;
+    /** Seleção múltipla */
+    multiselect?: boolean;
+    /** Habilitar zoom */
+    zoomable?: boolean | TimelineZoomOptions;
+    /** Habilitar movimento */
+    moveable?: boolean | TimelineMoveOptions;
+    /** Mostrar linha de tempo atual */
+    showCurrentTime?: boolean;
+    /** Mostrar barra de zoom personalizada */
+    showCustomTime?: boolean;
+    /** Mostrar dados em milissegundos */
+    showMajorLabels?: boolean;
+    /** Mostrar labels menores */
+    showMinorLabels?: boolean;
+    /** --- Estilização --- */
+    style?: CSSProperties;
+    className?: string;
+    /** Cor de fundo */
+    backgroundColor?: string;
+    /** Cor dos itens */
+    itemColor?: string;
+    /** Cor dos grupos */
+    groupColor?: string;
+    /** --- Estados --- */
+    disabled?: boolean;
+    loading?: ReactNode;
+    error?: ReactNode;
+    noData?: ReactNode;
+    /** --- Eventos --- */
+    onLoad?: () => void;
+    onError?: (error: Error) => void;
+    /** Eventos customizados da timeline */
+    on?: TimelineEvents;
+    /** --- Acessibilidade --- */
+    ariaLabel?: string;
+    title?: string;
+    /** --- Outros --- */
+    /** Ref para o elemento da timeline */
+    timelineRef?: React.RefObject<any> | ((instance: any) => void);
+}
+/**
+ * Opções completas da timeline (estilo vis-timeline)
+ */
+export interface TimelineOptions {
+    /** Altura */
+    height?: string | number;
+    /** Largura */
+    width?: string | number;
+    /** Altura mínima */
+    minHeight?: string | number;
+    /** Largura mínima */
+    minWidth?: string | number;
+    /** Orientação */
+    orientation?: TimelineOrientation;
+    /** Direção */
+    direction?: 'past' | 'future';
+    /** Auto-redimensionar */
+    autoResize?: boolean;
+    /** Modo de layout */
+    layout?: TimelineLayout;
+    /** Margem entre itens */
+    margin?: {
+        item?: {
+            horizontal: number;
+            vertical: number;
+        };
+        axis?: number;
+    };
+    /** Padding */
+    padding?: number;
+    /** Scrollbars */
+    showTooltips?: boolean;
+    /** Tooltip follows mouse */
+    tooltipOnItemUpdateTime?: boolean | {
+        followMouse: boolean;
+    };
+    /** Zoom */
+    zoomKey?: string;
+    /** Zoom min/max */
+    zoomMin?: number;
+    zoomMax?: number;
+    /** Move */
+    moveable?: boolean;
+    /** Move on key */
+    moveOnKey?: boolean;
+    /** Group editável */
+    groupEditable?: boolean;
+    /** Edições */
+    editable?: boolean | {
+        add?: boolean;
+        remove?: boolean;
+        updateTime?: boolean;
+        updateGroup?: boolean;
+        overrideItems?: boolean;
+    };
+    /** Seleção */
+    selectable?: boolean;
+    /** Seleção múltipla */
+    multiselect?: boolean;
+    /** Multi select por grupos */
+    multiselectPerGroup?: boolean;
+    /** Linha de tempo atual */
+    showCurrentTime?: boolean;
+    /** Tempo customizado */
+    showCustomTime?: boolean;
+    /** Locale */
+    locale?: string;
+    /** Formatos de data */
+    format?: TimelineDateFormatOptions | {
+        minorLabels: any;
+        majorLabels: any;
+    };
+    /** Moment locale */
+    moment?: (locale: string) => any;
+    /** Click para usar */
+    clickToUse?: boolean;
+    /** Show background para grupos */
+    groupOrder?: string | ((a: any, b: any) => number);
+    /** Snap */
+    snap?: ((date: Date, scale: string, step: number) => Date) | null;
+    /** Stack */
+    stack?: boolean;
+    /** Throttle redrawing */
+    throttleRedraw?: number;
+    /** Visible frame template */
+    visibleFrameTemplate?: (item: any) => string;
+    /** Horizontal scroll */
+    horizontalScroll?: boolean;
+    /** Vertical scroll */
+    verticalScroll?: boolean;
+}

package/dist/charts/vis-timeline/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * ArchbaseVisTimeline - Timeline Component (vis-timeline wrapper)
+ *
+ * Timeline visual avançada baseada em vis-timeline
+ * Suporta grupos, ranges, zoom, pan, e muito mais.
+ */
+export { ArchbaseVisTimeline } from './ArchbaseVisTimeline';
+export type { ArchbaseVisTimelineProps, TimelineItem, TimelineGroup, TimelineItemType, TimelineEvents, TimelineOptions, TimelineZoomOptions, TimelineMoveOptions, TimelineOrientation, TimelineLayout, TimelineDateFormatOptions, } from './ArchbaseVisTimeline.types';
+export { DEFAULT_TIMELINE_OPTIONS, mergeTimelineOptions, normalizeTimelineItems, normalizeTimelineGroups, normalizeDate, normalizeRange, formatTimelineDate, formatDuration, } from './utils/timelineOptions';

package/dist/charts/vis-timeline/utils/timelineOptions.d.ts

@@ -0,0 +1,68 @@
+import type { TimelineOptions, TimelineOrientation, TimelineLayout } from '../ArchbaseVisTimeline.types';
+/**
+ * Opções padrão para a timeline
+ */
+export declare const DEFAULT_TIMELINE_OPTIONS: Partial<TimelineOptions>;
+/**
+ * Opções por orientação
+ */
+export declare const ORIENTATION_OPTIONS: Record<TimelineOrientation, Partial<TimelineOptions>>;
+/**
+ * Opções por layout
+ */
+export declare const LAYOUT_OPTIONS: Record<TimelineLayout, Partial<TimelineOptions>>;
+/**
+ * Merge opções customizadas com padrão
+ */
+export declare function mergeTimelineOptions(custom?: Partial<TimelineOptions>): TimelineOptions;
+/**
+ * Converte itens para formato vis-timeline
+ */
+export declare function normalizeTimelineItems<T extends Record<string, any>>(items: T[]): Array<T & {
+    start: Date;
+    end?: Date;
+    content: string;
+    type?: string;
+}>;
+/**
+ * Converte grupos para formato vis-timeline
+ */
+export declare function normalizeTimelineGroups<T extends Record<string, any>>(groups: T[]): Array<T & {
+    content: string;
+}>;
+/**
+ * Normaliza data para objeto Date
+ */
+export declare function normalizeDate(date: Date | string | number): Date;
+/**
+ * Converte range para array de datas
+ */
+export declare function normalizeRange(range?: [Date | string | number, Date | string | number]): [Date, Date] | undefined;
+/**
+ * Gera opções de cores para timeline
+ */
+export declare function generateColorOptions(itemColor?: string, groupColor?: string, backgroundColor?: string): Partial<TimelineOptions>;
+/**
+ * Mapeia tipos de itens para tipos vis-timeline
+ */
+export declare const ITEM_TYPE_MAP: {
+    readonly box: "box";
+    readonly point: "point";
+    readonly range: "range";
+    readonly background: "background";
+};
+/**
+ * Calcula margem apropriada baseado no tipo de item
+ */
+export declare function calculateItemMargin(type?: string): {
+    horizontal: number;
+    vertical: number;
+};
+/**
+ * Formata data para exibição
+ */
+export declare function formatTimelineDate(date: Date, format?: 'short' | 'long'): string;
+/**
+ * Calcula duração entre duas datas em formato legível
+ */
+export declare function formatDuration(start: Date, end: Date): string;

package/dist/datagrid/components/index.d.ts

@@ -0,0 +1,6 @@
+export { default as GlobalSearchInput } from './toolbar/global-search-input';
+export { default as GridToolbar } from './toolbar/grid-toolbar';
+export { default as GridPagination } from './pagination/grid-pagination';
+export { ArchbaseItemRender } from "./render/archbase-data-grid-item-renderer";
+export type { ArchbaseItemRenderProps, ArchbaseItemRenderType } from "./render/archbase-data-grid-item-renderer.tsx";
+export * from '../types';

package/dist/datagrid/components/pagination/grid-pagination.d.ts

@@ -0,0 +1,7 @@
+import React from 'react';
+import { PaginationProps } from '../../types';
+/**
+ * Componente de paginação para o grid
+ */
+export declare const GridPagination: React.FC<PaginationProps>;
+export default GridPagination;

package/dist/datagrid/components/render/archbase-data-grid-item-renderer.d.ts

@@ -0,0 +1,10 @@
+export type ArchbaseItemRenderType = {
+    value: any;
+    label: string;
+    color: string;
+};
+export interface ArchbaseItemRenderProps {
+    currentValue: string | undefined;
+    values: ArchbaseItemRenderType[];
+}
+export declare function ArchbaseItemRender({ currentValue, values }: ArchbaseItemRenderProps): import("react/jsx-runtime").JSX.Element;

package/dist/datagrid/components/toolbar/global-search-input.d.ts

@@ -0,0 +1,16 @@
+import React from 'react';
+/**
+ * Props para o componente de pesquisa global
+ */
+export interface GlobalSearchInputProps {
+    value: string;
+    onChange: (value: string) => void;
+    onClear: () => void;
+    debounceTime?: number;
+}
+/**
+ * Componente para barra de pesquisa global integrado com Mantine
+ * Usa debounce para evitar chamadas excessivas durante a digitação
+ */
+export declare const GlobalSearchInput: React.FC<GlobalSearchInputProps>;
+export default GlobalSearchInput;

package/dist/datagrid/components/toolbar/grid-toolbar.d.ts

@@ -0,0 +1,19 @@
+import React from 'react';
+interface GridToolbarProps {
+    onRefresh: () => void;
+    onExport: () => void;
+    onPrint: () => void;
+    globalFilterValue: string;
+    onGlobalFilterChange: (value: string) => void;
+    renderAdditionalActions?: () => React.ReactNode;
+    enableGlobalFilter?: boolean;
+    allowExportData?: boolean;
+    allowPrintData?: boolean;
+    toolbarAlignment?: 'left' | 'right' | 'center';
+    toolbarLeftContent?: React.ReactNode;
+}
+/**
+ * Componente para a barra de ferramentas do grid
+ */
+export declare const GridToolbar: React.FC<GridToolbarProps>;
+export default GridToolbar;

package/dist/datagrid/hooks/index.d.ts

@@ -0,0 +1,3 @@
+export { useDetailPanels, useDetailPanelAutoClose, useDetailPanelPositions, useAvailableSpace } from './use-grid-details-panel';
+export { useGridData, type ArchbaseGridState } from './use-grid-data';
+export { useArchbaseDataGridStableRendering } from './use-grid-data-stable-rendering';

package/dist/datagrid/hooks/use-grid-data-stable-rendering.d.ts

@@ -0,0 +1,15 @@
+import { IArchbaseDataSourceBase } from '@archbase/data';
+/**
+ * Hook para estabilizar o comportamento da Grid e evitar chamadas duplicadas à busca,
+ * além de preservar o foco em inputs durante interações.
+ * Suporta tanto ArchbaseDataSource (V1) quanto ArchbaseRemoteDataSourceV2 (V2)
+ */
+export declare function useArchbaseDataGridStableRendering<T extends object, ID>({ dataSource, debounceTime }: {
+    dataSource: IArchbaseDataSourceBase<T>;
+    debounceTime?: number;
+}): {
+    rows: T[];
+    totalRecords: number;
+    isLoading: boolean;
+    refreshData: () => void;
+};

package/dist/datagrid/hooks/use-grid-data.d.ts

@@ -0,0 +1,32 @@
+import { GridFilterModel, GridRowSelectionModel, GridSortModel, GridPaginationModel, GridEventListener } from '@mui/x-data-grid';
+import { IArchbaseDataSourceBase } from '@archbase/data';
+/**
+ * Interface para o estado do grid
+ */
+export interface ArchbaseGridState<T> {
+    rows: T[];
+    totalRecords: number;
+    totalPages: number;
+    isLoading: boolean;
+    paginationModel: GridPaginationModel;
+    sortModel: GridSortModel;
+    filterModel: GridFilterModel;
+    selectionModel: GridRowSelectionModel;
+    selectedRowsData: T[];
+    setPaginationModel: (model: GridPaginationModel) => void;
+    setSortModel: (model: GridSortModel) => void;
+    setFilterModel: (model: GridFilterModel) => void;
+    setSelectionModel: (model: GridRowSelectionModel) => void;
+    refreshData: () => void;
+    handleCellKeyDown: GridEventListener<'cellKeyDown'>;
+}
+/**
+ * Hook personalizado para integrar o MUI X DataGrid com o ArchbaseDataSource (V1 ou V2)
+ */
+export declare function useGridData<T extends object, ID>({ dataSource, pageSize, pageIndex, getRowId, columns }: {
+    dataSource: IArchbaseDataSourceBase<T>;
+    pageSize?: number;
+    pageIndex?: number;
+    getRowId: (row: T) => any;
+    columns: any[];
+}): ArchbaseGridState<T>;