@archbase/components 3.0.0

package/dist/datagrid/hooks/use-grid-details-panel.d.ts

@@ -0,0 +1,51 @@
+import { GridRowId } from '@mui/x-data-grid';
+/**
+ * Hook personalizado para gerenciar os painéis de detalhes
+ */
+export declare function useDetailPanels<T extends object = any>({ allowMultipleDetailPanels, onDetailPanelChange, detailPanelMinHeight }?: {
+    allowMultipleDetailPanels?: boolean;
+    onDetailPanelChange?: (expandedRowIds: GridRowId[]) => void;
+    detailPanelMinHeight?: number;
+}): {
+    expandedRowIds: Set<GridRowId>;
+    detailPanelHeight: number;
+    detailPanelRefs: import("react").RefObject<Map<GridRowId, HTMLDivElement>>;
+    toggleExpand: (rowId: GridRowId) => void;
+    closeDetailPanel: (rowId: GridRowId) => void;
+    closeAllDetailPanels: () => void;
+    expandDetailPanel: (rowId: GridRowId) => void;
+    setExpandedRowIds: import("react").Dispatch<import("react").SetStateAction<Set<GridRowId>>>;
+};
+/**
+ * Hook para detectar cliques fora e scroll para fechar os painéis de detalhes
+ */
+export declare function useDetailPanelAutoClose({ containerRef, expandedRowIds, detailPanelRefs, closeAllDetailPanels }: {
+    containerRef: React.RefObject<HTMLElement | null>;
+    expandedRowIds: Set<GridRowId>;
+    detailPanelRefs: React.MutableRefObject<Map<GridRowId, HTMLDivElement>>;
+    closeAllDetailPanels: () => void;
+}): void;
+/**
+ * Hook para calcular as posições dos painéis de detalhes inline
+ */
+export declare function useDetailPanelPositions<T extends object = any>({ rows, getRowId, safeGetRowId, expandedRowIds, detailPanelHeights, rowHeight, headerHeight, detailPanelMinHeight }: {
+    rows: T[];
+    getRowId?: (row: T) => any;
+    safeGetRowId: (row: T, getRowId?: any) => any;
+    expandedRowIds: Set<GridRowId>;
+    detailPanelHeights: Map<GridRowId, number>;
+    rowHeight?: number;
+    headerHeight?: number;
+    detailPanelMinHeight?: number;
+}): () => Map<GridRowId, number>;
+/**
+ * Hook para verificar o espaço disponível na viewport
+ */
+export declare function useAvailableSpace<T extends object = any>({ containerRef, rows, getRowId, safeGetRowId, rowHeight, detailPanelMinHeight }: {
+    containerRef: React.RefObject<HTMLElement | null>;
+    rows: T[];
+    getRowId?: (row: T) => any;
+    safeGetRowId: (row: T, getRowId?: any) => any;
+    rowHeight?: number;
+    detailPanelMinHeight?: number;
+}): boolean;

package/dist/datagrid/index.d.ts

@@ -0,0 +1,6 @@
+export * from './main';
+export * from './components';
+export * from './hooks';
+export * from './utils';
+export * from './modals';
+export * from './types';

package/dist/datagrid/main/archbase-data-grid-column.d.ts

@@ -0,0 +1,26 @@
+import { ArchbaseDataGridColumnProps } from './archbase-data-grid-types';
+export type GridFieldDataType = 'text' | 'integer' | 'currency' | 'boolean' | 'date' | 'datetime' | 'time' | 'enum' | 'image' | 'uuid';
+export type InputFieldType = 'text' | 'select' | 'multi-select' | 'range' | 'checkbox' | 'date' | 'date-range';
+export type AlignType = 'left' | 'center' | 'right';
+export type EnumValuesColumnFilter = {
+    label: string;
+    value: string;
+};
+declare function ArchbaseDataGridColumn<T>(_props: ArchbaseDataGridColumnProps<T>): any;
+declare namespace ArchbaseDataGridColumn {
+    var defaultProps: {
+        visible: boolean;
+        size: number;
+        align: string;
+        enableColumnFilter: boolean;
+        enableGlobalFilter: boolean;
+        headerAlign: string;
+        footerAlign: string;
+        enableClickToCopy: boolean;
+        enableSorting: boolean;
+        dataType: string;
+        inputFilterType: string;
+        enumValues: any[];
+    };
+}
+export default ArchbaseDataGridColumn;

package/dist/datagrid/main/archbase-data-grid-formatters.d.ts

@@ -0,0 +1,57 @@
+import { ReactNode } from 'react';
+import { MaskOptions } from '@archbase/core';
+/**
+ * Renderiza texto com máscara opcional e decodificação automática de base64
+ */
+export declare const renderText: (cell: any, maskOptions?: MaskOptions) => ReactNode;
+/**
+ * Renderiza números inteiros
+ */
+export declare const renderInteger: (cell: any) => ReactNode;
+/**
+ * Renderiza valores monetários
+ */
+export declare const renderCurrency: (cell: any) => ReactNode;
+/**
+ * Renderiza valores com decimais
+ */
+export declare const renderFloat: (cell: any) => ReactNode;
+/**
+ * Renderiza valores percentuais
+ */
+export declare const renderPercent: (cell: any, decimalPlaces?: number) => ReactNode;
+/**
+ * Renderiza valores booleanos com checkbox
+ */
+export declare const renderBoolean: (cell: any) => ReactNode;
+/**
+ * Renderiza datas
+ */
+export declare const renderDate: (cell: any, dateFormat?: string) => ReactNode;
+/**
+ * Renderiza data e hora
+ */
+export declare const renderDateTime: (cell: any, dateTimeFormat?: string) => ReactNode;
+/**
+ * Renderiza valores de hora
+ */
+export declare const renderTime: (cell: any, timeFormat?: string) => ReactNode;
+/**
+ * Renderiza valores de enum/lista
+ */
+export declare const renderEnum: (cell: any, enumValues: Array<{
+    label: string;
+    value: string;
+}>) => ReactNode;
+/**
+ * Renderiza UUID formatado
+ */
+export declare const renderUUID: (cell: any) => ReactNode;
+/**
+ * Retorna o renderer adequado com base no tipo de dado
+ */
+export declare const getRendererByDataType: (dataType: string, customRender?: (data: any) => ReactNode, options?: any) => ((cell: any) => ReactNode);
+/**
+ * Retorna o alinhamento recomendado com base no tipo de dado
+ */
+export declare const getAlignmentByDataType: (dataType: string, customAlign?: string) => string;

package/dist/datagrid/main/archbase-data-grid-pagination.d.ts

@@ -0,0 +1,8 @@
+import React from 'react';
+import { ArchbaseDataGridPaginationProps } from './archbase-data-grid-types';
+/**
+ * Componente de paginação da grid
+ * Extraído para fora da grid para melhor organização
+ */
+export declare const ArchbaseDataGridPagination: React.NamedExoticComponent<ArchbaseDataGridPaginationProps>;
+export default ArchbaseDataGridPagination;

package/dist/datagrid/main/archbase-data-grid-toolbar.d.ts

@@ -0,0 +1,7 @@
+import React from 'react';
+import { ArchbaseDataGridToolbarProps } from './archbase-data-grid-types';
+/**
+ * Componente da barra de ferramentas da grid
+ * Extraído para fora da grid para evitar problemas de foco em inputs
+ */
+export declare const ArchbaseDataGridToolbar: React.NamedExoticComponent<ArchbaseDataGridToolbarProps>;

package/dist/datagrid/main/archbase-data-grid-types.d.ts

@@ -0,0 +1,252 @@
+import React from 'react';
+import { MutableRefObject, ReactNode, RefObject } from 'react';
+import { GridRowId, GridFilterModel, GridPaginationModel } from '@mui/x-data-grid';
+import { IArchbaseDataSourceBase } from '@archbase/data';
+import type { ArchbaseFilterDefinition, ArchbaseActiveFilter } from '../../filters/ArchbaseCompositeFilters.types';
+/**
+ * DataGrid Types - V1/V2 Compatible
+ *
+ * These types support both V1 and V2 DataSource versions.
+ * The actual V1/V2 compatibility logic is handled in the
+ * components that use these types (like ArchbaseDataGrid and useGridData).
+ */
+export interface ArchbaseDataGridRef<T = any> {
+    /**
+     * Obtém as linhas selecionadas
+     */
+    getSelectedRows: () => T[];
+    /**
+     * Limpa a seleção
+     */
+    clearSelection: () => void;
+    /**
+     * Atualiza os dados da grid
+     */
+    refreshData: () => void;
+    /**
+     * Exporta os dados da grid
+     */
+    exportData: () => void;
+    /**
+     * Imprime os dados da grid
+     */
+    printData: () => void;
+    expandRow: (rowId: GridRowId) => void;
+    collapseRow: (rowId: GridRowId) => void;
+    collapseAllRows: () => void;
+    getExpandedRows: () => GridRowId[];
+}
+export interface GridToolBarActionsProps {
+    children: ReactNode;
+}
+export interface GridColumnsProps {
+    children: ReactNode;
+}
+export interface ArchbaseDataGridToolbarProps {
+    dataSource: IArchbaseDataSourceBase<any>;
+    filterModel: GridFilterModel;
+    enableGlobalFilter?: boolean;
+    enableTopToolbarActions?: boolean;
+    allowExportData?: boolean;
+    allowPrintData?: boolean;
+    toolbarAlignment?: 'left' | 'right' | 'center';
+    toolbarLeftContent?: ReactNode;
+    renderToolbarActions?: () => ReactNode;
+    renderToolbarInternalActions?: (props: {
+        table: any;
+    }) => ReactNode | null;
+    theme: any;
+    onFilterModelChange: (newFilterModel: GridFilterModel) => void;
+    onRefresh: () => void;
+    onExport: () => void;
+    onPrint: () => void;
+    apiRef: any;
+    children: ReactNode;
+    useCompositeFilters?: boolean;
+    filterDefinitions?: ArchbaseFilterDefinition[];
+    activeFilters?: ArchbaseActiveFilter[];
+    onFiltersChange?: (filters: ArchbaseActiveFilter[], rsql?: string) => void;
+    hideMuiFilters?: boolean;
+}
+export interface ArchbaseDataGridPaginationProps {
+    paginationModel: GridPaginationModel;
+    totalRecords: number;
+    onPaginationModelChange: (model: GridPaginationModel) => void;
+    paginationLabels?: {
+        totalRecords?: string;
+        pageSize?: string;
+        currentPage?: string;
+        of?: string;
+    };
+    bottomToolbarMinHeight?: string | number;
+    theme: any;
+}
+/**
+ * Componente para definir ações na barra de ferramentas
+ */
+export declare function GridToolBarActions(props: GridToolBarActionsProps): import("react/jsx-runtime").JSX.Element;
+/**
+ * Componente para agrupar as definições de colunas
+ */
+export declare function Columns(props: GridColumnsProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace Columns {
+    var componentName: string;
+}
+/**
+ * Componente para definir uma coluna na grid
+ * Este componente é apenas declarativo e não renderiza nada
+ */
+export declare function ArchbaseDataGridColumn<T>(_props: ArchbaseDataGridColumnProps<T>): any;
+export declare namespace ArchbaseDataGridColumn {
+    var defaultProps: {
+        visible: boolean;
+        size: number;
+        align: string;
+        enableColumnFilter: boolean;
+        enableGlobalFilter: boolean;
+        headerAlign: string;
+        footerAlign: string;
+        enableClickToCopy: boolean;
+        enableSorting: boolean;
+        dataType: string;
+        inputFilterType: string;
+        enumValues: any[];
+        hideWhenNoPermission: boolean;
+        autoRegisterPermission: boolean;
+        fallbackContent: string;
+    };
+}
+export interface ArchbaseDataGridProps<T extends object = any, ID = any> {
+    dataSource: IArchbaseDataSourceBase<T>;
+    getRowId?: (row: T) => ID;
+    /** Nome do recurso para ativar segurança no grid */
+    resourceName?: string;
+    /** Descrição do recurso para contexto de segurança */
+    resourceDescription?: string;
+    /** Configurações de segurança para colunas */
+    columnSecurityOptions?: {
+        /** Fallback padrão para colunas sem permissão */
+        defaultFallback?: ReactNode | string;
+        /** Se true, oculta colunas sem permissão por padrão */
+        hideByDefault?: boolean;
+        /** Prefixo para auto-registro de permissões de coluna */
+        permissionPrefix?: string;
+    };
+    enableColumnResizing?: boolean;
+    enableRowNumbers?: boolean;
+    enableRowSelection?: boolean;
+    enableRowActions?: boolean;
+    enableColumnFilterModes?: boolean;
+    enableGlobalFilter?: boolean;
+    enableTopToolbar?: boolean;
+    enableTopToolbarActions?: boolean;
+    showPagination?: boolean;
+    manualFiltering?: boolean;
+    manualPagination?: boolean;
+    manualSorting?: boolean;
+    isLoading?: boolean;
+    isError?: boolean;
+    error?: any;
+    height?: string | number;
+    width?: string | number;
+    pageSize?: number;
+    pageIndex?: number;
+    children?: ReactNode;
+    renderRowActions?: (row: T) => ReactNode;
+    renderToolbarActions?: () => ReactNode;
+    renderToolbarInternalActions?: (props: {
+        table: any;
+    }) => ReactNode | null;
+    renderTopToolbar?: ReactNode;
+    renderDetailPanel?: (props: {
+        row: T;
+    }) => ReactNode;
+    allowMultipleDetailPanels?: boolean;
+    detailPanelMinHeight?: number;
+    detailPanelStyle?: React.CSSProperties;
+    detailPanelClassName?: string;
+    onDetailPanelChange?: (expandedRowIds: GridRowId[]) => void;
+    detailPanelDisplayMode?: 'auto' | 'inline' | 'modal' | 'drawer';
+    detailPanelTitle?: string | ((rowId: GridRowId, rowData: T) => string);
+    detailPanelPosition?: 'right' | 'left' | 'bottom' | 'top';
+    detailPanelSize?: string | number;
+    allowColumnFilters?: boolean;
+    allowExportData?: boolean;
+    allowPrintData?: boolean;
+    useCompositeFilters?: boolean;
+    filterDefinitions?: ArchbaseFilterDefinition[];
+    activeFilters?: ArchbaseActiveFilter[];
+    onFiltersChange?: (filters: ArchbaseActiveFilter[], rsql?: string) => void;
+    hideMuiFilters?: boolean;
+    withBorder?: boolean;
+    withColumnBorders?: boolean;
+    highlightOnHover?: boolean;
+    striped?: boolean;
+    className?: string;
+    variant?: 'filled' | 'outlined';
+    fontSize?: string | number;
+    cellPadding?: string | number;
+    tableHeadCellPadding?: string;
+    columnAutoWidth?: boolean;
+    rowHeight?: number;
+    printTitle?: string;
+    logoPrint?: string;
+    globalDateFormat?: string;
+    csvOptions?: any;
+    toolbarAlignment?: 'left' | 'right' | 'center';
+    positionActionsColumn?: 'first' | 'last';
+    toolbarLeftContent?: ReactNode;
+    bottomToolbarMinHeight?: string | number;
+    paginationLabels?: Record<string, string>;
+    showProgressBars?: boolean;
+    onSelectedRowsChanged?: (rows: T[]) => void;
+    onCellDoubleClick?: (params: {
+        id: any;
+        columnName: string;
+        rowData: T;
+    }) => void;
+    onExport?: (callback: () => void) => void;
+    onPrint?: (callback: () => void) => void;
+    gridRef?: RefObject<ArchbaseDataGridRef<T>> | MutableRefObject<ArchbaseDataGridRef<T> | null>;
+}
+export interface CellClickEvent {
+    id: GridRowId;
+    columnName: string;
+    rowData: any;
+}
+export type FieldDataType = 'text' | 'integer' | 'float' | 'currency' | 'boolean' | 'date' | 'datetime' | 'time' | 'enum' | 'image' | 'uuid';
+export interface ArchbaseDataGridColumnProps<T = any> {
+    header: string;
+    footer?: string;
+    dataField: string;
+    enableColumnFilter?: boolean;
+    enableGlobalFilter?: boolean;
+    dataFieldAcessorFn?: (originalRow: T) => any;
+    dataType: FieldDataType;
+    maskOptions?: any;
+    inputFilterType?: string;
+    enumValues?: Array<{
+        label: string;
+        value: string;
+    }>;
+    minSize?: number;
+    maxSize?: number;
+    render?: (data: any) => ReactNode;
+    visible: boolean;
+    size: number;
+    enableClickToCopy: boolean;
+    enableSorting: boolean;
+    align?: string;
+    headerAlign?: string;
+    footerAlign?: string;
+    /** Nome da permissão para visualizar esta coluna */
+    viewPermission?: string;
+    /** Nome da permissão para editar esta coluna (futuro) */
+    editPermission?: string;
+    /** Componente/texto a ser exibido quando não tem permissão */
+    fallbackContent?: ReactNode | string;
+    /** Se true, oculta coluna completamente sem permissão. Se false, mostra fallback */
+    hideWhenNoPermission?: boolean;
+    /** Auto-registra a permissão da coluna (padrão: true) */
+    autoRegisterPermission?: boolean;
+}

package/dist/datagrid/main/archbase-data-grid-utils.d.ts

@@ -0,0 +1,45 @@
+import { GridFilterModel, GridRowId, GridSortModel, GridColDef } from '@mui/x-data-grid';
+import type { ArchbaseFilterDefinition, ArchbaseActiveFilter } from '../../filters/ArchbaseCompositeFilters.types';
+/**
+ * Obtém o ID de uma linha de forma segura
+ */
+export declare const safeGetRowId: <T extends object>(row: T, getRowId?: (row: T) => any) => GridRowId | undefined;
+/**
+ * Constrói uma expressão de busca global
+ */
+export declare const buildGlobalFilterExpression: (filterValue: string, columns: any[]) => string | undefined;
+/**
+ * Constrói uma expressão de filtro
+ */
+export declare const buildFilterExpression: (filterModel: GridFilterModel, columns: any[]) => string | undefined;
+/**
+ * Converte valores hexadecimais para RGB
+ */
+export declare const getRgbValues: (hexColor: string) => string;
+/**
+ * Obtém o modelo de ordenação inicial a partir do DataSource
+ */
+export declare const getInitialSortModel: (dataSource: any) => GridSortModel;
+/**
+ * Converte RSQL para GridFilterModel do MUI X DataGrid
+ * Permite compatibilidade entre ArchbaseCompositeFilters e o sistema nativo do MUI
+ */
+export declare const convertRSQLToFilterModel: (rsql: string | undefined, columns: GridColDef[]) => GridFilterModel;
+/**
+ * Converte ArchbaseActiveFilter[] para GridFilterModel
+ */
+export declare const convertActiveFiltersToFilterModel: (activeFilters: ArchbaseActiveFilter[]) => GridFilterModel;
+/**
+ * Converte colunas do Grid para ArchbaseFilterDefinition[]
+ * Permite gerar automaticamente as definições de filtro a partir das colunas
+ */
+export declare const convertColumnsToFilterDefinitions: (columns: GridColDef[], options?: {
+    includeColumns?: string[];
+    excludeColumns?: string[];
+    onlyFilterable?: boolean;
+}) => ArchbaseFilterDefinition[];
+/**
+ * Converte ArchbaseFilterDefinition para GridColDef[]
+ * Útil para criar colunas automaticamente a partir de definições de filtro
+ */
+export declare const convertFilterDefinitionsToColumns: (definitions: ArchbaseFilterDefinition[]) => GridColDef[];

package/dist/datagrid/main/archbase-data-grid.d.ts

@@ -0,0 +1,9 @@
+import { ArchbaseDataGridProps } from './archbase-data-grid-types';
+/**
+ * Componente ArchbaseDataGrid - Grid avançada baseada no MUI X DataGrid
+ * com toolbar e paginação extraídos para fora da grid para evitar problemas de foco
+ *
+ * Suporta tanto ArchbaseDataSource (V1) quanto ArchbaseRemoteDataSourceV2 (V2)
+ */
+declare function ArchbaseDataGrid<T extends object = any, ID = any>(props: ArchbaseDataGridProps<T, ID>): import("react/jsx-runtime").JSX.Element;
+export default ArchbaseDataGrid;

package/dist/datagrid/main/archbase-detail-panel-component.d.ts

@@ -0,0 +1,52 @@
+import React from 'react';
+import { GridRowId } from '@mui/x-data-grid';
+/**
+ * Componente para renderizar o painel de detalhes inline (diretamente abaixo da linha na grid)
+ */
+export declare function ArchbaseDetailPanel<T extends object = any>({ rowData, rowId, renderDetailPanel, onClose, theme, className, style, title, fixed }: {
+    rowData: T;
+    rowId: GridRowId;
+    renderDetailPanel: (props: {
+        row: T;
+    }) => React.ReactNode;
+    onClose: (rowId: GridRowId) => void;
+    theme: any;
+    className?: string;
+    style?: React.CSSProperties;
+    title?: string;
+    fixed?: boolean;
+}): import("react/jsx-runtime").JSX.Element;
+/**
+ * Componente para renderizar o painel de detalhes como modal
+ */
+export declare function ArchbaseDetailModal<T extends object = any>({ rowId, rowData, renderDetailPanel, onClose, theme, className, style, opened, title }: {
+    rowId: GridRowId;
+    rowData: T;
+    renderDetailPanel: (props: {
+        row: T;
+    }) => React.ReactNode;
+    onClose: (rowId: GridRowId) => void;
+    theme: any;
+    className?: string;
+    style?: React.CSSProperties;
+    opened: boolean;
+    title?: string;
+}): import("react/jsx-runtime").JSX.Element;
+/**
+ * Componente para renderizar o painel de detalhes como drawer (desliza da direita/esquerda)
+ */
+export declare function ArchbaseDetailDrawer<T extends object = any>({ rowId, rowData, renderDetailPanel, onClose, theme, className, style, opened, title, position, size }: {
+    rowId: GridRowId;
+    rowData: T;
+    renderDetailPanel: (props: {
+        row: T;
+    }) => React.ReactNode;
+    onClose: (rowId: GridRowId) => void;
+    theme: any;
+    className?: string;
+    style?: React.CSSProperties;
+    opened: boolean;
+    title?: string;
+    position?: 'left' | 'right' | 'top' | 'bottom';
+    size?: string | number;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/datagrid/main/archbase-expand-button.d.ts

@@ -0,0 +1,22 @@
+import React from 'react';
+import { GridRowId } from '@mui/x-data-grid';
+/**
+ * Componente que renderiza o botão de expansão para mostrar/ocultar detalhes
+ */
+export declare function ArchbaseExpandButton({ rowId, expanded, onClick, buttonRef }: {
+    rowId: GridRowId;
+    expanded: boolean;
+    onClick: (rowId: GridRowId) => void;
+    buttonRef?: React.RefObject<HTMLButtonElement>;
+}): import("react/jsx-runtime").JSX.Element;
+/**
+ * Função auxiliar para criar a coluna de expansão com referências aos botões
+ */
+export declare function createExpandColumn(expandedRowIds: Set<GridRowId>, onToggleExpand: (rowId: GridRowId) => void, buttonRefs?: Map<GridRowId, React.RefObject<HTMLButtonElement>>): {
+    field: string;
+    headerName: string;
+    sortable: boolean;
+    filterable: boolean;
+    width: number;
+    renderCell: (params: any) => import("react/jsx-runtime").JSX.Element;
+};

package/dist/datagrid/main/archbase-grid-popover.d.ts

@@ -0,0 +1,37 @@
+import React from 'react';
+import { GridRowId } from '@mui/x-data-grid';
+/**
+ * Componente para renderizar o painel de detalhes como popover quando não há espaço suficiente
+ */
+export declare function ArchbaseDetailPopover<T extends object = any>({ rowId, rowData, renderDetailPanel, onClose, theme, className, style, opened, targetRef, // Referência ao elemento alvo (botão de expandir)
+width, maxHeight }: {
+    rowId: GridRowId;
+    rowData: T;
+    renderDetailPanel: (props: {
+        row: T;
+    }) => React.ReactNode;
+    onClose: (rowId: GridRowId) => void;
+    theme: any;
+    className?: string;
+    style?: React.CSSProperties;
+    opened: boolean;
+    targetRef: React.RefObject<HTMLElement>;
+    width?: number | string;
+    maxHeight?: number;
+}): import("react/jsx-runtime").JSX.Element;
+/**
+ * Componente alternativo usando HoverCard (útil quando quiser mostrar detalhes ao passar o mouse)
+ */
+export declare function ArchbaseDetailHoverCard<T extends object = any>({ rowId, rowData, renderDetailPanel, onClose, theme, className, style, targetRef, width }: {
+    rowId: GridRowId;
+    rowData: T;
+    renderDetailPanel: (props: {
+        row: T;
+    }) => React.ReactNode;
+    onClose: (rowId: GridRowId) => void;
+    theme: any;
+    className?: string;
+    style?: React.CSSProperties;
+    targetRef: React.RefObject<HTMLElement>;
+    width?: number | string;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/datagrid/main/grid-row-actions.d.ts

@@ -0,0 +1,15 @@
+export interface ArchbaseGridRowActionsProps<T extends Object> {
+    onEditRow?: (row: T) => void;
+    onRemoveRow?: (row: T) => void;
+    onViewRow?: (row: T) => void;
+    row: T;
+    variant?: string;
+    table?: any;
+    cell?: any;
+}
+export declare function ArchbaseGridRowActions<T extends Object>({ onEditRow, onRemoveRow, onViewRow, row, variant, table, cell }: ArchbaseGridRowActionsProps<T>): import("react/jsx-runtime").JSX.Element;
+export declare function createDataTableRowActions<T extends Object>(onEditRow?: (row: T) => void, onRemoveRow?: (row: T) => void, onViewRow?: (row: T) => void, variant?: string): ({ row, table }: {
+    row: any;
+    table: any;
+}) => import("react/jsx-runtime").JSX.Element;
+export default ArchbaseGridRowActions;

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

@@ -0,0 +1,21 @@
+export * from './archbase-data-grid';
+export * from './archbase-data-grid-types';
+export * from './archbase-data-grid-column';
+export * from './archbase-data-grid-toolbar';
+export * from './archbase-data-grid-pagination';
+export * from './archbase-detail-panel-component';
+export * from './archbase-expand-button';
+export * from './archbase-grid-popover';
+export * from './grid-row-actions';
+export * from './archbase-data-grid-formatters';
+export * from './archbase-data-grid-utils';
+export { default as ArchbaseDataGrid } from './archbase-data-grid';
+export { ArchbaseDataGridColumn, Columns, GridToolBarActions } from './archbase-data-grid-types';
+export { ArchbaseDataGridToolbar } from './archbase-data-grid-toolbar';
+export { ArchbaseDataGridPagination } from './archbase-data-grid-pagination';
+export { ArchbaseDetailPanel, ArchbaseDetailModal, ArchbaseDetailDrawer } from './archbase-detail-panel-component';
+export { ArchbaseExpandButton, createExpandColumn } from './archbase-expand-button';
+export { ArchbaseDetailPopover, ArchbaseDetailHoverCard } from './archbase-grid-popover';
+export { ArchbaseGridRowActions, createDataTableRowActions } from './grid-row-actions';
+export { renderText, renderInteger, renderCurrency, renderFloat, renderPercent, renderBoolean, renderDate, renderDateTime, renderTime, renderEnum, renderUUID, getRendererByDataType, getAlignmentByDataType } from './archbase-data-grid-formatters';
+export { safeGetRowId, buildGlobalFilterExpression, buildFilterExpression, getRgbValues, getInitialSortModel } from './archbase-data-grid-utils';

package/dist/datagrid/modals/export-data.d.ts

@@ -0,0 +1,13 @@
+export type ExportFormat = 'csv' | 'excel' | 'pdf';
+export interface ExportConfig {
+    format: ExportFormat;
+    filename?: string;
+    includeHeaders?: boolean;
+    delimiter?: string;
+    encoding?: string;
+    sheetName?: string;
+    selectedColumns?: string[];
+    dateFormat?: string;
+    numberFormat?: string;
+}
+export declare function exportData(data: any[], columns: any[], config: ExportConfig): Promise<void>;

package/dist/datagrid/modals/export-modal.d.ts

@@ -0,0 +1,9 @@
+import { ExportConfig } from './export-data';
+export interface ExportModalProps {
+    opened: boolean;
+    onClose: () => void;
+    onExport: (config: ExportConfig) => void;
+    columns: any[];
+    defaultConfig?: Partial<ExportConfig>;
+}
+export declare function ExportModal({ opened, onClose, onExport, columns, defaultConfig }: ExportModalProps): import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,6 @@
+export { ExportModal } from './export-modal';
+export { PrintModal } from './print-modal';
+export { exportData } from './export-data';
+export { printData } from './print-data';
+export * from './export-data';
+export * from './print-data';

package/dist/datagrid/modals/print-data.d.ts

@@ -0,0 +1,16 @@
+import 'jspdf-autotable';
+export interface PrintConfig {
+    title?: string;
+    subtitle?: string;
+    orientation?: 'portrait' | 'landscape';
+    pageSize?: 'A4' | 'A3' | 'Letter';
+    showHeader?: boolean;
+    showFooter?: boolean;
+    headerText?: string;
+    footerText?: string;
+    showPageNumbers?: boolean;
+    showDate?: boolean;
+    logo?: string;
+    selectedColumns?: string[];
+}
+export declare function printData<T>(data: T[], columns: any[], config: PrintConfig): void;