@archbase/components 3.0.25 → 4.0.1

package/dist/buttons/ArchbaseSpeedDial.d.ts

@@ -0,0 +1,59 @@
+import { default as React, ReactNode } from 'react';
+import { MantineColor, MantineSize, MantineRadius } from '@mantine/core';
+export interface ArchbaseSpeedDialAction {
+    /** ID único da ação */
+    id: string;
+    /** Ícone da ação */
+    icon: ReactNode;
+    /** Label da ação (tooltip) */
+    label: string;
+    /** Callback ao clicar */
+    onClick: () => void;
+    /** Cor da ação */
+    color?: MantineColor;
+    /** Se está desabilitado */
+    disabled?: boolean;
+    /** Se deve mostrar label junto ao botão */
+    showLabel?: boolean;
+}
+export interface ArchbaseSpeedDialProps {
+    /** Ações do speed dial */
+    actions: ArchbaseSpeedDialAction[];
+    /** Ícone quando fechado */
+    icon?: ReactNode;
+    /** Ícone quando aberto */
+    openIcon?: ReactNode;
+    /** Cor do botão principal */
+    color?: MantineColor;
+    /** Tamanho dos botões */
+    size?: MantineSize;
+    /** Raio das bordas */
+    radius?: MantineRadius;
+    /** Direção de expansão */
+    direction?: 'up' | 'down' | 'left' | 'right';
+    /** Se está aberto (controlado) */
+    opened?: boolean;
+    /** Callback ao abrir/fechar */
+    onOpenChange?: (opened: boolean) => void;
+    /** Se deve fechar ao clicar em uma ação */
+    closeOnActionClick?: boolean;
+    /** Posição no layout */
+    position?: 'top-left' | 'top-right' | 'bottom-left' | 'bottom-right';
+    /** Se está fixo na tela */
+    fixed?: boolean;
+    /** Espaçamento da borda quando fixo */
+    offset?: number;
+    /** Espaçamento entre ações */
+    gap?: number;
+    /** Variante do botão */
+    variant?: 'filled' | 'light' | 'outline' | 'subtle' | 'default';
+    /** Se deve mostrar backdrop */
+    withBackdrop?: boolean;
+    /** Callback ao clicar no backdrop */
+    onBackdropClick?: () => void;
+    /** Classe CSS */
+    className?: string;
+    /** Estilo */
+    style?: React.CSSProperties;
+}
+export declare const ArchbaseSpeedDial: React.ForwardRefExoticComponent<ArchbaseSpeedDialProps & React.RefAttributes<HTMLDivElement>>;

package/dist/buttons/index.d.ts

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

package/dist/charts/ArchbaseArcGauge.d.ts

@@ -0,0 +1,55 @@
+import { default as React } from 'react';
+import { MantineColor, MantineSize } from '@mantine/core';
+export interface ArchbaseArcGaugeSegment {
+    /** Valor final do segmento (percentual 0-100) */
+    value: number;
+    /** Cor do segmento */
+    color: MantineColor;
+    /** Label opcional */
+    label?: string;
+}
+export interface ArchbaseArcGaugeProps {
+    /** Valor atual (0-100 ou dentro de min-max) */
+    value: number;
+    /** Valor mínimo */
+    min?: number;
+    /** Valor máximo */
+    max?: number;
+    /** Segmentos coloridos do gauge */
+    segments?: ArchbaseArcGaugeSegment[];
+    /** Cor padrão do arco */
+    color?: MantineColor;
+    /** Cor do fundo do arco */
+    backgroundColor?: MantineColor;
+    /** Cor do ponteiro */
+    needleColor?: MantineColor;
+    /** Ângulo de início (graus, 0 = direita) */
+    startAngle?: number;
+    /** Ângulo de fim (graus) */
+    endAngle?: number;
+    /** Tamanho do componente */
+    size?: number;
+    /** Espessura do arco */
+    thickness?: number;
+    /** Se deve mostrar o valor */
+    showValue?: boolean;
+    /** Formato do valor */
+    valueFormat?: (value: number) => string;
+    /** Sufixo do valor */
+    valueSuffix?: string;
+    /** Label inferior */
+    label?: string;
+    /** Tamanho do label */
+    labelSize?: MantineSize;
+    /** Se deve mostrar marcadores */
+    showTicks?: boolean;
+    /** Número de marcadores */
+    tickCount?: number;
+    /** Se deve mostrar labels nos marcadores */
+    showTickLabels?: boolean;
+    /** Classe CSS */
+    className?: string;
+    /** Estilo */
+    style?: React.CSSProperties;
+}
+export declare const ArchbaseArcGauge: React.ForwardRefExoticComponent<ArchbaseArcGaugeProps & React.RefAttributes<HTMLDivElement>>;

package/dist/charts/ArchbaseGantt.d.ts

@@ -0,0 +1,70 @@
+import { default as React } from 'react';
+import { Task, ViewMode } from 'gantt-task-react';
+import { IArchbaseDataSourceBase } from '@archbase/data';
+export { ViewMode } from 'gantt-task-react';
+export type { Task } from 'gantt-task-react';
+export interface ArchbaseGanttProps<T = any, ID = any> {
+    /** DataSource que fornece a coleção de tarefas */
+    dataSource?: IArchbaseDataSourceBase<T>;
+    /** Campo que mapeia o id da tarefa */
+    idField?: string;
+    /** Campo que mapeia o nome da tarefa */
+    nameField?: string;
+    /** Campo que mapeia a data de início */
+    startDateField?: string;
+    /** Campo que mapeia a data de término */
+    endDateField?: string;
+    /** Campo que mapeia o progresso (0-100) */
+    progressField?: string;
+    /** Campo que mapeia dependências (array de IDs) */
+    dependenciesField?: string;
+    /** Campo que mapeia o tipo ('task' | 'milestone' | 'project') */
+    typeField?: string;
+    /** Campo que mapeia o ID do registro pai */
+    parentIdField?: string;
+    /** Tarefas standalone (quando não se usa dataSource) */
+    tasks?: Task[];
+    /** Modo de visualização do gantt */
+    viewMode?: ViewMode;
+    /** Locale para formatação de datas */
+    locale?: string;
+    /** Largura das células da lista de tarefas */
+    listCellWidth?: string;
+    /** Largura de cada coluna do gantt */
+    columnWidth?: number;
+    /** Altura de cada linha */
+    rowHeight?: number;
+    /** Percentual de preenchimento da barra */
+    barFill?: number;
+    /** Exibe a lista de tarefas à esquerda */
+    showTaskList?: boolean;
+    /** Callback quando uma tarefa é alterada (data arrastada) */
+    onTaskChange?: (task: T) => void;
+    /** Callback quando uma tarefa é deletada */
+    onTaskDelete?: (task: T) => void;
+    /** Callback quando o progresso de uma tarefa é alterado */
+    onProgressChange?: (task: T, progress: number) => void;
+    /** Callback ao dar duplo clique em uma tarefa */
+    onDoubleClick?: (task: T) => void;
+    /** Callback ao clicar em uma tarefa */
+    onClick?: (task: T) => void;
+    /** Callback ao selecionar/deselecionar uma tarefa */
+    onSelect?: (task: T, isSelected: boolean) => void;
+    /** Label do componente (usado com Input.Wrapper) */
+    label?: React.ReactNode;
+    /** Descrição do componente (usado com Input.Wrapper) */
+    description?: React.ReactNode;
+    /** Somente leitura — desabilita edição por drag */
+    readOnly?: boolean;
+    /** Estilo inline do container */
+    style?: React.CSSProperties;
+    /** Classe CSS do container */
+    className?: string;
+    /** Largura do container */
+    width?: string | number;
+    /** Altura do container */
+    height?: string | number;
+}
+export declare const ArchbaseGantt: <T = any, ID = any>(props: ArchbaseGanttProps<T, ID> & {
+    ref?: React.Ref<HTMLDivElement>;
+}) => React.ReactElement | null;

package/dist/charts/ArchbaseLinearGauge.d.ts

@@ -0,0 +1,55 @@
+import { default as React } from 'react';
+import { MantineColor, MantineSize } from '@mantine/core';
+export interface ArchbaseLinearGaugeZone {
+    /** Valor inicial da zona */
+    from: number;
+    /** Valor final da zona */
+    to: number;
+    /** Cor da zona */
+    color: MantineColor;
+    /** Label opcional */
+    label?: string;
+}
+export interface ArchbaseLinearGaugeProps {
+    /** Valor atual */
+    value: number;
+    /** Valor mínimo */
+    min?: number;
+    /** Valor máximo */
+    max?: number;
+    /** Orientação */
+    orientation?: 'horizontal' | 'vertical';
+    /** Zonas coloridas */
+    zones?: ArchbaseLinearGaugeZone[];
+    /** Cor padrão da barra */
+    color?: MantineColor;
+    /** Cor do fundo */
+    backgroundColor?: MantineColor;
+    /** Cor do indicador */
+    indicatorColor?: MantineColor;
+    /** Largura (horizontal) ou altura (vertical) */
+    size?: number;
+    /** Espessura da barra */
+    thickness?: number;
+    /** Se deve mostrar o valor */
+    showValue?: boolean;
+    /** Formato do valor */
+    valueFormat?: (value: number) => string;
+    /** Sufixo do valor */
+    valueSuffix?: string;
+    /** Label */
+    label?: string;
+    /** Tamanho do label */
+    labelSize?: MantineSize;
+    /** Se deve mostrar ticks */
+    showTicks?: boolean;
+    /** Número de ticks */
+    tickCount?: number;
+    /** Se deve mostrar labels nos ticks */
+    showTickLabels?: boolean;
+    /** Classe CSS */
+    className?: string;
+    /** Estilo */
+    style?: React.CSSProperties;
+}
+export declare const ArchbaseLinearGauge: React.ForwardRefExoticComponent<ArchbaseLinearGaugeProps & React.RefAttributes<HTMLDivElement>>;

package/dist/charts/ArchbaseResourceTimeline.d.ts

@@ -0,0 +1,61 @@
+import { IArchbaseDataSourceBase } from '@archbase/data';
+export type ArchbaseResourceTimelineViewMode = 'day' | 'week' | 'month' | 'quarter';
+export interface ArchbaseResourceTimelineProps<TResource, TEvent, ID = any> {
+    /** DataSource for resources (groups/rows). */
+    resourceDataSource?: IArchbaseDataSourceBase<TResource>;
+    /** Field that holds the resource id. */
+    resourceIdField?: string;
+    /** Field that holds the resource display label. */
+    resourceLabelField?: string;
+    /** DataSource for events (items). */
+    eventDataSource?: IArchbaseDataSourceBase<TEvent>;
+    /** Field that holds the event start date. */
+    eventStartField?: string;
+    /** Field that holds the event end date. */
+    eventEndField?: string;
+    /** Field that links the event to a resource. */
+    eventResourceIdField?: string;
+    /** Field that holds the event display label. */
+    eventLabelField?: string;
+    /** Optional field that holds a CSS color for the event. */
+    eventColorField?: string;
+    /** Standalone resource array (used when no resourceDataSource). */
+    resources?: TResource[];
+    /** Standalone event array (used when no eventDataSource). */
+    events?: TEvent[];
+    /** Visible range start. */
+    startDate?: Date;
+    /** Visible range end. */
+    endDate?: Date;
+    /** Zoom / time-axis granularity preset. */
+    viewMode?: ArchbaseResourceTimelineViewMode;
+    /** Allow drag & resize of events. */
+    editable?: boolean;
+    /** Fired when the user clicks an event. */
+    onEventClick?: (event: TEvent) => void;
+    /** Fired after an event is moved (drag). */
+    onEventMove?: (event: TEvent, newStart: Date, newEnd: Date, newResourceId: any) => void;
+    /** Fired after an event is resized. */
+    onEventResize?: (event: TEvent, newStart: Date, newEnd: Date) => void;
+    /** Fired when the user clicks on an empty slot. */
+    onSlotClick?: (resourceId: any, date: Date) => void;
+    /** Fired when a new event range is selected via drag on an empty area. */
+    onCreateEvent?: (resourceId: any, start: Date, end: Date) => void;
+    /** Input.Wrapper label. */
+    label?: string;
+    /** Input.Wrapper description. */
+    description?: string;
+    /** Height of the timeline container. */
+    height?: string | number;
+    /** Custom inline style for the outer wrapper. */
+    style?: React.CSSProperties;
+    /** Custom CSS class for the outer wrapper. */
+    className?: string;
+    /** Width of the outer wrapper. */
+    width?: string | number;
+}
+declare function ArchbaseResourceTimeline<TResource, TEvent, ID = any>({ resourceDataSource, resourceIdField, resourceLabelField, eventDataSource, eventStartField, eventEndField, eventResourceIdField, eventLabelField, eventColorField, resources: resourcesProp, events: eventsProp, startDate, endDate, viewMode, editable, onEventClick, onEventMove, onEventResize, onSlotClick, onCreateEvent, label, description, height, style, className, width, }: ArchbaseResourceTimelineProps<TResource, TEvent, ID>): import("react/jsx-runtime").JSX.Element;
+declare namespace ArchbaseResourceTimeline {
+    var displayName: string;
+}
+export { ArchbaseResourceTimeline };

package/dist/charts/ArchbaseSparkline.d.ts

@@ -0,0 +1,45 @@
+import { default as React } from 'react';
+import { SparklineProps } from '@mantine/charts';
+import { MantineSize, MantineColor } from '@mantine/core';
+export type SparklineTrendDirection = 'up' | 'down' | 'neutral';
+export interface ArchbaseSparklineProps extends Omit<SparklineProps, 'data' | 'trendColors'> {
+    /** Dados do sparkline (array de números) */
+    data: number[];
+    /** Cor do sparkline */
+    color?: MantineColor;
+    /** Cor de preenchimento (para área) */
+    fillColor?: MantineColor;
+    /** Opacidade do preenchimento */
+    fillOpacity?: number;
+    /** Tipo de curva */
+    curveType?: 'linear' | 'natural' | 'monotone' | 'step' | 'stepBefore' | 'stepAfter';
+    /** Largura da linha */
+    strokeWidth?: number;
+    /** Se deve mostrar o indicador de tendência */
+    showTrend?: boolean;
+    /** Se deve colorir automaticamente baseado na tendência */
+    autoTrendColors?: boolean;
+    /** Cor para tendência positiva */
+    trendUpColor?: MantineColor;
+    /** Cor para tendência negativa */
+    trendDownColor?: MantineColor;
+    /** Cor para tendência neutra */
+    trendNeutralColor?: MantineColor;
+    /** Se deve mostrar o valor atual */
+    showValue?: boolean;
+    /** Formato do valor */
+    valueFormat?: (value: number) => string;
+    /** Label opcional */
+    label?: string;
+    /** Tamanho do label */
+    labelSize?: MantineSize;
+    /** Altura do sparkline */
+    height?: number;
+    /** Largura do sparkline */
+    width?: number | string;
+    /** Classe CSS */
+    className?: string;
+    /** Estilo */
+    style?: React.CSSProperties;
+}
+export declare const ArchbaseSparkline: React.ForwardRefExoticComponent<Omit<ArchbaseSparklineProps, "ref"> & React.RefAttributes<HTMLDivElement>>;

package/dist/charts/index.d.ts

@@ -1,3 +1,13 @@
 export { ArchbaseTimeline } from './ArchbaseTimeline';
 export type { ArchbaseTimelineItem, ArchbaseTimelineProps } from './ArchbaseTimeline';
+export { ArchbaseGantt, ViewMode } from './ArchbaseGantt';
+export type { ArchbaseGanttProps, Task as GanttTask } from './ArchbaseGantt';
+export { ArchbaseResourceTimeline } from './ArchbaseResourceTimeline';
+export type { ArchbaseResourceTimelineProps, ArchbaseResourceTimelineViewMode } from './ArchbaseResourceTimeline';
 export * from './vis-timeline';
+export { ArchbaseSparkline } from './ArchbaseSparkline';
+export type { ArchbaseSparklineProps, SparklineTrendDirection } from './ArchbaseSparkline';
+export { ArchbaseArcGauge } from './ArchbaseArcGauge';
+export type { ArchbaseArcGaugeProps, ArchbaseArcGaugeSegment } from './ArchbaseArcGauge';
+export { ArchbaseLinearGauge } from './ArchbaseLinearGauge';
+export type { ArchbaseLinearGaugeProps, ArchbaseLinearGaugeZone } from './ArchbaseLinearGauge';

package/dist/containers/ArchbaseExpansionPanel.d.ts

@@ -0,0 +1,60 @@
+import { ReactNode } from 'react';
+import { AccordionProps } from '@mantine/core';
+export interface ArchbaseExpansionPanelItem {
+    /** ID único do painel */
+    id: string;
+    /** Título do painel */
+    title: string;
+    /** Descrição opcional */
+    description?: string;
+    /** Ícone opcional */
+    icon?: ReactNode;
+    /** Badge opcional */
+    badge?: string | number;
+    /** Cor do badge */
+    badgeColor?: string;
+    /** Conteúdo do painel */
+    content: ReactNode;
+    /** Se o painel está desabilitado */
+    disabled?: boolean;
+}
+export interface ArchbaseExpansionPanelProps extends Omit<AccordionProps<true>, 'children' | 'multiple' | 'value' | 'defaultValue' | 'onChange'> {
+    /** Array de painéis */
+    panels: ArchbaseExpansionPanelItem[];
+    /** Permitir múltiplos painéis abertos */
+    multiple?: boolean;
+    /** Valor padrão (IDs dos painéis abertos) */
+    defaultValue?: string | string[];
+    /** Valor controlado */
+    value?: string | string[] | null;
+    /** Callback ao mudar */
+    onChange?: (value: string | string[] | null) => void;
+    /** Variante visual */
+    variant?: 'default' | 'contained' | 'filled' | 'separated';
+    /** Tamanho do chevron */
+    chevronSize?: number;
+    /** Posição do chevron */
+    chevronPosition?: 'left' | 'right';
+    /** Duração da transição em ms */
+    transitionDuration?: number;
+    /** Desabilitar todos os painéis */
+    disabled?: boolean;
+}
+export declare function ArchbaseExpansionPanel({ panels, multiple, defaultValue, value, onChange, variant, chevronSize, chevronPosition, transitionDuration, disabled, ...mantineProps }: ArchbaseExpansionPanelProps): import("react/jsx-runtime").JSX.Element;
+export interface ArchbaseExpansionPanelControlledProps extends Omit<ArchbaseExpansionPanelProps, 'value' | 'onChange' | 'defaultValue'> {
+    /** IDs dos painéis abertos */
+    openPanels: string[];
+    /** Callback ao abrir/fechar painéis */
+    onOpenPanelsChange: (panels: string[]) => void;
+}
+export declare function ArchbaseExpansionPanelControlled({ openPanels, onOpenPanelsChange, ...props }: ArchbaseExpansionPanelControlledProps): import("react/jsx-runtime").JSX.Element;
+export interface ArchbaseExpansionPanelSingleProps extends Omit<ArchbaseExpansionPanelProps, 'multiple' | 'value' | 'onChange' | 'defaultValue'> {
+    /** ID do painel aberto */
+    openPanel?: string | null;
+    /** Callback ao abrir/fechar */
+    onOpenPanelChange?: (panel: string | null) => void;
+    /** Painel aberto por padrão */
+    defaultOpenPanel?: string;
+}
+export declare function ArchbaseExpansionPanelSingle({ openPanel, onOpenPanelChange, defaultOpenPanel, ...props }: ArchbaseExpansionPanelSingleProps): import("react/jsx-runtime").JSX.Element;
+export default ArchbaseExpansionPanel;

package/dist/containers/ArchbaseFloatingPanel.d.ts

@@ -0,0 +1,91 @@
+import { ReactNode } from 'react';
+export interface ArchbaseFloatingPanelProps {
+    /** ID único do painel */
+    id?: string;
+    /** Conteúdo do painel */
+    children: ReactNode;
+    /** Título do painel */
+    title?: string;
+    /** Ícone do título */
+    icon?: ReactNode;
+    /** Largura inicial */
+    width?: number;
+    /** Altura inicial */
+    height?: number;
+    /** Posição X inicial */
+    initialX?: number;
+    /** Posição Y inicial */
+    initialY?: number;
+    /** Se pode redimensionar */
+    resizable?: boolean;
+    /** Se pode minimizar */
+    minimizable?: boolean;
+    /** Se pode maximizar */
+    maximizable?: boolean;
+    /** Se pode fechar */
+    closable?: boolean;
+    /** Callback ao fechar */
+    onClose?: () => void;
+    /** Callback ao minimizar */
+    onMinimize?: () => void;
+    /** Callback ao maximizar */
+    onMaximize?: () => void;
+    /** Callback ao restaurar */
+    onRestore?: () => void;
+    /** Callback ao mover */
+    onMove?: (x: number, y: number) => void;
+    /** Callback ao redimensionar */
+    onResize?: (width: number, height: number) => void;
+    /** Cor do header */
+    headerColor?: string;
+    /** Se o painel está inicialmente visível */
+    defaultVisible?: boolean;
+    /** Z-index */
+    zIndex?: number;
+    /** Tamanho mínimo */
+    minWidth?: number;
+    minHeight?: number;
+    /** Tamanho máximo */
+    maxWidth?: number;
+    maxHeight?: number;
+}
+export interface ArchbaseFloatingPanelState {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    minimized: boolean;
+    maximized: boolean;
+    visible: boolean;
+    zIndex: number;
+}
+export declare function ArchbaseFloatingPanel({ id, children, title, icon, width: initialWidth, height: initialHeight, initialX, initialY, resizable, minimizable, maximizable, closable, onClose, onMinimize, onMaximize, onRestore, onMove, onResize, headerColor, defaultVisible, zIndex: initialZIndex, minWidth, minHeight, maxWidth, maxHeight, }: ArchbaseFloatingPanelProps): import("react/jsx-runtime").JSX.Element;
+export interface UseArchbaseFloatingPanelOptions {
+    /** ID do painel */
+    id?: string;
+    /** Título */
+    title?: string;
+    /** Largura inicial */
+    width?: number;
+    /** Altura inicial */
+    height?: number;
+    /** Posição inicial */
+    initialPosition?: {
+        x: number;
+        y: number;
+    };
+}
+export interface UseArchbaseFloatingPanelReturn {
+    /** Se o painel está visível */
+    isOpen: boolean;
+    /** Abrir o painel */
+    open: () => void;
+    /** Fechar o painel */
+    close: () => void;
+    /** Toggle visibilidade */
+    toggle: () => void;
+    /** Props para o painel */
+    panelProps: Partial<ArchbaseFloatingPanelProps>;
+}
+export declare function useArchbaseFloatingPanel(options?: UseArchbaseFloatingPanelOptions): UseArchbaseFloatingPanelReturn;
+export default ArchbaseFloatingPanel;

package/dist/containers/index.d.ts

@@ -0,0 +1,4 @@
+export { ArchbaseExpansionPanel, ArchbaseExpansionPanelControlled, ArchbaseExpansionPanelSingle } from './ArchbaseExpansionPanel';
+export type { ArchbaseExpansionPanelProps, ArchbaseExpansionPanelItem, ArchbaseExpansionPanelControlledProps, ArchbaseExpansionPanelSingleProps, } from './ArchbaseExpansionPanel';
+export { ArchbaseFloatingPanel, useArchbaseFloatingPanel } from './ArchbaseFloatingPanel';
+export type { ArchbaseFloatingPanelProps, ArchbaseFloatingPanelState, UseArchbaseFloatingPanelOptions, UseArchbaseFloatingPanelReturn, } from './ArchbaseFloatingPanel';

package/dist/datagrid/export/ArchbaseDataGridExcelExport.d.ts

@@ -0,0 +1,67 @@
+import { default as React } from 'react';
+import { MantineSize, MantineColor } from '@mantine/core';
+export interface ExcelExportColumn {
+    /** Campo/key do dado */
+    field: string;
+    /** Label do cabeçalho */
+    header: string;
+    /** Largura da coluna em caracteres */
+    width?: number;
+    /** Formatador de valor */
+    formatter?: (value: any, row: any) => string | number;
+    /** Se a coluna deve ser incluída na exportação */
+    visible?: boolean;
+}
+export interface ArchbaseDataGridExcelExportProps<T = any> {
+    /** Dados a serem exportados */
+    data: T[];
+    /** Colunas a serem exportadas */
+    columns: ExcelExportColumn[];
+    /** Nome do arquivo (sem extensão) */
+    filename?: string;
+    /** Nome da planilha */
+    sheetName?: string;
+    /** Se deve incluir apenas dados filtrados (se aplicável) */
+    includeFiltered?: boolean;
+    /** Formato de data para colunas de data */
+    dateFormat?: string;
+    /** Formato de número para colunas numéricas */
+    numberFormat?: string;
+    /** Se deve incluir cabeçalhos */
+    includeHeaders?: boolean;
+    /** Callback antes da exportação */
+    onBeforeExport?: (data: T[]) => T[] | Promise<T[]>;
+    /** Callback após exportação bem sucedida */
+    onExportSuccess?: () => void;
+    /** Callback em caso de erro */
+    onExportError?: (error: Error) => void;
+    /** Variante do botão */
+    variant?: 'button' | 'icon';
+    /** Label do botão */
+    label?: string;
+    /** Tamanho do botão */
+    size?: MantineSize;
+    /** Cor do botão */
+    color?: MantineColor;
+    /** Se o botão está desabilitado */
+    disabled?: boolean;
+    /** Tooltip */
+    tooltip?: string;
+    /** Classe CSS */
+    className?: string;
+    /** Estilo */
+    style?: React.CSSProperties;
+}
+export declare function ArchbaseDataGridExcelExport<T = any>({ data, columns, filename, sheetName, includeFiltered, dateFormat, numberFormat, includeHeaders, onBeforeExport, onExportSuccess, onExportError, variant, label, size, color, disabled, tooltip, className, style, }: ArchbaseDataGridExcelExportProps<T>): import("react/jsx-runtime").JSX.Element;
+export declare namespace ArchbaseDataGridExcelExport {
+    var displayName: string;
+}
+export declare function useArchbaseExcelExport<T = any>(): {
+    exportToExcel: (data: T[], columns: ExcelExportColumn[], options?: {
+        filename?: string;
+        sheetName?: string;
+        includeHeaders?: boolean;
+    }) => Promise<boolean>;
+    isExporting: boolean;
+    error: Error;
+};

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

@@ -0,0 +1,2 @@
+export { ArchbaseDataGridExcelExport, useArchbaseExcelExport, } from './ArchbaseDataGridExcelExport';
+export type { ArchbaseDataGridExcelExportProps, ExcelExportColumn, } from './ArchbaseDataGridExcelExport';

package/dist/datagrid/index.d.ts

@@ -4,3 +4,4 @@ export * from './hooks';
 export * from './utils';
 export * from './modals';
 export * from './types';
+export * from './export';