@archbase/components 3.0.25 → 4.0.0

package/dist/editors/ArchbaseTagInput.d.ts

@@ -0,0 +1,55 @@
+import { MantineSize } from '@mantine/core';
+import { CSSProperties, FocusEventHandler, default as React } from 'react';
+import { IArchbaseDataSourceBase } from '@archbase/data';
+export interface ArchbaseTagInputProps<T, ID> {
+    /** Fonte de dados onde sera atribuido o valor das tags (V1 ou V2) */
+    dataSource?: IArchbaseDataSourceBase<T>;
+    /** Campo onde devera ser atribuido o valor das tags na fonte de dados */
+    dataField?: string;
+    /** Valor controlado (array de strings) quando usado sem dataSource */
+    value?: string[];
+    /** Valor padrao inicial (array de strings) */
+    defaultValue?: string[];
+    /** Delimitador usado para serializar/deserializar quando o campo no dataSource e uma string. Padrao: ',' */
+    delimiter?: string;
+    /** Titulo do campo */
+    label?: string;
+    /** Descricao do campo */
+    description?: string;
+    /** Ultimo erro ocorrido no campo */
+    error?: string;
+    /** Texto sugestao do campo */
+    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. Obs: usado em conjunto com o status da fonte de dados */
+    readOnly?: boolean;
+    /** Lista de caracteres que, ao serem digitados, criam uma nova tag. Ex: [',', ' ', 'Enter'] */
+    separators?: string[];
+    /** Numero maximo de tags permitidas */
+    maxTags?: number;
+    /** Permite tags duplicadas */
+    allowDuplicates?: boolean;
+    /** Evento quando o valor das tags e alterado */
+    onChangeValue?: (value: string[], event?: any) => void;
+    /** Evento quando o campo recebe o foco */
+    onFocusEnter?: FocusEventHandler<HTMLInputElement>;
+    /** Evento quando o foco sai do campo */
+    onFocusExit?: FocusEventHandler<HTMLInputElement>;
+    /** Referencia para o componente interno */
+    innerRef?: React.RefObject<HTMLInputElement>;
+    /** Estilo do campo */
+    style?: CSSProperties;
+    /** Classe CSS adicional */
+    className?: string;
+    /** Largura do campo */
+    width?: string | number;
+    /** Tamanho do campo (Mantine size) */
+    size?: MantineSize;
+}
+export declare function ArchbaseTagInput<T, ID>({ dataSource, dataField, value: valueProp, defaultValue, delimiter, label, description, error, placeholder, required, disabled, readOnly, separators, maxTags, allowDuplicates, onChangeValue, onFocusEnter, onFocusExit, innerRef, style, className, width, size, }: ArchbaseTagInputProps<T, ID>): import("react/jsx-runtime").JSX.Element;
+export declare namespace ArchbaseTagInput {
+    var displayName: string;
+}

package/dist/editors/index.d.ts

@@ -17,6 +17,8 @@ export type { ArchbaseChipItemProps } from './ArchbaseChipItem';
 export { ArchbaseChipItem } from './ArchbaseChipItem';
 export type { ArchbaseColorPickerProps } from './ArchbaseColorPicker';
 export { ArchbaseColorPicker } from './ArchbaseColorPicker';
+export { ArchbaseDualListbox } from './ArchbaseDualListbox';
+export type { ArchbaseDualListboxProps, ArchbaseDualListboxOption } from './ArchbaseDualListbox';
 export type { ArchbaseDatePickerRangeProps } from './ArchbaseDatePickerRange';
 export { ArchbaseDatePickerRange } from './ArchbaseDatePickerRange';
 export type { ArchbaseDateTimePickerEditProps, } from './ArchbaseDateTimePickerEdit';
@@ -79,3 +81,41 @@ export { ArchbaseTimeEdit } from './ArchbaseTimeEdit';
 export type { ArchbaseTimeEditProps } from './ArchbaseTimeEdit';
 export { ArchbaseAvatarEdit } from './ArchbaseAvatarEdit';
 export type { ArchbaseAvatarEditProps } from './ArchbaseAvatarEdit';
+export { ArchbaseTagInput } from './ArchbaseTagInput';
+export type { ArchbaseTagInputProps } from './ArchbaseTagInput';
+export { ArchbasePhoneInput } from './ArchbasePhoneInput';
+export type { ArchbasePhoneInputProps } from './ArchbasePhoneInput';
+export { ArchbaseMultiEmail } from './ArchbaseMultiEmail';
+export type { ArchbaseMultiEmailProps } from './ArchbaseMultiEmail';
+export { ArchbaseMentionInput } from './ArchbaseMentionInput';
+export type { ArchbaseMentionInputProps, ArchbaseMentionConfig } from './ArchbaseMentionInput';
+export { ArchbaseSignaturePad } from './ArchbaseSignaturePad';
+export type { ArchbaseSignaturePadProps } from './ArchbaseSignaturePad';
+export { ArchbaseBarcodeScanner } from './ArchbaseBarcodeScanner';
+export type { ArchbaseBarcodeScannerProps } from './ArchbaseBarcodeScanner';
+export { ArchbaseSpreadsheet } from './ArchbaseSpreadsheet';
+export type { ArchbaseSpreadsheetProps, ArchbaseColumnDef, ArchbaseColumnType } from './ArchbaseSpreadsheet';
+export { ArchbaseLightGrid } from './ArchbaseLightGrid';
+export type { ArchbaseLightGridProps, ArchbaseLightGridColumn } from './ArchbaseLightGrid';
+export { ArchbaseCurrencyInput } from './ArchbaseCurrencyInput';
+export type { ArchbaseCurrencyInputProps, CurrencyCode } from './ArchbaseCurrencyInput';
+export { ArchbaseCpfCnpjInput, validateCPF, validateCNPJ, formatCPF, formatCNPJ, detectDocumentType } from './ArchbaseCpfCnpjInput';
+export type { ArchbaseCpfCnpjInputProps, DocumentType } from './ArchbaseCpfCnpjInput';
+export { ArchbaseCepInput, formatCep } from './ArchbaseCepInput';
+export type { ArchbaseCepInputProps, CepAddress } from './ArchbaseCepInput';
+export { ArchbaseOTPInput } from './ArchbaseOTPInput';
+export type { ArchbaseOTPInputProps } from './ArchbaseOTPInput';
+export { ArchbaseRangeSlider } from './ArchbaseRangeSlider';
+export type { ArchbaseRangeSliderProps, RangeValue } from './ArchbaseRangeSlider';
+export { ArchbaseInPlaceEditor } from './ArchbaseInPlaceEditor';
+export type { ArchbaseInPlaceEditorProps, InPlaceEditorType, SelectOption } from './ArchbaseInPlaceEditor';
+export { ArchbaseNumberStepper } from './ArchbaseNumberStepper';
+export type { ArchbaseNumberStepperProps } from './ArchbaseNumberStepper';
+export { ArchbaseAIPromptInput, useArchbasePromptHistory } from './ArchbaseAIPromptInput';
+export type { ArchbaseAIPromptInputProps, ArchbaseAIPromptSuggestion, UseArchbasePromptHistoryOptions, UseArchbasePromptHistoryReturn, } from './ArchbaseAIPromptInput';
+export { ArchbaseColorGradientPicker, ArchbaseFlatColorPicker } from './ArchbaseColorGradientPicker';
+export type { ArchbaseColorGradientPickerProps, ArchbaseFlatColorPickerProps, ArchbaseColorFormat, } from './ArchbaseColorGradientPicker';
+export { useArchbaseSpeechToText, ArchbaseSpeechToTextButton, ArchbaseSpeechToTextInput, ArchbaseSpeechToTextArea, } from './ArchbaseSpeechToTextInput';
+export type { UseArchbaseSpeechToTextOptions, UseArchbaseSpeechToTextReturn, ArchbaseSpeechToTextButtonProps, ArchbaseSpeechToTextInputProps, ArchbaseSpeechToTextAreaProps, } from './ArchbaseSpeechToTextInput';
+export { ArchbaseMultiViewCalendar, ArchbaseMultiViewCalendarWithPresets, ArchbaseDateRangeQuickPicker, defaultDatePresets, createDatePreset, } from './ArchbaseMultiViewCalendar';
+export type { ArchbaseMultiViewCalendarProps, ArchbaseMultiViewCalendarWithPresetsProps, ArchbaseDateRangeQuickPickerProps, DateRangePreset, } from './ArchbaseMultiViewCalendar';

package/dist/feedback/ArchbaseChunkProgressBar.d.ts

@@ -0,0 +1,35 @@
+import { default as React } from 'react';
+import { MantineColor, MantineSize } from '@mantine/core';
+export interface ArchbaseChunkProgressBarProps {
+    /** Valor atual (0-100) */
+    value: number;
+    /** Quantidade de chunks */
+    chunkCount?: number;
+    /** Gap entre os chunks em pixels */
+    gap?: number;
+    /** Cor dos chunks incompletos */
+    color?: MantineColor;
+    /** Cor dos chunks completos */
+    completedColor?: MantineColor;
+    /** Se deve animar os chunks */
+    animated?: boolean;
+    /** Se deve ter listras */
+    striped?: boolean;
+    /** Tamanho da barra */
+    size?: MantineSize | number;
+    /** Raio da barra */
+    radius?: MantineSize | number;
+    /** Label opcional */
+    label?: string;
+    /** Se deve mostrar o percentual */
+    showPercentage?: boolean;
+    /** Formato do percentual */
+    percentageFormat?: (value: number) => string;
+    /** Largura */
+    width?: number | string;
+    /** Classe CSS */
+    className?: string;
+    /** Estilo */
+    style?: React.CSSProperties;
+}
+export declare const ArchbaseChunkProgressBar: React.ForwardRefExoticComponent<ArchbaseChunkProgressBarProps & React.RefAttributes<HTMLDivElement>>;

package/dist/feedback/ArchbaseRipple.d.ts

@@ -0,0 +1,43 @@
+import { default as React, ReactNode, MouseEvent, CSSProperties } from 'react';
+import { MantineColor } from '@mantine/core';
+interface RippleItem {
+    id: number;
+    x: number;
+    y: number;
+    size: number;
+}
+export interface ArchbaseRippleProps {
+    /** Conteúdo a ser envolvido */
+    children: ReactNode;
+    /** Cor do ripple */
+    color?: MantineColor;
+    /** Opacidade do ripple */
+    opacity?: number;
+    /** Duração da animação em ms */
+    duration?: number;
+    /** Se o ripple deve ser centralizado */
+    centered?: boolean;
+    /** Se está desabilitado */
+    disabled?: boolean;
+    /** Se deve cobrir todo o elemento */
+    unbounded?: boolean;
+    /** Classe CSS */
+    className?: string;
+    /** Estilo */
+    style?: CSSProperties;
+}
+export declare const ArchbaseRipple: React.ForwardRefExoticComponent<ArchbaseRippleProps & React.RefAttributes<HTMLDivElement>>;
+export interface UseArchbaseRippleOptions {
+    color?: MantineColor;
+    opacity?: number;
+    duration?: number;
+    centered?: boolean;
+    disabled?: boolean;
+}
+export interface UseArchbaseRippleReturn {
+    ripples: RippleItem[];
+    handleClick: (event: MouseEvent<HTMLElement>) => void;
+    RippleContainer: React.FC;
+}
+export declare function useArchbaseRipple(options?: UseArchbaseRippleOptions): UseArchbaseRippleReturn;
+export {};

package/dist/feedback/ArchbaseSkeleton.d.ts

@@ -0,0 +1,115 @@
+import { default as React } from 'react';
+import { MantineRadius } from '@mantine/core';
+export interface ArchbaseDataGridSkeletonProps {
+    /** Número de linhas */
+    rows?: number;
+    /** Número de colunas */
+    columns?: number;
+    /** Se deve mostrar header */
+    showHeader?: boolean;
+    /** Altura da linha */
+    rowHeight?: number;
+    /** Espaçamento entre linhas */
+    gap?: number;
+    /** Raio das bordas */
+    radius?: MantineRadius;
+    /** Se deve animar */
+    animate?: boolean;
+    /** Classe CSS */
+    className?: string;
+    /** Estilo */
+    style?: React.CSSProperties;
+}
+export declare const ArchbaseDataGridSkeleton: React.ForwardRefExoticComponent<ArchbaseDataGridSkeletonProps & React.RefAttributes<HTMLDivElement>>;
+export interface ArchbaseFormSkeletonProps {
+    /** Número de campos */
+    fields?: number;
+    /** Número de colunas do form */
+    columns?: number;
+    /** Se deve mostrar labels */
+    showLabels?: boolean;
+    /** Altura do input */
+    inputHeight?: number;
+    /** Altura do label */
+    labelHeight?: number;
+    /** Espaçamento */
+    gap?: number;
+    /** Raio das bordas */
+    radius?: MantineRadius;
+    /** Se deve animar */
+    animate?: boolean;
+    /** Se deve mostrar botões de ação */
+    showActions?: boolean;
+    /** Classe CSS */
+    className?: string;
+    /** Estilo */
+    style?: React.CSSProperties;
+}
+export declare const ArchbaseFormSkeleton: React.ForwardRefExoticComponent<ArchbaseFormSkeletonProps & React.RefAttributes<HTMLDivElement>>;
+export interface ArchbaseCardSkeletonProps {
+    /** Se deve mostrar avatar */
+    showAvatar?: boolean;
+    /** Tamanho do avatar */
+    avatarSize?: number;
+    /** Número de linhas de texto */
+    lines?: number;
+    /** Se deve mostrar imagem no topo */
+    showImage?: boolean;
+    /** Altura da imagem */
+    imageHeight?: number;
+    /** Se deve mostrar ações */
+    showActions?: boolean;
+    /** Raio das bordas */
+    radius?: MantineRadius;
+    /** Se deve animar */
+    animate?: boolean;
+    /** Classe CSS */
+    className?: string;
+    /** Estilo */
+    style?: React.CSSProperties;
+}
+export declare const ArchbaseCardSkeleton: React.ForwardRefExoticComponent<ArchbaseCardSkeletonProps & React.RefAttributes<HTMLDivElement>>;
+export interface ArchbaseKanbanSkeletonProps {
+    /** Número de colunas */
+    columns?: number;
+    /** Número de cards por coluna */
+    cardsPerColumn?: number;
+    /** Largura da coluna */
+    columnWidth?: number;
+    /** Altura do card */
+    cardHeight?: number;
+    /** Espaçamento */
+    gap?: number;
+    /** Raio das bordas */
+    radius?: MantineRadius;
+    /** Se deve animar */
+    animate?: boolean;
+    /** Classe CSS */
+    className?: string;
+    /** Estilo */
+    style?: React.CSSProperties;
+}
+export declare const ArchbaseKanbanSkeleton: React.ForwardRefExoticComponent<ArchbaseKanbanSkeletonProps & React.RefAttributes<HTMLDivElement>>;
+export interface ArchbaseListSkeletonProps {
+    /** Número de itens */
+    items?: number;
+    /** Se deve mostrar avatar */
+    showAvatar?: boolean;
+    /** Tamanho do avatar */
+    avatarSize?: number;
+    /** Se deve mostrar descrição */
+    showDescription?: boolean;
+    /** Se deve mostrar ação à direita */
+    showAction?: boolean;
+    /** Espaçamento */
+    gap?: number;
+    /** Raio das bordas */
+    radius?: MantineRadius;
+    /** Se deve animar */
+    animate?: boolean;
+    /** Classe CSS */
+    className?: string;
+    /** Estilo */
+    style?: React.CSSProperties;
+}
+export declare const ArchbaseListSkeleton: React.ForwardRefExoticComponent<ArchbaseListSkeletonProps & React.RefAttributes<HTMLDivElement>>;

package/dist/feedback/index.d.ts

@@ -2,3 +2,9 @@ export { Alert as ArchbaseMantineAlert } from '@mantine/core';
 export { Notification as ArchbaseNotification } from '@mantine/core';
 export { Loader as ArchbaseLoader } from '@mantine/core';
 export { Progress as ArchbaseProgress } from '@mantine/core';
+export { ArchbaseChunkProgressBar } from './ArchbaseChunkProgressBar';
+export type { ArchbaseChunkProgressBarProps } from './ArchbaseChunkProgressBar';
+export { ArchbaseDataGridSkeleton, ArchbaseFormSkeleton, ArchbaseCardSkeleton, ArchbaseKanbanSkeleton, ArchbaseListSkeleton, } from './ArchbaseSkeleton';
+export type { ArchbaseDataGridSkeletonProps, ArchbaseFormSkeletonProps, ArchbaseCardSkeletonProps, ArchbaseKanbanSkeletonProps, ArchbaseListSkeletonProps, } from './ArchbaseSkeleton';
+export { ArchbaseRipple, useArchbaseRipple } from './ArchbaseRipple';
+export type { ArchbaseRippleProps, UseArchbaseRippleOptions, UseArchbaseRippleReturn } from './ArchbaseRipple';

package/dist/filters/ArchbaseColumnSelector.d.ts

@@ -0,0 +1,38 @@
+import { default as React } from 'react';
+export interface ArchbaseColumnItem {
+    field: string;
+    label: string;
+    visible: boolean;
+    order?: number;
+}
+export interface ArchbaseColumnSelectorProps {
+    /** Lista de colunas com configuração de visibilidade e ordem */
+    columns: ArchbaseColumnItem[];
+    /** Callback chamado quando a configuração de colunas muda */
+    onChange: (columns: Array<{
+        field: string;
+        label: string;
+        visible: boolean;
+        order: number;
+    }>) => void;
+    /** Rótulo exibido no topo do componente */
+    label?: string;
+    /** Descrição exibida abaixo do rótulo */
+    description?: string;
+    /** Exibir campo de busca */
+    showSearch?: boolean;
+    /** Exibir botões Selecionar Todos / Desmarcar Todos */
+    showSelectAll?: boolean;
+    /** Altura máxima da lista de colunas */
+    maxHeight?: number;
+    /** Estilos inline */
+    style?: React.CSSProperties;
+    /** Classe CSS */
+    className?: string;
+    /** Largura do componente */
+    width?: number | string;
+}
+export declare function ArchbaseColumnSelector({ columns, onChange, label, description, showSearch, showSelectAll, maxHeight, style, className, width, }: ArchbaseColumnSelectorProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace ArchbaseColumnSelector {
+    var displayName: string;
+}

package/dist/filters/index.d.ts

@@ -1,4 +1,6 @@
 export { ArchbaseCompositeFilters } from './ArchbaseCompositeFilters';
+export { ArchbaseColumnSelector } from './ArchbaseColumnSelector';
+export type { ArchbaseColumnSelectorProps, ArchbaseColumnItem } from './ArchbaseColumnSelector';
 export { FilterPill } from './components/FilterPill';
 export { useArchbaseFilters, useArchbaseFiltersControlled, } from './hooks/useArchbaseFilters';
 export { useArchbaseFilterPresets } from './hooks/useArchbaseFilterPresets';

package/dist/forms/ArchbaseFieldArray.d.ts

@@ -0,0 +1,80 @@
+import { default as React, ReactNode } from 'react';
+import { MantineColor, MantineSize } from '@mantine/core';
+import { UseFieldArrayReturn, Control, FieldValues, ArrayPath, FieldArrayWithId } from 'react-hook-form';
+export interface ArchbaseFieldArrayItemProps<T extends FieldValues> {
+    /** Índice do item */
+    index: number;
+    /** Dados do item */
+    item: FieldArrayWithId<T>;
+    /** Função para remover o item */
+    remove: () => void;
+    /** Se pode remover (baseado em minItems) */
+    canRemove: boolean;
+    /** Se pode arrastar */
+    canDrag: boolean;
+    /** Props de drag handle */
+    dragHandleProps?: Record<string, any>;
+}
+export interface ArchbaseFieldArrayProps<T extends FieldValues> {
+    /** Nome do campo no form */
+    name: ArrayPath<T>;
+    /** Control do react-hook-form */
+    control: Control<T>;
+    /** Renderizador do item */
+    renderItem: (props: ArchbaseFieldArrayItemProps<T>) => ReactNode;
+    /** Valor padrão para novos itens */
+    defaultValue?: Record<string, any>;
+    /** Mínimo de itens */
+    minItems?: number;
+    /** Máximo de itens */
+    maxItems?: number;
+    /** Label do botão adicionar */
+    addLabel?: string;
+    /** Componente de empty state */
+    emptyState?: ReactNode;
+    /** Se permite reordenar */
+    sortable?: boolean;
+    /** Se deve mostrar o header */
+    showHeader?: boolean;
+    /** Título do campo */
+    title?: string;
+    /** Descrição do campo */
+    description?: string;
+    /** Cor do botão adicionar */
+    addButtonColor?: MantineColor;
+    /** Variante do botão adicionar */
+    addButtonVariant?: 'filled' | 'light' | 'outline' | 'subtle' | 'default';
+    /** Tamanho */
+    size?: MantineSize;
+    /** Se deve usar Paper em volta de cada item */
+    withPaper?: boolean;
+    /** Se deve mostrar índice */
+    showIndex?: boolean;
+    /** Espaçamento entre itens */
+    gap?: MantineSize | number;
+    /** Se está desabilitado */
+    disabled?: boolean;
+    /** Callback quando array muda */
+    onArrayChange?: (items: any[]) => void;
+    /** Classe CSS */
+    className?: string;
+    /** Estilo */
+    style?: React.CSSProperties;
+}
+export declare const ArchbaseFieldArray: <T extends FieldValues>(props: ArchbaseFieldArrayProps<T> & {
+    ref?: React.Ref<HTMLDivElement>;
+}) => React.ReactElement;
+export interface UseArchbaseFieldArrayOptions<T extends FieldValues> {
+    name: ArrayPath<T>;
+    control: Control<T>;
+    minItems?: number;
+    maxItems?: number;
+    defaultValue?: Record<string, any>;
+}
+export interface UseArchbaseFieldArrayReturn<T extends FieldValues> extends UseFieldArrayReturn<T> {
+    canAdd: boolean;
+    canRemove: boolean;
+    addItem: () => void;
+    removeItem: (index: number) => void;
+}
+export declare function useArchbaseFieldArray<T extends FieldValues>(options: UseArchbaseFieldArrayOptions<T>): UseArchbaseFieldArrayReturn<T>;

package/dist/forms/ArchbaseFormWizard.d.ts

@@ -0,0 +1,73 @@
+import { default as React, ReactNode } from 'react';
+import { MantineColor, MantineSize } from '@mantine/core';
+import { ArchbaseDataSource } from '@archbase/data';
+import { FormWizardStep } from './useArchbaseFormWizard';
+export interface ArchbaseFormWizardStep<T = any> extends FormWizardStep<T> {
+    /** Componente React a ser renderizado no step */
+    component: ReactNode | ((props: {
+        data: T;
+        stepIndex: number;
+    }) => ReactNode);
+}
+export interface ArchbaseFormWizardProps<T extends object, ID = string> {
+    /** Lista de steps do wizard */
+    steps: ArchbaseFormWizardStep<T>[];
+    /** DataSource vinculado ao formulário */
+    dataSource?: ArchbaseDataSource<T, ID>;
+    /** Step inicial */
+    initialStep?: number;
+    /** Callback ao completar todos os steps */
+    onComplete?: (data: T) => void | Promise<void>;
+    /** Callback ao mudar de step */
+    onStepChange?: (fromStep: number, toStep: number, data: T) => void;
+    /** Se deve validar ao avançar */
+    validateOnNext?: boolean;
+    /** Se permite voltar para steps anteriores */
+    allowBack?: boolean;
+    /** Se permite clicar nos steps para navegar */
+    allowStepClick?: boolean;
+    /** Orientação do stepper */
+    orientation?: 'horizontal' | 'vertical';
+    /** Tamanho do stepper */
+    size?: MantineSize;
+    /** Cor do stepper */
+    color?: MantineColor;
+    /** Label do botão anterior */
+    backLabel?: string;
+    /** Label do botão próximo */
+    nextLabel?: string;
+    /** Label do botão finalizar */
+    completeLabel?: string;
+    /** Ícone do botão anterior */
+    backIcon?: ReactNode;
+    /** Ícone do botão próximo */
+    nextIcon?: ReactNode;
+    /** Ícone do botão finalizar */
+    completeIcon?: ReactNode;
+    /** Se deve mostrar os botões de navegação */
+    showNavigation?: boolean;
+    /** Posição dos botões de navegação */
+    navigationPosition?: 'top' | 'bottom' | 'both';
+    /** Componente de revisão final (opcional) */
+    reviewComponent?: ReactNode | ((props: {
+        data: T;
+    }) => ReactNode);
+    /** Componente de conclusão */
+    completedComponent?: ReactNode | ((props: {
+        data: T;
+        onReset: () => void;
+    }) => ReactNode);
+    /** Se deve mostrar o step de revisão */
+    showReviewStep?: boolean;
+    /** Padding do conteúdo */
+    contentPadding?: number | string;
+    /** Altura mínima do conteúdo */
+    contentMinHeight?: number | string;
+    /** Classe CSS adicional */
+    className?: string;
+    /** Estilos adicionais */
+    style?: React.CSSProperties;
+}
+export declare const ArchbaseFormWizard: <T extends object, ID = string>(props: ArchbaseFormWizardProps<T, ID> & {
+    ref?: React.Ref<HTMLDivElement>;
+}) => React.ReactElement;

package/dist/forms/ArchbaseStepper.d.ts

@@ -0,0 +1,51 @@
+import { default as React, ReactNode } from 'react';
+import { StepperProps, MantineColor, MantineSize } from '@mantine/core';
+export interface ArchbaseStepperStep {
+    /** Identificador único do step */
+    id?: string;
+    /** Título do step */
+    title: string;
+    /** Descrição do step */
+    description?: string;
+    /** Ícone do step */
+    icon?: ReactNode;
+    /** Cor do step quando ativo */
+    color?: MantineColor;
+    /** Se o step pode ser clicado para navegar diretamente */
+    allowStepSelect?: boolean;
+    /** Se o step está desabilitado */
+    disabled?: boolean;
+    /** Conteúdo do step */
+    children?: ReactNode;
+    /** Estado de carregamento do step */
+    loading?: boolean;
+}
+export interface ArchbaseStepperProps extends Omit<StepperProps, 'children' | 'active' | 'onStepClick'> {
+    /** Lista de steps */
+    steps: ArchbaseStepperStep[];
+    /** Step ativo (controlado) */
+    active?: number;
+    /** Step ativo inicial (não controlado) */
+    defaultActive?: number;
+    /** Callback quando o step muda */
+    onStepChange?: (nextStep: number, prevStep: number) => void;
+    /** Se permite clicar nos steps para navegar */
+    allowStepClick?: boolean;
+    /** Orientação do stepper */
+    orientation?: 'horizontal' | 'vertical';
+    /** Tamanho do stepper */
+    size?: MantineSize;
+    /** Cor do stepper */
+    color?: MantineColor;
+    /** Ícone de step completado */
+    completedIcon?: ReactNode;
+    /** Ícone de step em progresso */
+    progressIcon?: ReactNode;
+    /** Raio do ícone do step */
+    iconSize?: number;
+    /** Estilo do conector entre steps */
+    contentPadding?: number;
+    /** Se deve mostrar a barra de progresso */
+    withProgress?: boolean;
+}
+export declare const ArchbaseStepper: React.ForwardRefExoticComponent<Omit<ArchbaseStepperProps, "ref"> & React.RefAttributes<HTMLDivElement>>;

package/dist/forms/index.d.ts

@@ -1,3 +1,11 @@
 export { Button as ArchbaseButton } from '@mantine/core';
 export { ActionIcon as ArchbaseActionIcon } from '@mantine/core';
 export { Fieldset as ArchbaseFieldset } from '@mantine/core';
+export { ArchbaseStepper } from './ArchbaseStepper';
+export type { ArchbaseStepperProps, ArchbaseStepperStep } from './ArchbaseStepper';
+export { ArchbaseFormWizard } from './ArchbaseFormWizard';
+export type { ArchbaseFormWizardProps, ArchbaseFormWizardStep } from './ArchbaseFormWizard';
+export { useArchbaseFormWizard } from './useArchbaseFormWizard';
+export type { FormWizardStep, UseArchbaseFormWizardOptions, UseArchbaseFormWizardReturn, } from './useArchbaseFormWizard';
+export { ArchbaseFieldArray, useArchbaseFieldArray } from './ArchbaseFieldArray';
+export type { ArchbaseFieldArrayProps, ArchbaseFieldArrayItemProps, UseArchbaseFieldArrayOptions, UseArchbaseFieldArrayReturn, } from './ArchbaseFieldArray';

package/dist/forms/useArchbaseFormWizard.d.ts

@@ -0,0 +1,74 @@
+import { ArchbaseDataSource } from '@archbase/data';
+export interface FormWizardStep<T = any> {
+    /** Identificador único do step */
+    id: string;
+    /** Título do step */
+    title: string;
+    /** Descrição do step */
+    description?: string;
+    /** Ícone do step */
+    icon?: React.ReactNode;
+    /** Função de validação do step - retorna true se válido, string com erro se inválido */
+    validate?: (data: T) => boolean | string | Promise<boolean | string>;
+    /** Se o step é opcional */
+    optional?: boolean;
+    /** Campos do DataSource que pertencem a este step (para validação parcial) */
+    fields?: string[];
+}
+export interface UseArchbaseFormWizardOptions<T extends object, ID> {
+    /** Lista de steps do wizard */
+    steps: FormWizardStep<T>[];
+    /** DataSource vinculado ao formulário */
+    dataSource?: ArchbaseDataSource<T, ID>;
+    /** Step inicial */
+    initialStep?: number;
+    /** Callback ao completar todos os steps */
+    onComplete?: (data: T) => void | Promise<void>;
+    /** Callback ao mudar de step */
+    onStepChange?: (fromStep: number, toStep: number, data: T) => void;
+    /** Se deve validar ao avançar */
+    validateOnNext?: boolean;
+    /** Se permite voltar para steps anteriores */
+    allowBack?: boolean;
+    /** Se permite pular steps opcionais */
+    allowSkipOptional?: boolean;
+}
+export interface UseArchbaseFormWizardReturn<T> {
+    /** Step atual (0-indexed) */
+    currentStep: number;
+    /** Total de steps */
+    totalSteps: number;
+    /** Se está no primeiro step */
+    isFirstStep: boolean;
+    /** Se está no último step */
+    isLastStep: boolean;
+    /** Se o wizard foi completado */
+    isCompleted: boolean;
+    /** Se está validando */
+    isValidating: boolean;
+    /** Erro de validação do step atual */
+    validationError: string | null;
+    /** Dados do step atual */
+    currentStepData: FormWizardStep<T>;
+    /** Steps completados */
+    completedSteps: Set<number>;
+    /** Avançar para o próximo step */
+    nextStep: () => Promise<boolean>;
+    /** Voltar para o step anterior */
+    prevStep: () => void;
+    /** Ir para um step específico */
+    goToStep: (step: number) => Promise<boolean>;
+    /** Resetar o wizard */
+    reset: () => void;
+    /** Completar o wizard */
+    complete: () => Promise<boolean>;
+    /** Marcar step como completado */
+    markStepCompleted: (step: number) => void;
+    /** Verificar se um step está completado */
+    isStepCompleted: (step: number) => boolean;
+    /** Verificar se pode avançar */
+    canGoNext: boolean;
+    /** Verificar se pode voltar */
+    canGoBack: boolean;
+}
+export declare function useArchbaseFormWizard<T extends object, ID = string>(options: UseArchbaseFormWizardOptions<T, ID>): UseArchbaseFormWizardReturn<T>;

package/dist/hooks/index.d.ts

@@ -3,3 +3,5 @@ export { useArchbaseVisible } from './useArchbaseVisible';
 export { useArchbaseNavigateParams } from './useArchbaseNavigateParams';
 export { useArchbaseContainerDimensions } from './useArchbaseContainerDimensions';
 export { useArchbaseElementSizeArea } from './useArchbaseElementSizeArea';
+export { useArchbaseConfirm, archbaseConfirm, archbaseConfirmDelete, archbaseAlert, } from './useArchbaseConfirm';
+export type { ArchbaseConfirmOptions, ArchbaseDeleteConfirmOptions, UseArchbaseConfirmReturn, } from './useArchbaseConfirm';