@archbase/components 3.0.25 → 4.0.1

package/dist/editors/ArchbaseLightGrid.d.ts

@@ -0,0 +1,56 @@
+import { IArchbaseDataSourceBase } from '@archbase/data';
+import { CSSProperties } from 'react';
+export interface ArchbaseLightGridColumn<T> {
+    /** Campo do registro (keyof T ou path com notação de ponto) */
+    field: keyof T | string;
+    /** Texto do cabeçalho */
+    header: string;
+    /** Largura da coluna em pixels */
+    width?: number;
+    /** Tipo de dado da coluna */
+    type?: 'text' | 'number' | 'date' | 'boolean' | 'currency' | 'custom';
+    /** Formato (ex.: "DD/MM/YYYY", "0,0.00", "R$ #.##0,00") */
+    format?: string;
+    /** Se a coluna e editavel */
+    editable?: boolean;
+    /** Se a coluna deve ficar fixa a esquerda */
+    frozen?: boolean;
+    /** Alinhamento do texto */
+    align?: 'left' | 'center' | 'right';
+}
+export interface ArchbaseLightGridProps<T, ID> {
+    /** Fonte de dados */
+    dataSource?: IArchbaseDataSourceBase<T>;
+    /** Definicao das colunas */
+    columns: ArchbaseLightGridColumn<T>[];
+    /** Dados standalone (usado quando nao ha dataSource) */
+    data?: T[];
+    /** Habilita edicao de celulas */
+    editable?: boolean;
+    /** Altura do grid */
+    height?: string | number;
+    /** Largura do grid */
+    width?: string | number;
+    /** Exibe numeracao de linhas */
+    showRowNumbers?: boolean;
+    /** Callback quando uma celula e alterada */
+    onCellChange?: (record: T, field: string, oldValue: any, newValue: any) => void;
+    /** Callback quando a selecao muda */
+    onSelectionChange?: (selection: {
+        row: number;
+        col: number;
+    }[]) => void;
+    /** Somente leitura (sobrescreve editable) */
+    readOnly?: boolean;
+    /** Label exibido acima do grid */
+    label?: string;
+    /** Descricao exibida abaixo do label */
+    description?: string;
+    /** Estilo CSS do container */
+    style?: CSSProperties;
+    /** Classe CSS do container */
+    className?: string;
+}
+declare function ArchbaseLightGridInner<T, ID>(props: ArchbaseLightGridProps<T, ID>): import("react/jsx-runtime").JSX.Element;
+export declare const ArchbaseLightGrid: typeof ArchbaseLightGridInner;
+export {};

package/dist/editors/ArchbaseMentionInput.d.ts

@@ -0,0 +1,75 @@
+import { MantineSize } from '@mantine/core';
+import { CSSProperties, FocusEventHandler, default as React } from 'react';
+import { IArchbaseDataSourceBase } from '@archbase/data';
+export interface ArchbaseMentionConfig {
+    /** Caractere gatilho da mention (ex: '@', '#') */
+    trigger: string;
+    /** Lista estatica ou funcao async que retorna sugestoes */
+    data: Array<{
+        id: string;
+        display: string;
+    }> | ((search: string, callback: (data: Array<{
+        id: string;
+        display: string;
+    }>) => void) => void);
+    /** Markup template. Padrao: '[__display__](__id__)' */
+    markup?: string;
+    /** Funcao para transformar exibicao */
+    displayTransform?: (id: string, display: string) => string;
+    /** Permite espacos na busca */
+    allowSpaceInQuery?: boolean;
+    /** Estilos customizados para a mention */
+    style?: React.CSSProperties;
+}
+export interface ArchbaseMentionInputProps<T, ID> {
+    /** Fonte de dados onde sera atribuido o valor (V1 ou V2) */
+    dataSource?: IArchbaseDataSourceBase<T>;
+    /** Campo onde devera ser atribuido o valor na fonte de dados */
+    dataField?: string;
+    /** Valor controlado (standalone) */
+    value?: string;
+    /** Valor padrao (standalone) */
+    defaultValue?: string;
+    /** Titulo do campo */
+    label?: string;
+    /** Descricao do campo */
+    description?: string;
+    /** Ultimo erro ocorrido */
+    error?: string;
+    /** Texto sugestao */
+    placeholder?: string;
+    /** Indicador se o preenchimento e obrigatorio */
+    required?: boolean;
+    /** Indicador se o campo esta desabilitado */
+    disabled?: boolean;
+    /** Indicador se o campo e somente leitura */
+    readOnly?: boolean;
+    /** Configuracoes de mention (triggers, data, etc.) */
+    mentions: ArchbaseMentionConfig[];
+    /** Modo linha unica */
+    singleLine?: boolean;
+    /** Permitir sugestoes acima do cursor */
+    allowSuggestionsAboveCursor?: boolean;
+    /** Evento quando o valor e alterado */
+    onChangeValue?: (value: string, event: any) => void;
+    /** Evento quando o campo recebe foco */
+    onFocusEnter?: FocusEventHandler<HTMLTextAreaElement | HTMLInputElement>;
+    /** Evento quando o foco sai do campo */
+    onFocusExit?: FocusEventHandler<HTMLTextAreaElement | HTMLInputElement>;
+    /** Referencia para o componente interno */
+    innerRef?: React.RefObject<HTMLTextAreaElement | HTMLInputElement>;
+    /** Estilos customizados */
+    style?: CSSProperties;
+    /** Classes CSS customizadas */
+    className?: string;
+    /** Largura do campo */
+    width?: string | number;
+    /** Altura do campo */
+    height?: string | number;
+    /** Tamanho do campo (Mantine) */
+    size?: MantineSize;
+}
+export declare function ArchbaseMentionInput<T, ID>({ dataSource, dataField, value: valueProp, defaultValue, label, description, error, placeholder, required, disabled, readOnly, mentions, singleLine, allowSuggestionsAboveCursor, onChangeValue, onFocusEnter, onFocusExit, innerRef, style, className, width, height, size, }: ArchbaseMentionInputProps<T, ID>): import("react/jsx-runtime").JSX.Element;
+export declare namespace ArchbaseMentionInput {
+    var displayName: string;
+}

package/dist/editors/ArchbaseMultiEmail.d.ts

@@ -0,0 +1,53 @@
+import { MantineSize } from '@mantine/core';
+import { CSSProperties, FocusEventHandler, default as React } from 'react';
+import { IArchbaseDataSourceBase } from '@archbase/data';
+export interface ArchbaseMultiEmailProps<T, ID> {
+    /** Fonte de dados onde sera atribuido o valor (V1 ou V2) */
+    dataSource?: IArchbaseDataSourceBase<T>;
+    /** Campo onde devera ser atribuido o valor na fonte de dados */
+    dataField?: string;
+    /** Valor controlado (array de emails) */
+    value?: string[];
+    /** Valor padrao nao controlado */
+    defaultValue?: string[];
+    /** Delimitador para converter string do datasource em array (padrao ';') */
+    delimiter?: string;
+    /** Titulo do campo */
+    label?: string;
+    /** Descricao do campo */
+    description?: string;
+    /** Ultimo erro ocorrido */
+    error?: string;
+    /** Texto de sugestao */
+    placeholder?: string;
+    /** Indicador se o preenchimento e obrigatorio */
+    required?: boolean;
+    /** Indicador se o campo esta desabilitado */
+    disabled?: boolean;
+    /** Indicador se o campo e somente leitura */
+    readOnly?: boolean;
+    /** Numero maximo de emails permitidos */
+    max?: number;
+    /** Funcao customizada de validacao de email */
+    validateEmail?: (email: string) => boolean;
+    /** Evento quando o valor e alterado */
+    onChangeValue?: (emails: string[]) => void;
+    /** Evento quando o campo recebe o foco */
+    onFocusEnter?: FocusEventHandler<HTMLInputElement> | undefined;
+    /** Evento quando o foco sai do campo */
+    onFocusExit?: FocusEventHandler<HTMLInputElement> | undefined;
+    /** Referencia para o componente interno */
+    innerRef?: React.RefObject<HTMLDivElement> | undefined;
+    /** Estilo do componente */
+    style?: CSSProperties;
+    /** Classe CSS */
+    className?: string;
+    /** Largura do componente */
+    width?: string | number;
+    /** Tamanho do componente */
+    size?: MantineSize;
+}
+export declare function ArchbaseMultiEmail<T, ID>({ dataSource, dataField, value, defaultValue, delimiter, label, description, error, placeholder, required, disabled, readOnly, max, validateEmail, onChangeValue, onFocusEnter, onFocusExit, innerRef, style, className, width, size, }: ArchbaseMultiEmailProps<T, ID>): import("react/jsx-runtime").JSX.Element;
+export declare namespace ArchbaseMultiEmail {
+    var displayName: string;
+}

package/dist/editors/ArchbaseMultiViewCalendar.d.ts

@@ -0,0 +1,47 @@
+import { DatePickerInputProps, DatesRangeValue } from '@mantine/dates';
+export interface DateRangePreset {
+    /** Identificador único */
+    id: string;
+    /** Label exibido */
+    label: string;
+    /** Função que retorna o range */
+    getValue: () => [Date, Date];
+}
+export interface ArchbaseMultiViewCalendarProps extends Omit<DatePickerInputProps<'range'>, 'value' | 'onChange' | 'type' | 'numberOfColumns' | 'presets'> {
+    /** Valor atual [startDate, endDate] */
+    value?: DatesRangeValue;
+    /** Callback ao mudar */
+    onChange?: (value: DatesRangeValue) => void;
+    /** Número de colunas (meses visíveis) */
+    numberOfColumns?: number;
+    /** Presets de data rápidos */
+    presets?: DateRangePreset[];
+    /** Mostrar presets */
+    showPresets?: boolean;
+    /** Locale (padrão: pt-BR) */
+    locale?: string;
+    /** Formato de exibição */
+    valueFormat?: string;
+}
+export declare const defaultDatePresets: DateRangePreset[];
+export declare function ArchbaseMultiViewCalendar({ value, onChange, numberOfColumns, presets, showPresets, locale, valueFormat, ...props }: ArchbaseMultiViewCalendarProps): import("react/jsx-runtime").JSX.Element;
+export interface ArchbaseMultiViewCalendarWithPresetsProps extends Omit<ArchbaseMultiViewCalendarProps, 'showPresets'> {
+    /** Presets de data rápidos */
+    presets?: DateRangePreset[];
+    /** Label para seção de presets */
+    presetsLabel?: string;
+}
+export declare function ArchbaseMultiViewCalendarWithPresets({ value, onChange, numberOfColumns, presets, presetsLabel, locale, valueFormat, ...props }: ArchbaseMultiViewCalendarWithPresetsProps): import("react/jsx-runtime").JSX.Element;
+export interface ArchbaseDateRangeQuickPickerProps {
+    /** Valor atual [startDate, endDate] */
+    value?: DatesRangeValue;
+    /** Callback ao mudar */
+    onChange?: (value: DatesRangeValue) => void;
+    /** Presets disponíveis */
+    presets?: DateRangePreset[];
+    /** Colunas de presets */
+    columns?: number;
+}
+export declare function ArchbaseDateRangeQuickPicker({ value, onChange, presets, columns, }: ArchbaseDateRangeQuickPickerProps): import("react/jsx-runtime").JSX.Element;
+export declare function createDatePreset(id: string, label: string, getValue: () => [Date, Date]): DateRangePreset;
+export default ArchbaseMultiViewCalendar;

package/dist/editors/ArchbaseNumberStepper.d.ts

@@ -0,0 +1,66 @@
+import { default as React } from 'react';
+import { NumberInputProps, MantineSize } from '@mantine/core';
+import { ArchbaseDataSource } from '@archbase/data';
+export interface ArchbaseNumberStepperProps<T extends object, ID> extends Omit<NumberInputProps, 'value' | 'onChange'> {
+    /** Fonte de dados */
+    dataSource?: ArchbaseDataSource<T, ID>;
+    /** Campo do DataSource */
+    dataField?: string;
+    /** Valor controlado */
+    value?: number | string;
+    /** Valor padrão */
+    defaultValue?: number | string;
+    /** Callback de mudança */
+    onChange?: (value: number | string) => void;
+    /** Valor mínimo */
+    min?: number;
+    /** Valor máximo */
+    max?: number;
+    /** Passo de incremento */
+    step?: number;
+    /** Número de casas decimais */
+    decimalScale?: number;
+    /** Se deve fixar casas decimais */
+    fixedDecimalScale?: boolean;
+    /** Separador de milhar */
+    thousandSeparator?: string | boolean;
+    /** Separador decimal */
+    decimalSeparator?: string;
+    /** Prefixo */
+    prefix?: string;
+    /** Sufixo */
+    suffix?: string;
+    /** Comportamento ao atingir limite */
+    clampBehavior?: 'strict' | 'blur' | 'none';
+    /** Se permite valores negativos */
+    allowNegative?: boolean;
+    /** Se permite entrada decimal */
+    allowDecimal?: boolean;
+    /** Se deve esconder controles */
+    hideControls?: boolean;
+    /** Tamanho */
+    size?: MantineSize;
+    /** Se está desabilitado */
+    disabled?: boolean;
+    /** Se é somente leitura */
+    readOnly?: boolean;
+    /** Label */
+    label?: string;
+    /** Descrição */
+    description?: string;
+    /** Erro */
+    error?: string | boolean;
+    /** Se é obrigatório */
+    required?: boolean;
+    /** Placeholder */
+    placeholder?: string;
+    /** Largura */
+    width?: number | string;
+    /** Classe CSS */
+    className?: string;
+    /** Estilo */
+    style?: React.CSSProperties;
+}
+export declare const ArchbaseNumberStepper: <T extends object = any, ID = string>(props: ArchbaseNumberStepperProps<T, ID> & {
+    ref?: React.Ref<HTMLInputElement>;
+}) => React.ReactElement;

package/dist/editors/ArchbaseOTPInput.d.ts

@@ -0,0 +1,27 @@
+import { PinInputProps } from '@mantine/core';
+export interface ArchbaseOTPInputProps extends Omit<PinInputProps, 'value' | 'onChange' | 'error'> {
+    /** Número de dígitos (padrão: 6) */
+    length?: number;
+    /** Valor atual */
+    value?: string;
+    /** Callback ao mudar */
+    onChange?: (value: string) => void;
+    /** Callback ao completar */
+    onComplete?: (value: string) => void;
+    /** Mostrar botão de reenviar */
+    showResend?: boolean;
+    /** Callback ao reenviar */
+    onResend?: () => void;
+    /** Tempo de espera para reenviar (segundos) */
+    resendCooldown?: number;
+    /** Texto do botão reenviar */
+    resendText?: string;
+    /** Erro */
+    errorMessage?: string;
+    /** Máscara */
+    mask?: boolean;
+}
+export declare function ArchbaseOTPInput({ length, value, onChange, onComplete, showResend, onResend, resendCooldown, resendText, errorMessage, mask, ...props }: ArchbaseOTPInputProps): import("react/jsx-runtime").JSX.Element;
+export declare function ArchbaseOTP4Input(props: Omit<ArchbaseOTPInputProps, 'length'>): import("react/jsx-runtime").JSX.Element;
+export declare function ArchbaseOTP6Input(props: Omit<ArchbaseOTPInputProps, 'length'>): import("react/jsx-runtime").JSX.Element;
+export default ArchbaseOTPInput;

package/dist/editors/ArchbasePhoneInput.d.ts

@@ -0,0 +1,52 @@
+import { MantineSize } from '@mantine/core';
+import { CSSProperties, FocusEventHandler, default as React } from 'react';
+import { IArchbaseDataSourceBase } from '@archbase/data';
+import { CountryCode } from 'libphonenumber-js';
+export interface ArchbasePhoneInputProps<T, ID> {
+    /** Fonte de dados onde será atribuído o valor do phone input (V1 ou V2) */
+    dataSource?: IArchbaseDataSourceBase<T>;
+    /** Campo onde deverá ser atribuído o valor do phone input na fonte de dados */
+    dataField?: string;
+    /** Valor controlado do phone input (modo standalone) */
+    value?: string;
+    /** Valor padrão do phone input (modo standalone) */
+    defaultValue?: string;
+    /** País padrão selecionado no seletor de bandeiras */
+    defaultCountry?: CountryCode;
+    /** Se true, exibe o número em formato internacional (+55 ...) */
+    international?: boolean;
+    /** Título/label do phone input */
+    label?: string;
+    /** Descrição exibida abaixo do label */
+    description?: string;
+    /** Mensagem de erro a ser exibida */
+    error?: string;
+    /** Texto de placeholder do phone input */
+    placeholder?: string;
+    /** Indicador se o preenchimento é obrigatório */
+    required?: boolean;
+    /** Indicador se o phone input está desabilitado */
+    disabled?: boolean;
+    /** Indicador se o phone input é somente leitura. Obs: usado em conjunto com o status da fonte de dados */
+    readOnly?: boolean;
+    /** Evento quando o valor do phone input é alterado */
+    onChangeValue?: (value: string | undefined) => void;
+    /** Evento quando o phone input recebe o foco */
+    onFocusEnter?: FocusEventHandler<HTMLInputElement> | undefined;
+    /** Evento quando o foco sai do phone input */
+    onFocusExit?: FocusEventHandler<HTMLInputElement> | undefined;
+    /** Referência para o componente interno */
+    innerRef?: React.RefObject<HTMLInputElement> | undefined;
+    /** Estilo CSS customizado aplicado ao wrapper */
+    style?: CSSProperties;
+    /** Classe CSS customizada aplicada ao wrapper */
+    className?: string;
+    /** Largura do componente */
+    width?: string | number;
+    /** Tamanho do componente seguindo o padrão Mantine */
+    size?: MantineSize;
+}
+export declare function ArchbasePhoneInput<T, ID>({ dataSource, dataField, value: valueProp, defaultValue, defaultCountry, international, label, description, error, placeholder, required, disabled, readOnly, onChangeValue, onFocusEnter, onFocusExit, innerRef, style, className, width, size, }: ArchbasePhoneInputProps<T, ID>): import("react/jsx-runtime").JSX.Element;
+export declare namespace ArchbasePhoneInput {
+    var displayName: string;
+}

package/dist/editors/ArchbaseRangeSlider.d.ts

@@ -0,0 +1,22 @@
+import { RangeSliderProps } from '@mantine/core';
+export type RangeValue = [number, number];
+export interface ArchbaseRangeSliderProps extends Omit<RangeSliderProps, 'value' | 'onChange'> {
+    /** Valor atual [min, max] */
+    value?: RangeValue;
+    /** Callback ao mudar */
+    onChange?: (value: RangeValue) => void;
+    /** Callback ao soltar o slider */
+    onChangeEnd?: (value: RangeValue) => void;
+    /** Mostrar valores */
+    showValues?: boolean;
+    /** Formatador de valores */
+    formatValue?: (value: number) => string;
+    /** Prefixo dos valores */
+    valuePrefix?: string;
+    /** Sufixo dos valores */
+    valueSuffix?: string;
+}
+export declare function ArchbaseRangeSlider({ value, onChange, onChangeEnd, showValues, formatValue, valuePrefix, valueSuffix, min, max, ...props }: ArchbaseRangeSliderProps): import("react/jsx-runtime").JSX.Element;
+export declare function ArchbasePriceRangeSlider(props: Omit<ArchbaseRangeSliderProps, 'valuePrefix'>): import("react/jsx-runtime").JSX.Element;
+export declare function ArchbasePercentRangeSlider(props: Omit<ArchbaseRangeSliderProps, 'valueSuffix' | 'min' | 'max'>): import("react/jsx-runtime").JSX.Element;
+export default ArchbaseRangeSlider;

package/dist/editors/ArchbaseSignaturePad.d.ts

@@ -0,0 +1,60 @@
+import { default as React, CSSProperties } from 'react';
+import { MantineSize } from '@mantine/core';
+import { IArchbaseDataSourceBase } from '@archbase/data';
+export interface ArchbaseSignaturePadProps<T, ID> {
+    /** Fonte de dados onde sera atribuido o valor da assinatura (V1 ou V2) */
+    dataSource?: IArchbaseDataSourceBase<T>;
+    /** Campo onde devera ser atribuido o valor da assinatura na fonte de dados */
+    dataField?: string;
+    /** Valor controlado (base64 data URL) */
+    value?: string;
+    /** Valor padrao (base64 data URL) */
+    defaultValue?: string;
+    /** Titulo do campo */
+    label?: string;
+    /** Descricao do campo */
+    description?: string;
+    /** Ultimo erro ocorrido */
+    error?: string;
+    /** Indicador se o preenchimento e obrigatorio */
+    required?: boolean;
+    /** Indicador se esta desabilitado */
+    disabled?: boolean;
+    /** Indicador se e somente leitura */
+    readOnly?: boolean;
+    /** Cor da caneta */
+    penColor?: string;
+    /** Cor de fundo do canvas */
+    backgroundColor?: string;
+    /** Largura do canvas */
+    width?: number;
+    /** Altura do canvas */
+    height?: number;
+    /** Exibir botao limpar */
+    showClearButton?: boolean;
+    /** Exibir botao confirmar */
+    showConfirmButton?: boolean;
+    /** Texto do botao limpar */
+    clearLabel?: string;
+    /** Texto do botao confirmar */
+    confirmLabel?: string;
+    /** Evento quando o valor muda (retorna base64 data URL) */
+    onChangeValue?: (value: string | undefined) => void;
+    /** Evento quando o foco entra */
+    onFocusEnter?: React.FocusEventHandler<any>;
+    /** Evento quando o foco sai */
+    onFocusExit?: React.FocusEventHandler<any>;
+    /** Evento quando o usuario confirma a assinatura */
+    onConfirm?: (value: string | undefined) => void;
+    /** Estilo do componente */
+    style?: CSSProperties;
+    /** Classe CSS */
+    className?: string;
+    /** Formato da imagem gerada */
+    imageFormat?: 'png' | 'jpeg' | 'svg';
+    /** Tamanho do componente */
+    size?: MantineSize;
+}
+declare function ArchbaseSignaturePadInner<T, ID>({ dataSource, dataField, value: valueProp, defaultValue, label, description, error, required, disabled, readOnly, penColor, backgroundColor, width, height, showClearButton, showConfirmButton, clearLabel, confirmLabel, onChangeValue, onFocusEnter, onFocusExit, onConfirm, style, className, imageFormat, size, }: ArchbaseSignaturePadProps<T, ID>): import("react/jsx-runtime").JSX.Element;
+export declare const ArchbaseSignaturePad: typeof ArchbaseSignaturePadInner;
+export {};

package/dist/editors/ArchbaseSpeechToTextInput.d.ts

@@ -0,0 +1,106 @@
+import { TextInputProps, TextareaProps } from '@mantine/core';
+interface SpeechRecognitionEvent {
+    resultIndex: number;
+    results: SpeechRecognitionResultList;
+}
+interface SpeechRecognitionErrorEvent {
+    error: string;
+    message: string;
+}
+interface SpeechRecognition extends EventTarget {
+    continuous: boolean;
+    interimResults: boolean;
+    lang: string;
+    start: () => void;
+    stop: () => void;
+    abort: () => void;
+    onresult: ((event: SpeechRecognitionEvent) => void) | null;
+    onerror: ((event: SpeechRecognitionErrorEvent) => void) | null;
+    onend: (() => void) | null;
+    onstart: (() => void) | null;
+}
+declare global {
+    interface Window {
+        SpeechRecognition: new () => SpeechRecognition;
+        webkitSpeechRecognition: new () => SpeechRecognition;
+    }
+}
+export interface UseArchbaseSpeechToTextOptions {
+    /** Idioma (padrão: pt-BR) */
+    lang?: string;
+    /** Modo contínuo */
+    continuous?: boolean;
+    /** Resultados intermediários */
+    interimResults?: boolean;
+    /** Callback ao obter transcrição */
+    onTranscript?: (transcript: string, isFinal: boolean) => void;
+    /** Callback em caso de erro */
+    onError?: (error: string) => void;
+    /** Callback ao iniciar */
+    onStart?: () => void;
+    /** Callback ao parar */
+    onEnd?: () => void;
+}
+export interface UseArchbaseSpeechToTextReturn {
+    /** Se está gravando */
+    isListening: boolean;
+    /** Transcrição atual */
+    transcript: string;
+    /** Se o browser suporta */
+    isSupported: boolean;
+    /** Último erro */
+    error: string | null;
+    /** Iniciar gravação */
+    start: () => void;
+    /** Parar gravação */
+    stop: () => void;
+    /** Limpar transcrição */
+    clear: () => void;
+}
+export declare function useArchbaseSpeechToText({ lang, continuous, interimResults, onTranscript, onError, onStart, onEnd, }?: UseArchbaseSpeechToTextOptions): UseArchbaseSpeechToTextReturn;
+export interface ArchbaseSpeechToTextButtonProps {
+    /** Callback ao obter transcrição */
+    onTranscript: (transcript: string) => void;
+    /** Idioma (padrão: pt-BR) */
+    lang?: string;
+    /** Modo contínuo */
+    continuous?: boolean;
+    /** Desabilitado */
+    disabled?: boolean;
+    /** Tamanho do botão */
+    size?: 'xs' | 'sm' | 'md' | 'lg' | 'xl';
+    /** Cor */
+    color?: string;
+    /** Tooltip quando desabilitado/não suportado */
+    unsupportedTooltip?: string;
+}
+export declare function ArchbaseSpeechToTextButton({ onTranscript, lang, continuous, disabled, size, color, unsupportedTooltip, }: ArchbaseSpeechToTextButtonProps): import("react/jsx-runtime").JSX.Element;
+export interface ArchbaseSpeechToTextInputProps extends Omit<TextInputProps, 'value' | 'onChange'> {
+    /** Valor atual */
+    value?: string;
+    /** Callback ao mudar */
+    onChange?: (value: string) => void;
+    /** Idioma (padrão: pt-BR) */
+    lang?: string;
+    /** Modo contínuo */
+    continuous?: boolean;
+    /** Substituir ou anexar transcrição */
+    mode?: 'replace' | 'append';
+    /** Mostrar indicador de gravação */
+    showRecordingIndicator?: boolean;
+}
+export declare function ArchbaseSpeechToTextInput({ value, onChange, lang, continuous, mode, showRecordingIndicator, ...props }: ArchbaseSpeechToTextInputProps): import("react/jsx-runtime").JSX.Element;
+export interface ArchbaseSpeechToTextAreaProps extends Omit<TextareaProps, 'value' | 'onChange'> {
+    /** Valor atual */
+    value?: string;
+    /** Callback ao mudar */
+    onChange?: (value: string) => void;
+    /** Idioma (padrão: pt-BR) */
+    lang?: string;
+    /** Modo contínuo */
+    continuous?: boolean;
+    /** Substituir ou anexar transcrição */
+    mode?: 'replace' | 'append';
+}
+export declare function ArchbaseSpeechToTextArea({ value, onChange, lang, continuous, mode, ...props }: ArchbaseSpeechToTextAreaProps): import("react/jsx-runtime").JSX.Element;
+export default ArchbaseSpeechToTextInput;

package/dist/editors/ArchbaseSpreadsheet.d.ts

@@ -0,0 +1,56 @@
+import { CSSProperties } from 'react';
+import { IArchbaseDataSourceBase } from '@archbase/data';
+export type ArchbaseColumnType = 'text' | 'number' | 'date' | 'boolean' | 'currency';
+export interface ArchbaseColumnDef<T> {
+    /** Campo do registro mapeado para esta coluna */
+    field: keyof T | string;
+    /** Cabeçalho exibido na planilha */
+    header: string;
+    /** Largura da coluna em pixels */
+    width?: number;
+    /** Tipo do dado */
+    type?: ArchbaseColumnType;
+    /** Formato numérico (ex: '#,##0.00') */
+    format?: string;
+    /** Se a coluna é editável */
+    editable?: boolean;
+}
+export interface ArchbaseSpreadsheetProps<T, ID> {
+    /** Fonte de dados que fornece os registros */
+    dataSource?: IArchbaseDataSourceBase<T>;
+    /** Definição de colunas para mapeamento DataSource -> planilha */
+    columns?: ArchbaseColumnDef<T>[];
+    /** Dados standalone no formato Sheet[] do fortune-sheet */
+    data?: any[];
+    /** Permite edição (default: true) */
+    editable?: boolean;
+    /** Exibe a toolbar (default: true) */
+    showToolbar?: boolean;
+    /** Exibe a barra de fórmulas (default: true) */
+    showFormulaBar?: boolean;
+    /** Exibe as abas de planilhas (default: true) */
+    showSheetTabs?: boolean;
+    /** Altura do componente */
+    height?: string | number;
+    /** Largura do componente */
+    width?: string | number;
+    /** Callback quando uma célula é alterada */
+    onCellChange?: (row: number, col: number, oldValue: any, newValue: any) => void;
+    /** Callback quando a seleção muda */
+    onSelectionChange?: (ranges: any[]) => void;
+    /** Rótulo (Input.Wrapper) */
+    label?: string;
+    /** Descrição (Input.Wrapper) */
+    description?: string;
+    /** Somente leitura */
+    readOnly?: boolean;
+    /** Locale (default: 'pt-BR') */
+    locale?: string;
+    /** Estilo adicional do container */
+    style?: CSSProperties;
+    /** Classe CSS adicional */
+    className?: string;
+}
+declare function ArchbaseSpreadsheetInner<T, ID>(props: ArchbaseSpreadsheetProps<T, ID>): import("react/jsx-runtime").JSX.Element;
+export declare const ArchbaseSpreadsheet: typeof ArchbaseSpreadsheetInner;
+export {};