@archbase/components 3.0.25 → 4.0.1

package/dist/display/ArchbaseTooltipRich.d.ts

@@ -0,0 +1,82 @@
+import { default as React, ReactNode } from 'react';
+import { HoverCardProps, MantineSize, MantineColor, MantineRadius } from '@mantine/core';
+export interface ArchbaseTooltipRichProps {
+    /** Elemento alvo (trigger) */
+    children: ReactNode;
+    /** Título do tooltip */
+    title: string;
+    /** Descrição */
+    description?: string;
+    /** URL da imagem */
+    image?: string;
+    /** Alt da imagem */
+    imageAlt?: string;
+    /** Altura da imagem */
+    imageHeight?: number;
+    /** Link "saiba mais" */
+    link?: string;
+    /** Label do link */
+    linkLabel?: string;
+    /** Se o link abre em nova aba */
+    linkExternal?: boolean;
+    /** Conteúdo customizado adicional */
+    footer?: ReactNode;
+    /** Largura do tooltip */
+    width?: number;
+    /** Delay para abrir */
+    openDelay?: number;
+    /** Delay para fechar */
+    closeDelay?: number;
+    /** Posição */
+    position?: HoverCardProps['position'];
+    /** Se deve ter seta */
+    withArrow?: boolean;
+    /** Tamanho da seta */
+    arrowSize?: number;
+    /** Raio das bordas */
+    radius?: MantineRadius;
+    /** Sombra */
+    shadow?: MantineSize;
+    /** Cor do título */
+    titleColor?: MantineColor;
+    /** Tamanho do título */
+    titleSize?: MantineSize;
+    /** Se está desabilitado */
+    disabled?: boolean;
+    /** Classe CSS */
+    className?: string;
+    /** Estilo */
+    style?: React.CSSProperties;
+}
+export declare const ArchbaseTooltipRich: React.ForwardRefExoticComponent<ArchbaseTooltipRichProps & React.RefAttributes<HTMLDivElement>>;
+export interface ArchbaseTooltipUserProps {
+    /** Elemento alvo (trigger) */
+    children: ReactNode;
+    /** Nome do usuário */
+    name: string;
+    /** Email ou cargo */
+    subtitle?: string;
+    /** URL do avatar */
+    avatar?: string;
+    /** Status online */
+    status?: 'online' | 'offline' | 'away' | 'busy';
+    /** Bio ou descrição */
+    bio?: string;
+    /** Ações customizadas */
+    actions?: ReactNode;
+    /** Largura */
+    width?: number;
+    /** Delay para abrir */
+    openDelay?: number;
+    /** Delay para fechar */
+    closeDelay?: number;
+    /** Posição */
+    position?: HoverCardProps['position'];
+    /** Se deve ter seta */
+    withArrow?: boolean;
+    /** Classe CSS */
+    className?: string;
+    /** Estilo */
+    style?: React.CSSProperties;
+}
+export declare const ArchbaseTooltipUser: React.ForwardRefExoticComponent<ArchbaseTooltipUserProps & React.RefAttributes<HTMLDivElement>>;

package/dist/display/ArchbaseVirtualList.d.ts

@@ -0,0 +1,116 @@
+import { default as React, ReactNode } from 'react';
+import { BoxProps } from '@mantine/core';
+export interface VirtualListItem {
+    id: string | number;
+    [key: string]: any;
+}
+export interface ArchbaseVirtualListProps<T extends VirtualListItem> extends Omit<BoxProps, 'children'> {
+    /** Array de itens */
+    items: T[];
+    /** Altura de cada item em pixels */
+    itemHeight: number;
+    /** Altura do container */
+    height: number | string;
+    /** Largura do container */
+    width?: number | string;
+    /** Quantidade de itens extras para renderizar (overscan) */
+    overscan?: number;
+    /** Renderizador de item */
+    renderItem: (item: T, index: number, style: React.CSSProperties) => ReactNode;
+    /** Callback ao alcançar o final */
+    onEndReached?: () => void;
+    /** Threshold para onEndReached (em pixels) */
+    endReachedThreshold?: number;
+    /** Estado de carregamento */
+    loading?: boolean;
+    /** Componente de loading */
+    loadingComponent?: ReactNode;
+    /** Mensagem quando vazio */
+    emptyMessage?: string;
+    /** Componente quando vazio */
+    emptyComponent?: ReactNode;
+    /** Renderizar header */
+    header?: ReactNode;
+    /** Renderizar footer */
+    footer?: ReactNode;
+    /** Callback ao scrollar */
+    onScroll?: (scrollTop: number) => void;
+    /** Scroll inicial */
+    initialScrollTop?: number;
+    /** Estilo dos itens */
+    itemStyle?: React.CSSProperties;
+    /** Gap entre itens */
+    gap?: number;
+    /** Key extractor */
+    keyExtractor?: (item: T, index: number) => string | number;
+}
+export interface ArchbaseVirtualListRef {
+    scrollToIndex: (index: number, align?: 'start' | 'center' | 'end') => void;
+    scrollToTop: () => void;
+    scrollToBottom: () => void;
+    getScrollTop: () => number;
+}
+declare function ArchbaseVirtualListInner<T extends VirtualListItem>({ items, itemHeight, height, width, overscan, renderItem, onEndReached, endReachedThreshold, loading, loadingComponent, emptyMessage, emptyComponent, header, footer, onScroll, initialScrollTop, itemStyle, gap, keyExtractor, ...boxProps }: ArchbaseVirtualListProps<T>, ref: React.Ref<ArchbaseVirtualListRef>): import("react/jsx-runtime").JSX.Element;
+export declare const ArchbaseVirtualList: <T extends VirtualListItem>(props: ArchbaseVirtualListProps<T> & {
+    ref?: React.Ref<ArchbaseVirtualListRef>;
+}) => ReturnType<typeof ArchbaseVirtualListInner>;
+export interface ArchbaseVirtualGridProps<T extends VirtualListItem> extends Omit<BoxProps, 'children'> {
+    /** Array de itens */
+    items: T[];
+    /** Largura de cada item */
+    itemWidth: number;
+    /** Altura de cada item */
+    itemHeight: number;
+    /** Altura do container */
+    height: number | string;
+    /** Gap entre itens */
+    gap?: number;
+    /** Overscan de linhas */
+    overscan?: number;
+    /** Renderizador de item */
+    renderItem: (item: T, index: number, style: React.CSSProperties) => ReactNode;
+    /** Callback ao alcançar o final */
+    onEndReached?: () => void;
+    /** Threshold para onEndReached */
+    endReachedThreshold?: number;
+    /** Estado de carregamento */
+    loading?: boolean;
+    /** Mensagem quando vazio */
+    emptyMessage?: string;
+    /** Key extractor */
+    keyExtractor?: (item: T, index: number) => string | number;
+}
+export declare function ArchbaseVirtualGrid<T extends VirtualListItem>({ items, itemWidth, itemHeight, height, gap, overscan, renderItem, onEndReached, endReachedThreshold, loading, emptyMessage, keyExtractor, ...boxProps }: ArchbaseVirtualGridProps<T>): import("react/jsx-runtime").JSX.Element;
+export interface ArchbaseInfiniteListProps<T extends VirtualListItem> extends Omit<ArchbaseVirtualListProps<T>, 'onEndReached'> {
+    /** Função para carregar mais itens */
+    loadMore: () => Promise<void>;
+    /** Se há mais itens para carregar */
+    hasMore: boolean;
+    /** Erro ao carregar */
+    error?: string | null;
+    /** Componente de erro */
+    errorComponent?: ReactNode;
+    /** Callback para retry */
+    onRetry?: () => void;
+}
+export declare function ArchbaseInfiniteList<T extends VirtualListItem>({ loadMore, hasMore, error, errorComponent, onRetry, loading, ...props }: ArchbaseInfiniteListProps<T>): import("react/jsx-runtime").JSX.Element;
+export interface UseVirtualListOptions<T> {
+    items: T[];
+    itemHeight: number;
+    containerHeight: number;
+    overscan?: number;
+    gap?: number;
+}
+export declare function useVirtualList<T>({ items, itemHeight, containerHeight, overscan, gap, }: UseVirtualListOptions<T>): {
+    totalHeight: number;
+    visibleItems: {
+        item: T;
+        index: number;
+        style: React.CSSProperties;
+    }[];
+    handleScroll: (event: React.UIEvent<HTMLDivElement>) => void;
+    scrollToIndex: (index: number, align?: "start" | "center" | "end") => number;
+    scrollTop: number;
+    setScrollTop: React.Dispatch<React.SetStateAction<number>>;
+};
+export default ArchbaseVirtualList;

package/dist/display/index.d.ts

@@ -2,3 +2,27 @@ export { Text as ArchbaseText } from '@mantine/core';
 export { Title as ArchbaseTitle } from '@mantine/core';
 export { Image as ArchbaseMantineImage } from '@mantine/core';
 export { Badge as ArchbaseBadge } from '@mantine/core';
+export { ArchbaseQRCode } from './ArchbaseQRCode';
+export type { ArchbaseQRCodeProps, ArchbaseQRCodeImageSettings } from './ArchbaseQRCode';
+export { ArchbaseDiffViewer, DiffMethod } from './ArchbaseDiffViewer';
+export type { ArchbaseDiffViewerProps } from './ArchbaseDiffViewer';
+export { ArchbaseJsonTree } from './ArchbaseJsonTree';
+export type { ArchbaseJsonTreeProps } from './ArchbaseJsonTree';
+export { ArchbaseCodeViewer } from './ArchbaseCodeViewer';
+export type { ArchbaseCodeViewerProps, ArchbaseCodeViewerTab } from './ArchbaseCodeViewer';
+export { ArchbaseAnimationWrapper, ArchbaseAnimatedList, ArchbaseFadeInWhenVisible } from './ArchbaseAnimationWrapper';
+export type { ArchbaseAnimationWrapperProps, ArchbaseAnimatedListProps, ArchbaseFadeInWhenVisibleProps, ArchbaseAnimationPreset, } from './ArchbaseAnimationWrapper';
+export { ArchbaseBarcodeGenerator, ArchbaseEAN13Generator, ArchbaseEAN8Generator, ArchbaseUPCGenerator, ArchbaseCODE128Generator, } from './ArchbaseBarcodeGenerator';
+export type { ArchbaseBarcodeGeneratorProps, BarcodeFormat, } from './ArchbaseBarcodeGenerator';
+export { ArchbaseTooltipRich, ArchbaseTooltipUser } from './ArchbaseTooltipRich';
+export type { ArchbaseTooltipRichProps, ArchbaseTooltipUserProps } from './ArchbaseTooltipRich';
+export { ArchbaseMarquee, ArchbaseMarqueeLeft, ArchbaseMarqueeRight, ArchbaseMarqueeUp, ArchbaseMarqueeDown, ArchbaseTextTicker, } from './ArchbaseMarquee';
+export type { ArchbaseMarqueeProps, MarqueeDirection, ArchbaseTextTickerProps } from './ArchbaseMarquee';
+export { ArchbaseCarousel, ArchbaseCarouselSlide, ArchbaseImageCarousel, ArchbaseCardCarousel, useArchbaseCarousel, } from './ArchbaseCarousel';
+export type { ArchbaseCarouselProps, ArchbaseCarouselSlideProps, ArchbaseImageCarouselProps, ImageSlide, ArchbaseCardCarouselProps, UseArchbaseCarouselOptions, } from './ArchbaseCarousel';
+export { ArchbaseVirtualList, ArchbaseVirtualGrid, ArchbaseInfiniteList, useVirtualList, } from './ArchbaseVirtualList';
+export type { ArchbaseVirtualListProps, ArchbaseVirtualListRef, VirtualListItem, ArchbaseVirtualGridProps, ArchbaseInfiniteListProps, UseVirtualListOptions, } from './ArchbaseVirtualList';
+export { ArchbaseLightbox, ArchbaseLightboxProvider, useArchbaseLightbox, useArchbaseLightboxContext, } from './ArchbaseLightbox';
+export type { ArchbaseLightboxProps, ArchbaseLightboxSlide, ArchbaseLightboxProviderProps, UseArchbaseLightboxReturn, } from './ArchbaseLightbox';
+export { ArchbasePhotoAlbum } from './ArchbasePhotoAlbum';
+export type { ArchbasePhotoAlbumProps, ArchbasePhotoAlbumPhoto, ArchbasePhotoAlbumLayout, } from './ArchbasePhotoAlbum';

package/dist/editors/ArchbaseAIPromptInput.d.ts

@@ -0,0 +1,69 @@
+import { default as React, ReactNode } from 'react';
+import { TextareaProps, MantineColor, MantineSize } from '@mantine/core';
+export interface ArchbaseAIPromptSuggestion {
+    /** ID único */
+    id: string;
+    /** Texto da sugestão */
+    text: string;
+    /** Ícone opcional */
+    icon?: ReactNode;
+    /** Categoria */
+    category?: string;
+}
+export interface ArchbaseAIPromptInputProps extends Omit<TextareaProps, 'onSubmit'> {
+    /** Callback ao enviar (Enter) */
+    onSubmit?: (value: string) => void | Promise<void>;
+    /** Se está carregando/processando */
+    loading?: boolean;
+    /** Placeholder */
+    placeholder?: string;
+    /** Sugestões rápidas */
+    suggestions?: ArchbaseAIPromptSuggestion[];
+    /** Se deve mostrar sugestões */
+    showSuggestions?: boolean;
+    /** Histórico de prompts */
+    history?: string[];
+    /** Se deve habilitar navegação no histórico */
+    enableHistory?: boolean;
+    /** Máximo de caracteres */
+    maxLength?: number;
+    /** Se deve mostrar contador */
+    showCounter?: boolean;
+    /** Se deve habilitar voice input */
+    enableVoice?: boolean;
+    /** Callback de voice input */
+    onVoiceInput?: (transcript: string) => void;
+    /** Cor do botão enviar */
+    submitColor?: MantineColor;
+    /** Ícone do botão enviar */
+    submitIcon?: ReactNode;
+    /** Tamanho */
+    size?: MantineSize;
+    /** Mínimo de linhas */
+    minRows?: number;
+    /** Máximo de linhas */
+    maxRows?: number;
+    /** Se deve auto-expandir */
+    autosize?: boolean;
+    /** Se está desabilitado */
+    disabled?: boolean;
+    /** Classe CSS */
+    className?: string;
+    /** Estilo */
+    style?: React.CSSProperties;
+}
+export declare const ArchbaseAIPromptInput: React.ForwardRefExoticComponent<Omit<ArchbaseAIPromptInputProps, "ref"> & React.RefAttributes<HTMLTextAreaElement>>;
+export interface UseArchbasePromptHistoryOptions {
+    maxHistory?: number;
+    storageKey?: string;
+}
+export interface UseArchbasePromptHistoryReturn {
+    history: string[];
+    addToHistory: (prompt: string) => void;
+    clearHistory: () => void;
+    currentIndex: number;
+    navigateUp: () => string | null;
+    navigateDown: () => string | null;
+    resetNavigation: () => void;
+}
+export declare function useArchbasePromptHistory(options?: UseArchbasePromptHistoryOptions): UseArchbasePromptHistoryReturn;

package/dist/editors/ArchbaseAsyncMultiSelect.d.ts

@@ -109,4 +109,4 @@ export declare const SelectedItem: ({ item, value, onRemove, label }: {
     label: any;
 }) => import("react/jsx-runtime").JSX.Element;
 export declare function ArchbaseAsyncMultiSelect<T, ID, O>({ allowDeselect, clearable, dataSource, dataField, disabled, debounceTime, minCharsToSearch, readOnly, placeholder, initialOptions, searchable, label, description, error, icon, iconWidth, required, getOptionLabel, getOptionValue, getOptionImage, getOptions, onFocusEnter, onFocusExit, onChangeValues, value, defaultValue, filter, size, style, width, initiallyOpened, itemComponent: ItemComponent, selectedItemComponent: SelectedItemComponent, onDropdownOpen, onDropdownClose, limit, nothingFound, zIndex, dropdownPosition, onErrorLoadOptions, onSearchChange, converter, getConvertedOption }: ArchbaseAsyncMultiSelectProps<T, ID, O>): import("react/jsx-runtime").JSX.Element;
-export declare const CustomSelectScrollArea: React.ForwardRefExoticComponent<ScrollAreaProps & React.RefAttributes<HTMLDivElement>>;
+export declare const CustomSelectScrollArea: React.ForwardRefExoticComponent<Omit<ScrollAreaProps, "ref"> & React.RefAttributes<HTMLDivElement>>;

package/dist/editors/ArchbaseAsyncSelect.d.ts

@@ -95,4 +95,4 @@ export interface ArchbaseAsyncSelectProps<T, ID, O> {
     getConvertedOption?: (value: any) => Promise<O>;
 }
 export declare function ArchbaseAsyncSelect<T, ID, O>({ allowDeselect, clearable, dataSource, dataField, disabled, debounceTime, minCharsToSearch, readOnly, placeholder, initialOptions, searchable, label, description, error, icon, iconWidth, required, getOptionLabel, getOptionValue, getOptionImage, getOptions, onFocusEnter, onFocusExit, onSelectValue, value, defaultValue, filter, size, style, width, initiallyOpened, itemComponent: ItemComponent, onDropdownOpen, onDropdownClose, limit, nothingFound, zIndex, dropdownPosition, onErrorLoadOptions, innerRef, onSearchChange, converter, getConvertedOption }: ArchbaseAsyncSelectProps<T, ID, O>): import("react/jsx-runtime").JSX.Element;
-export declare const CustomSelectScrollArea: React.ForwardRefExoticComponent<ScrollAreaProps & React.RefAttributes<HTMLDivElement>>;
+export declare const CustomSelectScrollArea: React.ForwardRefExoticComponent<Omit<ScrollAreaProps, "ref"> & React.RefAttributes<HTMLDivElement>>;

package/dist/editors/ArchbaseBarcodeScanner.d.ts

@@ -0,0 +1,63 @@
+import { CSSProperties, ReactNode } from 'react';
+import { IArchbaseDataSourceBase } from '@archbase/data';
+declare global {
+    interface Window {
+        BarcodeDetector: any;
+    }
+}
+export interface ArchbaseBarcodeScannerProps<T, ID> {
+    /** Fonte de dados onde sera atribuido o valor do scanner (V1 ou V2) */
+    dataSource?: IArchbaseDataSourceBase<T>;
+    /** Campo onde devera ser atribuido o valor do scanner na fonte de dados */
+    dataField?: string;
+    /** Valor controlado (uso standalone) */
+    value?: 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 o scanner esta desabilitado */
+    disabled?: boolean;
+    /** Indicador se e somente leitura */
+    readOnly?: boolean;
+    /** Continuar escaneando apos primeira leitura (default false) */
+    continuous?: boolean;
+    /** Formatos de codigo aceitos */
+    formats?: string[];
+    /** Intervalo entre tentativas de deteccao em ms (default 500) */
+    scanInterval?: number;
+    /** Callback quando um codigo e escaneado */
+    onScan?: (code: string, format: string) => void;
+    /** Callback quando ocorre um erro */
+    onError?: (error: Error) => void;
+    /** Largura do video (default 320) */
+    width?: number;
+    /** Altura do video (default 240) */
+    height?: number;
+    /** Mostrar botao de lanterna (default false) */
+    showTorchButton?: boolean;
+    /** Renderizar como botao que abre modal (default false) */
+    asModal?: boolean;
+    /** Titulo do modal (default 'Escanear codigo') */
+    modalTitle?: string;
+    /** Label do botao (default 'Escanear') */
+    buttonLabel?: string;
+    /** Icone do botao */
+    buttonIcon?: ReactNode;
+    /** Overlay customizado sobre o video */
+    overlay?: ReactNode;
+    /** Estilo do componente */
+    style?: CSSProperties;
+    /** Classe CSS */
+    className?: string;
+    /** Evento quando o valor e alterado */
+    onChangeValue?: (value: string) => void;
+}
+export declare function ArchbaseBarcodeScanner<T, ID>(props: ArchbaseBarcodeScannerProps<T, ID>): import("react/jsx-runtime").JSX.Element;
+export declare namespace ArchbaseBarcodeScanner {
+    var displayName: string;
+}

package/dist/editors/ArchbaseCepInput.d.ts

@@ -0,0 +1,26 @@
+import { TextInputProps } from '@mantine/core';
+export interface CepAddress {
+    cep: string;
+    state: string;
+    city: string;
+    neighborhood: string;
+    street: string;
+    service?: string;
+}
+export interface ArchbaseCepInputProps extends Omit<TextInputProps, 'value' | 'onChange' | 'onError'> {
+    /** Valor atual */
+    value?: string;
+    /** Callback ao mudar */
+    onChange?: (value: string) => void;
+    /** Callback ao encontrar endereço */
+    onAddressFound?: (address: CepAddress) => void;
+    /** Callback em caso de erro */
+    onCepError?: (error: Error) => void;
+    /** Auto-buscar ao completar CEP */
+    autoFetch?: boolean;
+    /** Mostrar ícone de status */
+    showStatusIcon?: boolean;
+}
+export declare function formatCep(cep: string): string;
+export declare function ArchbaseCepInput({ value, onChange, onAddressFound, onCepError, autoFetch, showStatusIcon, ...props }: ArchbaseCepInputProps): import("react/jsx-runtime").JSX.Element;
+export default ArchbaseCepInput;

package/dist/editors/ArchbaseColorGradientPicker.d.ts

@@ -0,0 +1,80 @@
+import { default as React } from 'react';
+import { ColorPickerProps, MantineSize } from '@mantine/core';
+import { ArchbaseDataSource } from '@archbase/data';
+export type ArchbaseColorFormat = 'hex' | 'hexa' | 'rgb' | 'rgba' | 'hsl' | 'hsla';
+export interface ArchbaseColorGradientPickerProps extends Omit<ColorPickerProps, 'value' | 'onChange'> {
+    /** Fonte de dados */
+    dataSource?: ArchbaseDataSource<any, any>;
+    /** Campo do DataSource */
+    dataField?: string;
+    /** Valor controlado */
+    value?: string;
+    /** Valor padrão */
+    defaultValue?: string;
+    /** Callback de mudança */
+    onChange?: (value: string) => void;
+    /** Formato do valor */
+    format?: ArchbaseColorFormat;
+    /** Swatches de cores */
+    swatches?: string[];
+    /** Se deve mostrar swatches */
+    showSwatches?: boolean;
+    /** Se deve mostrar hue slider */
+    showHueSlider?: boolean;
+    /** Se deve mostrar alpha slider */
+    showAlphaSlider?: boolean;
+    /** Se deve mostrar input de texto */
+    showInput?: boolean;
+    /** Se deve mostrar eyedropper (quando suportado) */
+    showEyeDropper?: boolean;
+    /** Label */
+    label?: string;
+    /** Descrição */
+    description?: string;
+    /** Erro */
+    error?: string | boolean;
+    /** Tamanho */
+    size?: MantineSize;
+    /** Se está desabilitado */
+    disabled?: boolean;
+    /** Se é somente leitura */
+    readOnly?: boolean;
+    /** Largura */
+    width?: number | string;
+    /** Se deve usar popover */
+    withPopover?: boolean;
+    /** Classe CSS */
+    className?: string;
+    /** Estilo */
+    style?: React.CSSProperties;
+}
+export declare const ArchbaseColorGradientPicker: React.ForwardRefExoticComponent<Omit<ArchbaseColorGradientPickerProps, "ref"> & React.RefAttributes<HTMLDivElement>>;
+export interface ArchbaseFlatColorPickerProps {
+    /** Fonte de dados */
+    dataSource?: ArchbaseDataSource<any, any>;
+    /** Campo do DataSource */
+    dataField?: string;
+    /** Valor controlado */
+    value?: string;
+    /** Valor padrão */
+    defaultValue?: string;
+    /** Callback de mudança */
+    onChange?: (value: string) => void;
+    /** Swatches de cores */
+    swatches?: string[];
+    /** Número de colunas */
+    columns?: number;
+    /** Tamanho do swatch */
+    swatchSize?: number;
+    /** Espaçamento entre swatches */
+    spacing?: number;
+    /** Label */
+    label?: string;
+    /** Se está desabilitado */
+    disabled?: boolean;
+    /** Classe CSS */
+    className?: string;
+    /** Estilo */
+    style?: React.CSSProperties;
+}
+export declare const ArchbaseFlatColorPicker: React.ForwardRefExoticComponent<ArchbaseFlatColorPickerProps & React.RefAttributes<HTMLDivElement>>;

package/dist/editors/ArchbaseCpfCnpjInput.d.ts

@@ -0,0 +1,21 @@
+import { TextInputProps } from '@mantine/core';
+export declare function validateCPF(cpf: string): boolean;
+export declare function validateCNPJ(cnpj: string): boolean;
+export declare function formatCPF(cpf: string): string;
+export declare function formatCNPJ(cnpj: string): string;
+export type DocumentType = 'cpf' | 'cnpj' | 'unknown';
+export declare function detectDocumentType(value: string): DocumentType;
+export interface ArchbaseCpfCnpjInputProps extends Omit<TextInputProps, 'value' | 'onChange'> {
+    /** Valor atual */
+    value?: string;
+    /** Callback ao mudar */
+    onChange?: (value: string) => void;
+    /** Tipo de documento (auto-detecta se não informado) */
+    documentType?: 'cpf' | 'cnpj' | 'auto';
+    /** Mostrar ícone de validação */
+    showValidationIcon?: boolean;
+    /** Callback ao validar */
+    onValidate?: (isValid: boolean, type: DocumentType) => void;
+}
+export declare function ArchbaseCpfCnpjInput({ value, onChange, documentType, showValidationIcon, onValidate, ...props }: ArchbaseCpfCnpjInputProps): import("react/jsx-runtime").JSX.Element;
+export default ArchbaseCpfCnpjInput;

package/dist/editors/ArchbaseCurrencyInput.d.ts

@@ -0,0 +1,25 @@
+import { NumberInputProps } from '@mantine/core';
+export type CurrencyCode = 'BRL' | 'USD' | 'EUR' | 'GBP' | 'JPY' | 'CNY' | 'ARS' | 'CLP' | 'COP' | 'MXN';
+export interface CurrencyConfig {
+    prefix: string;
+    thousandSeparator: string;
+    decimalSeparator: string;
+    decimalScale: number;
+}
+export interface ArchbaseCurrencyInputProps extends Omit<NumberInputProps, 'value' | 'onChange'> {
+    /** Moeda */
+    currency?: CurrencyCode;
+    /** Valor atual */
+    value?: number | null;
+    /** Callback ao mudar */
+    onChange?: (value: number | null) => void;
+    /** Permitir valores negativos */
+    allowNegative?: boolean;
+    /** Mostrar símbolo da moeda */
+    showSymbol?: boolean;
+}
+export declare function ArchbaseCurrencyInput({ currency, value, onChange, allowNegative, showSymbol, ...props }: ArchbaseCurrencyInputProps): import("react/jsx-runtime").JSX.Element;
+export declare function ArchbaseBRLInput(props: Omit<ArchbaseCurrencyInputProps, 'currency'>): import("react/jsx-runtime").JSX.Element;
+export declare function ArchbaseUSDInput(props: Omit<ArchbaseCurrencyInputProps, 'currency'>): import("react/jsx-runtime").JSX.Element;
+export declare function ArchbaseEURInput(props: Omit<ArchbaseCurrencyInputProps, 'currency'>): import("react/jsx-runtime").JSX.Element;
+export default ArchbaseCurrencyInput;

package/dist/editors/ArchbaseDualListbox.d.ts

@@ -0,0 +1,61 @@
+import { MantineSize } from '@mantine/core';
+import { default as React, CSSProperties } from 'react';
+import { IArchbaseDataSourceBase } from '@archbase/data';
+export interface ArchbaseDualListboxOption {
+    value: any;
+    label: string;
+    group?: string;
+    disabled?: boolean;
+}
+export interface ArchbaseDualListboxProps<T, ID, O> {
+    /** 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 de entrada controlado */
+    value?: any[];
+    /** Valor padrao de entrada nao controlado */
+    defaultValue?: any[];
+    /** Opcoes disponiveis para selecao */
+    options: ArchbaseDualListboxOption[];
+    /** Titulo do componente */
+    label?: string;
+    /** Descricao do componente */
+    description?: string;
+    /** Ultimo erro ocorrido */
+    error?: string;
+    /** Indicador se o campo e obrigatorio */
+    required?: boolean;
+    /** Indicador se o componente esta desabilitado */
+    disabled?: boolean;
+    /** Indicador se o componente e somente leitura */
+    readOnly?: boolean;
+    /** Titulo da lista de itens disponiveis */
+    availableLabel?: string;
+    /** Titulo da lista de itens selecionados */
+    selectedLabel?: string;
+    /** Exibir campo de busca em cada lista */
+    showSearch?: boolean;
+    /** Exibir botoes para mover todos os itens */
+    showMoveAll?: boolean;
+    /** Altura das listas */
+    height?: number;
+    /** Evento quando o valor muda */
+    onChangeValue?: (value: any[]) => void;
+    /** Evento quando o componente recebe o foco */
+    onFocusEnter?: (event: React.FocusEvent) => void;
+    /** Evento quando o foco sai do componente */
+    onFocusExit?: (event: React.FocusEvent) => void;
+    /** Estilo do componente */
+    style?: CSSProperties;
+    /** Classe CSS do componente */
+    className?: string;
+    /** Largura do componente */
+    width?: string | number;
+    /** Tamanho do componente */
+    size?: MantineSize;
+}
+export declare function ArchbaseDualListbox<T, ID, O>({ dataSource, dataField, value, defaultValue, options, label, description, error, required, disabled, readOnly, availableLabel, selectedLabel, showSearch, showMoveAll, height, onChangeValue, onFocusEnter, onFocusExit, style, className, width, size, }: ArchbaseDualListboxProps<T, ID, O>): import("react/jsx-runtime").JSX.Element;
+export declare namespace ArchbaseDualListbox {
+    var displayName: string;
+}

package/dist/editors/ArchbaseInPlaceEditor.d.ts

@@ -0,0 +1,67 @@
+export type InPlaceEditorType = 'text' | 'number' | 'select' | 'textarea' | 'date';
+export interface SelectOption {
+    value: string;
+    label: string;
+}
+export interface ArchbaseInPlaceEditorProps {
+    /** Valor atual */
+    value: any;
+    /** Callback ao salvar */
+    onSave: (value: any) => void | Promise<void>;
+    /** Callback ao cancelar */
+    onCancel?: () => void;
+    /** Tipo do editor */
+    type?: InPlaceEditorType;
+    /** Opções para select */
+    options?: SelectOption[];
+    /** Formatador para exibição */
+    formatter?: (value: any) => string;
+    /** Validador */
+    validate?: (value: any) => boolean | string;
+    /** Placeholder do input */
+    placeholder?: string;
+    /** Texto quando vazio */
+    emptyText?: string;
+    /** Desabilitado */
+    disabled?: boolean;
+    /** Salvar ao perder foco */
+    saveOnBlur?: boolean;
+    /** Mostrar botões de ação */
+    showActions?: boolean;
+    /** Mostrar ícone de edição no hover */
+    showEditIcon?: boolean;
+    /** Tamanho do texto */
+    textSize?: 'xs' | 'sm' | 'md' | 'lg' | 'xl';
+    /** Peso do texto */
+    textWeight?: number;
+    /** Cor do texto */
+    textColor?: string;
+    /** Número de linhas para textarea */
+    textareaRows?: number;
+    /** Props do NumberInput */
+    numberProps?: {
+        min?: number;
+        max?: number;
+        step?: number;
+        decimalScale?: number;
+        prefix?: string;
+        suffix?: string;
+    };
+    /** Props do DateInput */
+    dateProps?: {
+        locale?: string;
+        valueFormat?: string;
+        minDate?: Date;
+        maxDate?: Date;
+    };
+}
+export declare function ArchbaseInPlaceEditor({ value, onSave, onCancel, type, options, formatter, validate, placeholder, emptyText, disabled, saveOnBlur, showActions, showEditIcon, textSize, textWeight, textColor, textareaRows, numberProps, dateProps, }: ArchbaseInPlaceEditorProps): import("react/jsx-runtime").JSX.Element;
+/** Editor inline de texto */
+export declare function ArchbaseInPlaceTextEditor(props: Omit<ArchbaseInPlaceEditorProps, 'type'>): import("react/jsx-runtime").JSX.Element;
+/** Editor inline de número */
+export declare function ArchbaseInPlaceNumberEditor(props: Omit<ArchbaseInPlaceEditorProps, 'type'>): import("react/jsx-runtime").JSX.Element;
+/** Editor inline de select */
+export declare function ArchbaseInPlaceSelectEditor(props: Omit<ArchbaseInPlaceEditorProps, 'type'>): import("react/jsx-runtime").JSX.Element;
+/** Editor inline de data */
+export declare function ArchbaseInPlaceDateEditor(props: Omit<ArchbaseInPlaceEditorProps, 'type'>): import("react/jsx-runtime").JSX.Element;
+export default ArchbaseInPlaceEditor;