@giro-ds/react 1.0.0

package/dist/index.d.ts

@@ -0,0 +1,1045 @@
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import * as React$1 from 'react';
+import React__default, { ReactNode, ReactElement, CSSProperties } from 'react';
+
+interface AvatarProps {
+    id?: string;
+    icon: React__default.ReactNode;
+    size?: 'small' | 'large';
+    className?: string;
+}
+
+declare let Avatar: ({ id, icon, size, className }: AvatarProps) => react_jsx_runtime.JSX.Element;
+
+type BadgeType = 'notification' | 'status';
+type BadgeValue = number | string | null;
+interface BadgeProps {
+    /** Tipo de badge (notificação ou status) */
+    type: BadgeType;
+    /** Conteúdo a ser envolvido pelo badge */
+    children?: ReactNode;
+    /** Valor a ser exibido no badge (número, texto ou null) */
+    badgeValue?: BadgeValue;
+    /** Classes CSS adicionais */
+    className?: string;
+    /** ID único do componente */
+    id?: string;
+    /** Se o badge está desabilitado */
+    maxValue?: number;
+    /** Props de acessibilidade customizadas */
+    'aria-label'?: string;
+}
+
+declare const Badge: React__default.FC<BadgeProps>;
+
+interface ButtonProps {
+    /** Define o elemento a ser renderizado (ex: 'button', 'a', ou componente de roteamento) */
+    as?: React__default.ElementType;
+    /** Define o texto principal do botão */
+    children?: React__default.ReactNode;
+    /** Define tipo do botão entre as opções */
+    variant?: 'filled' | 'outlined' | 'text';
+    iconOnly?: boolean;
+    /** Define a posição do ícone entre as opções */
+    iconPosition?: 'none' | 'left' | 'right';
+    /** URL para links externos (ex: https://example.com) */
+    href?: string;
+    /** Rota interna para navegação SPA (ex: /dashboard, /profile) */
+    to?: string;
+    /** Indica se o link é externo */
+    external?: boolean;
+    /** Target para links (_blank, _self, etc.) */
+    target?: string;
+    /** Rel attribute para links */
+    rel?: string;
+    /** Props para React Router (replace, state, etc.) */
+    routerProps?: Record<string, any>;
+    type?: 'button' | 'submit' | 'reset';
+    /** Desabilita interações do botão */
+    disabled?: boolean;
+    /** Função a ser chamada quando o botão é clicado */
+    onClick?: (event: React__default.MouseEvent<HTMLElement>) => void;
+    /** Define o tamanho do botão entre as opções */
+    size?: 'lg' | 'sm';
+    /** Classe CSS opcional */
+    className?: string;
+    /** ID opcional */
+    id?: string;
+    /** Ícone opcional */
+    icon?: React__default.ReactNode;
+    /** Define se o botão deve ocupar toda a largura */
+    fullWidth?: boolean;
+    /** Texto para acessibilidade */
+    ariaLabel?: string;
+    /** Outros props específicos do elemento/componente */
+    [key: string]: any;
+}
+
+declare const Button: React__default.ForwardRefExoticComponent<Omit<ButtonProps, "ref"> & React__default.RefAttributes<HTMLElement>>;
+
+type Locale = 'pt-br' | 'en-us';
+type DateFormat = 'dd/mm/yyyy' | 'mm/dd/yyyy';
+interface DayItem {
+    type: 'day';
+    key: number;
+    day: number;
+    date: Date;
+    isToday: boolean;
+    isSelected: boolean;
+    label: string;
+}
+interface EmptyItem {
+    type: 'empty';
+    key: string;
+}
+type CalendarItem = DayItem | EmptyItem;
+interface YearItem {
+    year: number;
+    isCurrent: boolean;
+    key: number;
+}
+interface CalendarProps {
+    /** Data do dia Atual */
+    currentDate: Date | null;
+    /** Classe CSS adicional */
+    className?: string;
+    /** Dia Selecionado pelo usuário */
+    selectedDate?: Date | null;
+    /** Função que é executada quando a data escolhida é alterada */
+    onDateChange?: (date: Date) => void;
+    /** Função que é executada quando um dia é selecionado */
+    onDaySelect?: (date: Date) => void;
+    onClear?: () => void;
+    minDate?: Date;
+    maxDate?: Date;
+    /** Locale do calendário ('pt-br' ou 'en-us') */
+    locale?: Locale;
+    /** Formato de exibição da data ('dd/mm/yyyy' ou 'mm/dd/yyyy') */
+    format?: DateFormat;
+    /** Identificador do elemento raiz do calendário */
+    id?: string;
+}
+
+declare const MemoizedCalendar: React__default.NamedExoticComponent<CalendarProps>;
+
+interface CalloutProps {
+    /** Define o tipo de callout */
+    type?: 'neutral' | 'color' | 'brand' | 'alert' | 'success';
+    /** Define o título com mais destaque */
+    title?: string | null;
+    /** Define o texto com menos destaque */
+    text?: string;
+    /** Define o ícone a ser importado */
+    icon?: React__default.ReactNode;
+    /** Define a classe CSS adicional */
+    className?: string;
+    /** Define o id do callout */
+    id?: string;
+    /** Props adicionais para o elemento div */
+    [key: string]: any;
+}
+
+declare const Callout: React__default.FC<CalloutProps>;
+
+interface CheckboxProps {
+    /** Unique identifier for the checkbox input */
+    id?: string;
+    /** Name attribute for the checkbox, used for form identification */
+    name?: string;
+    /** Controlled value indicating whether the checkbox is checked */
+    checked?: boolean;
+    /** Callback function triggered when the checkbox value changes */
+    onChange?: (event: React__default.ChangeEvent<HTMLInputElement>) => void;
+    /** Label text displayed next to the checkbox */
+    label?: string | React__default.ReactNode;
+    /** Additional CSS classes for custom styling */
+    className?: string;
+    /** Value attribute for the checkbox input element */
+    value?: string;
+    /** AriaDescribedBy for the checkbox input element */
+    ariaDescribedby?: string;
+    /** Disables the checkbox, preventing user interaction */
+    disabled?: boolean;
+    /** Sets the checkbox to an indeterminate state (useful for parent-child relationships) */
+    indeterminate?: boolean;
+    /** Additional props passed to the checkbox input element */
+    [key: string]: any;
+}
+
+declare const MemoizedCheckbox: React__default.NamedExoticComponent<CheckboxProps>;
+
+interface CheckboxRadixProps {
+    id?: string;
+    label: string;
+    onCheckedChange?: (checked: boolean) => void;
+    defaultChecked?: boolean;
+    checked?: boolean;
+    disabled?: boolean;
+    className?: string;
+    indeterminate?: boolean;
+}
+
+declare const CheckboxRadix: React$1.FC<CheckboxRadixProps>;
+
+interface ChipsProps {
+    /** Variante a ser escolhida para utilizar padrões de estilizações pré-definidos */
+    type?: 'neutral' | 'brand' | 'color' | 'success' | 'alert';
+    /** Texto a ser exibido dentro do componente */
+    title: string;
+    /** Ícone react que ficará posicionado à esquerda no componente */
+    leftIcon?: React__default.ReactNode;
+    /** Ícone react que ficará posicionado à direita no componente */
+    rightIcon?: React__default.ReactNode;
+    /** Estado alterável para desabilitar */
+    disabled?: boolean;
+    /** Classe CSS adicional */
+    className?: string;
+    /** Props adicionais para o elemento div */
+    [key: string]: any;
+}
+
+declare const MemoizedChips: React__default.NamedExoticComponent<ChipsProps>;
+
+interface ContainerProps {
+    children: React__default.ReactNode;
+}
+
+declare function Container({ children }: ContainerProps): react_jsx_runtime.JSX.Element;
+
+type DatePickerLocale = 'pt-br' | 'en-us';
+type CalendarPosition = 'left' | 'right';
+interface DatePickerProps {
+    /** Locale para formatação da data */
+    locale?: DatePickerLocale;
+    /** Posição do calendário */
+    calendarPosition?: CalendarPosition;
+    /** Texto de ajuda */
+    helperText?: string;
+    /** Se o campo é obrigatório */
+    required?: boolean;
+    /** Label do campo */
+    label?: string;
+    /** Valor controlado da data */
+    value?: Date | null;
+    /** Valor inicial para modo não controlado */
+    defaultValue?: Date | null;
+    /** Callback chamado quando a data muda */
+    onChange?: (date: Date | null) => void;
+    /** Se o campo está desabilitado */
+    disabled?: boolean;
+    /** Mensagem de erro */
+    error?: string;
+    /** Data mínima permitida */
+    minDate?: Date;
+    /** Data máxima permitida */
+    maxDate?: Date;
+    /** Classes CSS adicionais */
+    className?: string;
+    /** ID para testes */
+    'data-testid'?: string;
+}
+
+declare const _default: React__default.NamedExoticComponent<DatePickerProps>;
+
+interface DialogProps {
+    children?: ReactNode;
+    /** Se o Dialog está visível */
+    show: boolean;
+    /** Título exibido no cabeçalho do Dialog (obrigatório) */
+    title: string;
+    /** Texto do corpo do Dialog */
+    text?: ReactNode;
+    /** Texto do botão de confirmação */
+    textConfirm?: string;
+    /** Texto do botão de cancelamento */
+    textCancel?: string;
+    /** Função chamada ao confirmar */
+    fnConfirm?: () => void;
+    /** Função chamada ao cancelar */
+    fnCancel?: () => void;
+    /** Função chamada ao fechar o Dialog */
+    onClose?: () => void;
+    /** ID opcional para o Dialog */
+    id?: string;
+    /** Classe CSS opcional */
+    className?: string;
+}
+
+declare const MemoizedDialog: React__default.NamedExoticComponent<DialogProps>;
+
+interface DrawerProps {
+    /** Conteúdo do Drawer */
+    children?: ReactNode;
+    /** Largura do Drawer (use design tokens quando possível) */
+    customWidth?: string;
+    /** Callback quando o Drawer é fechado */
+    onClose: () => void;
+    /** Título do Drawer */
+    title?: string;
+    /** Determina se o drawer está aberto */
+    isOpen: boolean;
+    /** Callback quando o Drawer é aberto */
+    onOpen?: () => void;
+    /** Classes CSS adicionais */
+    className?: string;
+    /** ID único do componente */
+    id?: string;
+    /** Se o drawer está desabilitado */
+    disabled?: boolean;
+    /** Callback chamado quando clica no overlay */
+    onOverlayClick?: () => void;
+    /** Se deve fechar ao clicar no overlay */
+    closeOnOverlayClick?: boolean;
+    /** Se deve fechar ao pressionar ESC */
+    closeOnEscape?: boolean;
+}
+
+/**
+ * Componente Drawer do Zanthus Design System
+ * Implementa um painel lateral deslizante com overlay
+ * Segue padrões WCAG 2.1 AA para acessibilidade
+ */
+declare const Drawer: React__default.FC<DrawerProps>;
+
+interface DropdownItem {
+    /** ID único do item (opcional, será gerado automaticamente se não fornecido) */
+    id?: string;
+    /** Texto principal do item */
+    text: string;
+    /** Texto secundário/descrição do item */
+    subText?: string;
+    /** Ícone do item (React node) */
+    icon?: React__default.ReactNode;
+    /** Define se o item está desabilitado */
+    disabled?: boolean;
+}
+type DropdownType = 'text' | 'checkbox' | 'icon';
+interface DropdownProps {
+    /** Classes CSS adicionais */
+    className?: string;
+    /** Força posição do dropdown: 'top' abre para cima, 'bottom' abre para baixo. Se não especificado, usa detecção automática */
+    position?: 'top' | 'bottom';
+    /** Array de itens para o dropdown - obrigatório */
+    items: DropdownItem[];
+    /** ID único do componente */
+    id?: string;
+    /** Tipo do dropdown */
+    type?: DropdownType;
+    /** Habilita campo de busca */
+    applySearch?: boolean;
+    /** Placeholder do campo de busca */
+    placeholder?: string;
+    /** Callback para mudanças na seleção */
+    onSelectionChange?: (selectedIds: string[]) => void;
+    /** Controla exibição do subtexto */
+    showSubText?: boolean;
+    /** IDs dos itens selecionados por padrão */
+    defaultSelectedIds?: string[];
+    /** Estado inicial dos itens selecionados (objeto com chave-valor) */
+    initialItemsSelected?: Record<string, boolean>;
+    width?: string | number;
+    maxWidth?: string | number;
+    minWidth?: string | number;
+    /** Altura máxima do dropdown */
+    maxHeight?: string | number;
+    /** Define se o componente esta sendo usado para filtro */
+    filter?: boolean;
+    /**
+     * Configurações para paginação infinita
+     */
+    infiniteScroll?: {
+        /** Status atual do carregamento */
+        status: 'idle' | 'loading' | 'succeeded' | 'failed';
+        /** Página atual */
+        page: number;
+        /** Última página disponível */
+        lastPage: number;
+        /** Callback para carregar próxima página */
+        onLoadMore: () => void;
+        /** Threshold para trigger (0-1) */
+        threshold?: number;
+        /** Margem para trigger */
+        rootMargin?: string;
+        /** Debug mode */
+        debug?: boolean;
+    };
+}
+
+declare const MemoizedDropdown: React__default.NamedExoticComponent<DropdownProps>;
+
+type FilterButtonVariant = 'filled' | 'outlined' | 'text';
+interface FilterProps {
+    /** Items para o dropdown */
+    items?: DropdownItem[];
+    /** Tipo do dropdown */
+    type?: DropdownType | 'calendar';
+    /** IDs selecionados */
+    selectedIds?: string[];
+    /** Callback quando aplicar filtros */
+    onApplyFilter?: (selectedIds: string[]) => void;
+    /** Placeholder do dropdown */
+    placeholder?: string;
+    /** Habilita busca no dropdown */
+    enableSearch?: boolean;
+    /** Texto do botão do filtro */
+    buttonText?: string | ReactNode;
+    /** Ícone do botão */
+    icon?: ReactElement;
+    /** Variante do botão */
+    variant?: FilterButtonVariant;
+    /** Callback chamado quando o filtro é aberto */
+    onOpen?: () => void;
+    /** Callback chamado quando o filtro é fechado */
+    onClose?: () => void;
+    /** Posição do dropdown */
+    position?: 'left' | 'right';
+    /** Se o filtro está desabilitado */
+    disabled?: boolean;
+    /** Classes CSS adicionais */
+    className?: string;
+    /** Data selecionada (quando type='calendar') */
+    selectedDate?: Date | null;
+    /** Callback quando data é selecionada */
+    onDateSelect?: (date: Date) => void;
+    /** Callback para limpar data */
+    onClearDate?: () => void;
+    /** Data mínima permitida */
+    minDate?: Date;
+    /** Data máxima permitida */
+    maxDate?: Date;
+    /** Locale do calendar */
+    locale?: 'pt-br' | 'en-us';
+}
+
+declare const Filter: React__default.FC<FilterProps>;
+
+type ListItemVariant = 'text' | 'checkbox' | 'radio' | 'icon';
+interface ListItemProps {
+    /** ID único do componente */
+    id?: string;
+    /** Classes CSS customizadas */
+    className?: string;
+    /** Variante do item da lista */
+    variant?: ListItemVariant;
+    /** Texto principal do item */
+    text?: string;
+    /** Nome do input (para checkbox/radio) */
+    name?: string;
+    /** Texto secundário/descrição */
+    subText?: string;
+    /** Se o item está desabilitado */
+    disabled?: boolean;
+    /** Estado de checked (para checkbox/radio) */
+    checked?: boolean;
+    /** Estado de selecionado (para text/icon) */
+    selected?: boolean;
+    /** Callback para clique no item */
+    onClick?: (event: React__default.MouseEvent<HTMLElement> | React__default.KeyboardEvent<HTMLElement>) => void;
+    /** Callback para mudança de estado */
+    onChange?: (checked: boolean) => void;
+    /** Ícone do item (para variant icon) */
+    icon?: React__default.ReactNode;
+    /** Valor do input (para checkbox/radio) */
+    value?: string;
+    /** Se deve mostrar o subtexto */
+    showSubText?: boolean;
+    /** Estado de hover */
+    hovered?: boolean;
+}
+
+/**
+ * Componente ListItem do Zanthus Design System
+ * Implementa item de lista unificado com variações text, checkbox, radio e icon
+ * Segue padrões WCAG 2.1 AA para acessibilidade
+ */
+declare const ListItem: React__default.FC<ListItemProps>;
+
+interface MenuItem {
+    /** ID único do item */
+    id: string;
+    /** Texto principal do item */
+    text: string;
+    /** Texto secundário opcional */
+    subText?: string;
+    /** Ícone do item */
+    icon?: ReactNode;
+    /** Estado desabilitado */
+    disabled?: boolean;
+    /** Valor customizado do item */
+    value?: unknown;
+}
+interface MenuProps {
+    /** Elemento React que será usado como âncora do menu (obrigatório) */
+    children: ReactElement<any, any>;
+    /** Array de itens do menu */
+    menuItems?: MenuItem[];
+    /** Callback executado quando um item do menu é clicado */
+    onMenuItemClick?: (item: MenuItem) => void;
+    /** Callback executado quando o menu é aberto/fechado */
+    onToggle?: (isOpen: boolean) => void;
+    /** Tipo do dropdown */
+    type?: 'text' | 'icon';
+    /** Habilita campo de busca */
+    applySearch?: boolean;
+    /** Placeholder do campo de busca */
+    placeholder?: string;
+    /** Controla exibição do subtexto */
+    showSubText?: boolean;
+    /** Classes CSS adicionais */
+    className?: string;
+    /** ID único do componente */
+    id?: string;
+    maxWidth?: string | number;
+    minWidth?: string | number;
+    /** Posição do menu em relação ao elemento âncora */
+    position?: 'left' | 'right';
+}
+
+declare const Menu: React__default.FC<MenuProps>;
+
+interface MenuItemProps {
+    id?: string;
+    text?: string;
+    subText?: string;
+    disabled?: boolean;
+    icon?: React.ReactNode;
+    children?: MenuItemProps[];
+    value?: string;
+}
+interface MenuRadixProps {
+    items: MenuItemProps[];
+    children?: ReactElement;
+    type?: 'text' | 'icon';
+    className?: string;
+    onItemSelect?: (items: MenuItemProps) => void;
+    selectedItems?: MenuItemProps[];
+    search?: boolean;
+    align?: 'start' | 'end' | 'center';
+    maxHeight?: number | string;
+    enableInfiniteScroll?: boolean;
+    onScrollEnd?: () => void;
+    isLoadingMore?: boolean;
+    enableApiSearch?: boolean;
+    onApiSearch?: (searchTerm: string) => void;
+    onOpenChange?: (open: boolean) => void;
+}
+
+declare const MenuRadix: React__default.FC<MenuRadixProps>;
+
+interface QuantityProps {
+    /** Valor padrão inicial */
+    defaultValue?: number;
+    /** Valor controlado externamente */
+    value?: number;
+    /** Callback chamado quando o valor muda */
+    onChange?: (value: number) => void;
+    /** Define se o componente está desabilitado */
+    disabled?: boolean;
+    /** Define se o valor do input será decimal ou inteiro */
+    decimal?: boolean;
+    /** Define o tamanho do componente */
+    size?: 'lg' | 'sm';
+    /** Define o número de casas decimais quando decimal for true */
+    decimalPlaces?: number;
+    step?: number;
+    id?: string;
+    /** ClassName adicional para customização */
+    className?: string;
+}
+
+declare const memorizedQuantity: React__default.NamedExoticComponent<QuantityProps>;
+
+interface RadioProps$1 {
+    /** Definirá o nome do grupo de radio */
+    name?: string;
+    /** O valor associado ao botão de rádio */
+    value: string;
+    /** O identificador único para o input do rádio */
+    id?: string;
+    /** Indica se o botão de rádio está selecionado */
+    checked?: boolean;
+    /** Classes adicionais para estilização personalizada */
+    className?: string;
+    /** Função de callback acionada quando o valor do botão de rádio muda */
+    onChange?: (value: string) => void;
+    /** O texto do rótulo exibido ao lado do botão de rádio */
+    label?: string;
+    /** Indica se o botão de rádio está desabilitado */
+    disabled?: boolean;
+}
+
+declare const MemoizedRadio: React__default.NamedExoticComponent<RadioProps$1>;
+
+interface RadioProps {
+    id?: string | number;
+    value: string;
+    label: string;
+    disabled?: boolean;
+}
+interface RadioGroupProps {
+    id?: string;
+    items: RadioProps[];
+    onValueChange?: (value: string) => void;
+    defaultValue?: string;
+    name?: string;
+    ariaLabel?: string;
+    orientation?: "horizontal" | "vertical";
+}
+
+declare const RadioRadix: React__default.FC<RadioGroupProps>;
+
+interface SearchProps {
+    placeholder?: string;
+    disabled?: boolean;
+    value?: string;
+    onChange?: (e: React__default.ChangeEvent<HTMLInputElement>) => void;
+    onKeyDown?: (e: React__default.KeyboardEvent<HTMLInputElement>) => void;
+    onFocus?: (e: React__default.FocusEvent<HTMLInputElement>) => void;
+    onBlur?: (e: React__default.FocusEvent<HTMLInputElement>) => void;
+    onClear?: () => void;
+    onClick?: (e: React__default.MouseEvent<HTMLDivElement>) => void;
+    onMouseDown?: (e: React__default.MouseEvent<HTMLDivElement>) => void;
+    className?: string;
+    id?: string;
+}
+
+declare const Search: React__default.ForwardRefExoticComponent<SearchProps & React__default.RefAttributes<HTMLInputElement>>;
+
+interface SelectOption {
+    /** ID único da opção (opcional, será gerado automaticamente se não fornecido) */
+    id?: string;
+    /** Texto principal da opção */
+    text: string;
+    /** Texto secundário/descrição da opção */
+    subText?: string;
+    /** Ícone da opção (React node) */
+    icon?: React__default.ReactNode;
+    /** Define se a opção está desabilitada */
+    disabled?: boolean;
+}
+interface SelectProps {
+    /** ID único do componente */
+    id?: string;
+    /** Array de opções para seleção - obrigatório */
+    options: SelectOption[];
+    /** Valor(es) selecionado(s) */
+    value?: string | string[];
+    /** Valor inicial para seleção (usado apenas na primeira renderização) */
+    initialValue?: string | string[];
+    /** Callback para mudanças na seleção */
+    onChange?: (selectedItems: SelectOption[]) => void;
+    /** Placeholder do campo */
+    placeholder?: string;
+    /** Tipo do dropdown (single ou multiple) */
+    type?: DropdownType;
+    maxHeight?: string;
+    /** Label do campo */
+    label?: string;
+    /** Texto de ajuda */
+    helperText?: string;
+    /** Mensagem de erro */
+    errorMessage?: string;
+    /** Campo obrigatório */
+    required?: boolean;
+    /** Campo desabilitado */
+    disabled?: boolean;
+    /** Classes CSS adicionais */
+    className?: string;
+    /** Texto para acessibilidade */
+    showSubText?: boolean;
+    /** Aria-label do campo */
+    ariaLabel?: string;
+    /** Habilita campo de busca */
+    applySearch?: boolean;
+    /** Placeholder do campo de busca */
+    searchPlaceholder?: string;
+    maxWidth?: string;
+    minWidth?: string;
+    tooltip?: boolean;
+    tooltipText?: string;
+    width?: string;
+    /** Força posição do dropdown: 'top' abre para cima, 'bottom' abre para baixo. Se não especificado, usa detecção automática */
+    position?: 'top' | 'bottom';
+    positionTooltip?: 'top-right' | 'top-left' | 'bottom-right' | 'bottom-left' | 'left' | 'right';
+    infiniteScroll?: {
+        status: 'idle' | 'loading' | 'succeeded' | 'failed';
+        page: number;
+        lastPage: number;
+        onLoadMore: () => void;
+        threshold?: number;
+        rootMargin?: string;
+    };
+}
+
+declare const Select: React__default.NamedExoticComponent<SelectProps>;
+
+interface SelectFieldProps {
+    /** ID do campo */
+    id?: string;
+    /** Nome do campo */
+    name?: string;
+    /** Valor exibido */
+    value?: string;
+    /** Placeholder */
+    placeholder?: string;
+    /** Label do campo */
+    label?: string;
+    /** Texto de ajuda */
+    helperText?: string;
+    /** Mensagem de erro */
+    errorMessage?: string;
+    /** Campo obrigatório */
+    required?: boolean;
+    /** Campo desabilitado */
+    disabled?: boolean;
+    /** Ícone (chevron) */
+    icon?: React__default.ReactNode;
+    /** Estado aberto */
+    isOpen?: boolean;
+    /** Classes CSS adicionais */
+    className?: string;
+    /** Tooltip info */
+    tooltip?: React__default.ReactNode;
+    tooltipText?: string;
+    positionTooltip?: 'top-right' | 'top-left' | 'bottom-right' | 'bottom-left' | 'left' | 'right';
+    /** Indica se o campo foi "tocado" (aberto e fechado) */
+    isTouched?: boolean;
+    /** Força estado de erro independente da validação interna */
+    hasError?: boolean;
+}
+
+declare const SelectField: React__default.ForwardRefExoticComponent<SelectFieldProps & React__default.RefAttributes<HTMLDivElement>>;
+
+interface SelectItemProps {
+    id?: string;
+    text: ReactNode;
+    subTitle?: ReactNode;
+    icon?: ReactNode;
+    disabled?: boolean;
+    value: string;
+    selected?: boolean;
+}
+type SelectVariant = 'text' | 'icon' | 'checkbox';
+interface SelectRadixProps {
+    items: SelectItemProps[];
+    onValueChange?: (value: string | string[]) => void;
+    onOpenChange?: (open: boolean) => void;
+    variant: SelectVariant;
+    required?: boolean;
+    value?: string | string[];
+    multiple?: boolean;
+    placeholder?: string;
+    search?: boolean;
+    tooltip?: boolean;
+    tooltipMessage?: string;
+    label?: string;
+    helperText?: string;
+    maxWidth?: string | number;
+    errorMessage?: string;
+    disabled?: boolean;
+    className?: string;
+    'aria-label'?: string;
+    'data-testid'?: string;
+    enableInfiniteScroll?: boolean;
+    onScrollEnd?: () => void;
+    isLoadingMore?: boolean;
+    enableApiSearch?: boolean;
+    onApiSearch?: (term: string) => void;
+    isSearching?: boolean;
+}
+
+declare const SelectRadix: React__default.FC<SelectRadixProps>;
+
+type TableColumnType = 'text' | 'datetime' | 'custom';
+type TableAlign = 'left' | 'center' | 'right';
+interface TableColumn {
+    key: string;
+    label: ReactNode;
+    type?: TableColumnType;
+    format?: string;
+    render?: (row: TableRowData, index: number) => ReactNode;
+    align?: TableAlign;
+    style?: CSSProperties;
+}
+type TableRowData = Record<string, any>;
+interface TableProps {
+    columns: TableColumn[];
+    dataSource: TableRowData[];
+    className?: string;
+    loading?: boolean;
+    rowSelection?: {
+        selectedRowKeys?: (string | number)[];
+        onChange?: (keys: (string | number)[], rows: TableRowData[]) => void;
+        getCheckboxProps?: (row: TableRowData, index: number) => {
+            disabled?: boolean;
+        };
+    };
+    locale?: {
+        emptyText?: ReactNode;
+    };
+    /** Eventos de linha */
+    onRow?: (row: TableRowData, index: number) => {
+        onClick?: () => void;
+        onDoubleClick?: () => void;
+        className?: string;
+    };
+}
+
+declare const Table: React__default.FC<TableProps>;
+
+interface BaseFilterItem {
+    id?: string;
+    buttonText: string | React__default.ReactNode;
+    icon?: React__default.ReactElement;
+    position?: 'left' | 'right';
+    disabled?: boolean;
+    onToggle?: (isOpen: boolean) => void;
+    tooltip?: string;
+}
+interface CheckboxFilterItem extends BaseFilterItem {
+    type: 'checkbox' | 'text' | 'icon';
+    items: DropdownItem[];
+    selectedIds?: string[];
+    onSelectionChange?: (selectedIds: string[]) => void;
+    placeholder?: string;
+    enableSearch?: boolean;
+}
+interface CalendarFilterItem extends BaseFilterItem {
+    type: 'calendar';
+    selectedDate?: Date | null;
+    onDateSelect?: (date: Date) => void;
+    minDate?: Date;
+    maxDate?: Date;
+    locale?: string;
+    placeholder?: string;
+}
+type FilterItem = CheckboxFilterItem | CalendarFilterItem;
+interface TableHeaderProps {
+    searchValue?: string;
+    onSearchChange?: (value: string) => void;
+    searchPlaceholder?: string;
+    showSearch?: boolean;
+    showFilters?: boolean;
+    filters?: React__default.ReactNode;
+    filterItems?: FilterItem[];
+    className?: string;
+    onSearch?: (value: string) => void;
+    showClearSearch?: boolean;
+}
+declare const TableHeader: React__default.FC<TableHeaderProps>;
+
+interface TablePaginationProps {
+    /** Página atual */
+    currentPage: number;
+    /** Total de itens */
+    totalItems: number;
+    /** Itens por página */
+    itemsPerPage: number;
+    /** Callback quando a página muda */
+    onPageChange: (page: number) => void;
+    /** Callback quando itens por página muda */
+    onItemsPerPageChange: (itemsPerPage: number) => void;
+    /** Opções disponíveis para itens por página */
+    pageSizeOptions?: number[];
+    /** Desabilita a paginação */
+    disabled?: boolean;
+    /** Classes CSS adicionais */
+    className?: string;
+}
+declare const TablePagination: React__default.FC<TablePaginationProps>;
+
+interface TextFieldProps {
+    name?: string;
+    className?: string;
+    value?: string | number;
+    label?: string;
+    placeholder?: string;
+    type?: string;
+    onChange?: (value: string | number) => void;
+    disabled?: boolean;
+    maxLength?: number;
+    required?: boolean;
+    helper?: boolean;
+    helperText?: string;
+    tooltip?: boolean;
+    tooltipText?: string;
+    positionTooltip?: 'top-right' | 'top-left' | 'bottom-right' | 'bottom-left';
+    errorMessage?: string;
+    trailingIcon?: boolean;
+    id?: string;
+    icon?: React__default.ReactNode;
+}
+
+declare const MemoizedTextField: React__default.NamedExoticComponent<TextFieldProps>;
+
+type ToastType = 'success' | 'alert' | 'info';
+interface ToastMessage {
+    id: string;
+    message: string;
+    type: ToastType;
+    persistent?: boolean;
+    duration?: number;
+    timestamp: number;
+}
+interface ToastOptions {
+    persistent?: boolean;
+    duration?: number;
+}
+interface ToastContextType {
+    showToast: (message: string, type?: ToastType, options?: ToastOptions) => string;
+    hideToast: (id: string) => void;
+    hideAllToasts: () => void;
+}
+
+interface ToastProviderProps {
+    children: ReactNode;
+    maxToasts?: number;
+}
+declare const ToastProvider: React__default.FC<ToastProviderProps>;
+declare const useToast: () => ToastContextType;
+
+interface TooltipProps {
+    id?: string;
+    text: React__default.ReactNode;
+    position?: 'top-right' | 'top-left' | 'bottom-right' | 'bottom-left' | 'left' | 'right';
+    children: React__default.ReactNode;
+}
+
+declare const Tooltip: React__default.FC<TooltipProps>;
+
+type InputType = 'numeric' | 'alpha' | 'alphanumeric';
+interface VerificationCodeProps {
+    /** Define o número de dígitos do código (padrão: 6) */
+    length?: number;
+    /** Define tipo de entrada: números, letras ou alfanumérico (padrão: "numeric") */
+    inputType?: InputType;
+    /** Callback chamado quando todos os campos são preenchidos */
+    onComplete?: (value: string) => void;
+    /** Indica se o campo está em estado de erro */
+    hasError?: boolean;
+    /** Mensagem de erro exibida abaixo do componente */
+    errorMessage?: string;
+    /** Define se o componente deve estar desabilitado */
+    disabled?: boolean;
+    /** Classe CSS adicional para estilização externa */
+    className?: string;
+    /** Props adicionais passadas para os inputs */
+    [key: string]: any;
+}
+
+/**
+ * Componente VerificationCode para entrada de códigos de verificação
+ *
+ * @description Permite entrada de códigos com múltiplos dígitos,
+ * suportando diferentes tipos de caracteres e navegação por teclado.
+ *
+ * @example
+ * ```tsx
+ * <VerificationCode
+ *   length={6}
+ *   inputType="numeric"
+ *   onComplete={(code) => console.log('Código:', code)}
+ *   hasError={false}
+ * />
+ * ```
+ */
+declare const VerificationCode: React__default.FC<VerificationCodeProps>;
+
+/**
+ * Configurações para simulação de API
+ */
+interface ApiSimulationConfig {
+    /** Items por página */
+    itemsPerPage?: number;
+    /** Total de items no dataset */
+    totalItems?: number;
+    /** Delay em ms para simular latência */
+    delay?: number;
+    /** Taxa de erro (0-1) para simular falhas */
+    errorRate?: number;
+    /** Função geradora de items customizada */
+    itemGenerator?: (index: number, searchQuery?: string) => any;
+    /** Debug mode */
+    debug?: boolean;
+}
+/**
+ * Estado da simulação de API
+ */
+interface ApiSimulationState<T> {
+    /** Items carregados */
+    items: T[];
+    /** Página atual */
+    currentPage: number;
+    /** Total de páginas */
+    totalPages: number;
+    /** Status do carregamento */
+    status: 'idle' | 'loading' | 'succeeded' | 'failed';
+    /** Erro atual (se houver) */
+    error: string | null;
+    /** Query de busca atual */
+    searchQuery: string;
+    /** Se há próxima página */
+    hasNextPage: boolean;
+    /** Se é a primeira página */
+    isFirstPage: boolean;
+}
+interface ApiSimulationActions {
+    /** Carregar próxima página */
+    loadNextPage: () => Promise<void>;
+    /** Realizar nova busca */
+    search: (query: string) => Promise<void>;
+    /** Reset completo */
+    reset: () => void;
+    /** Retry da última operação */
+    retry: () => Promise<void>;
+}
+interface UseApiSimulationReturn<T> extends ApiSimulationState<T> {
+    actions: ApiSimulationActions;
+}
+declare function useApiSimulation<T = any>(config?: ApiSimulationConfig): UseApiSimulationReturn<T>;
+
+/**
+ * Props para o hook useInfiniteScroll
+ */
+interface UseInfiniteScrollProps {
+    /** Status atual do carregamento */
+    status: 'idle' | 'loading' | 'succeeded' | 'failed';
+    /** Página atual */
+    page: number;
+    /** Última página disponível */
+    lastPage: number;
+    /** Callback para carregar próxima página */
+    onLoadMore: () => void;
+    /** Threshold para IntersectionObserver (0-1) */
+    threshold?: number;
+    /** Margem raiz para IntersectionObserver */
+    rootMargin?: string;
+    /** Habilita/desabilita o hook */
+    enabled?: boolean;
+    /** Debug mode - logs no console */
+    debug?: boolean;
+}
+/**
+ * Retorno do hook useInfiniteScroll
+ */
+interface UseInfiniteScrollReturn {
+    /** Ref para o elemento observador */
+    observerRef: React.RefObject<HTMLDivElement | null>;
+    /** Se o elemento está visível */
+    isIntersecting: boolean;
+    /** Se há próxima página */
+    hasNextPage: boolean;
+    /** Se todas as páginas foram carregadas */
+    isCompleted: boolean;
+    /** Função para reset manual */
+    reset: () => void;
+}
+/**
+ * Hook otimizado para scroll infinito usando IntersectionObserver
+ */
+declare function useInfiniteScroll({ status, page, lastPage, onLoadMore, threshold, rootMargin, enabled, debug }: UseInfiniteScrollProps): UseInfiniteScrollReturn;
+
+declare const normalizeText: (text: React.ReactNode) => string;
+
+export { Avatar, Badge, Button, MemoizedCalendar as Calendar, Callout, MemoizedCheckbox as Checkbox, CheckboxRadix, MemoizedChips as Chips, Container, _default as DatePicker, MemoizedDialog as Dialog, Drawer, MemoizedDropdown as Dropdown, Filter, ListItem, Menu, MenuRadix, memorizedQuantity as Quantity, MemoizedRadio as Radio, RadioRadix, Search, Select, SelectField, SelectRadix, Table, TableHeader, TablePagination, MemoizedTextField as TextField, ToastProvider as Toast, ToastProvider, Tooltip, VerificationCode, normalizeText, useApiSimulation, useInfiniteScroll, useToast };
+export type { AvatarProps, BadgeProps, ButtonProps, CalendarItem, CalendarProps, CalloutProps, CheckboxProps, CheckboxRadixProps, ChipsProps, ContainerProps, DateFormat, DatePickerProps, DayItem, DialogProps, DrawerProps, DropdownItem, DropdownProps, DropdownType, EmptyItem, FilterItem, FilterProps, ListItemProps, Locale, MenuItem, MenuProps, MenuRadixProps, QuantityProps, RadioProps$1 as RadioProps, RadioProps as RadioRadixItemProps, RadioGroupProps as RadioRadixProps, SearchProps, SelectFieldProps, SelectOption, SelectProps, SelectRadixProps, TableHeaderProps, TablePaginationProps, TableProps, TextFieldProps, ToastContextType, ToastMessage, ToastOptions, ToastType, TooltipProps, VerificationCodeProps, YearItem };