@giro-ds/react 5.0.0 → 6.0.0

package/dist/index.d.ts

@@ -0,0 +1,1656 @@
+import * as React$1 from 'react';
+import React__default, { ReactNode, ReactElement, ComponentPropsWithoutRef, CSSProperties } from 'react';
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import { Matcher } from 'react-day-picker';
+import { Toast as Toast$1 } from 'radix-ui';
+
+type Size = 'sm' | 'lg';
+type Variant = 'filled' | 'outlined' | 'text';
+type TextVariant = 'neutral' | 'brand' | 'color' | 'success' | 'alert';
+type Side = 'top' | 'right' | 'bottom' | 'left';
+type Align = 'start' | 'center' | 'end';
+type Position = 'right' | 'left' | 'both';
+type Locale = 'pt-br' | 'en-us';
+interface BaseProps {
+    id?: string;
+    className?: string;
+    disabled?: boolean;
+}
+
+/**
+ * Props do componente Avatar
+ * @example
+ * ```tsx
+ * // Avatar com ícone
+ * <Avatar icon={<UserIcon />} size="lg" />
+ *
+ * // Avatar com imagem
+ * <Avatar src="https://example.com/avatar.jpg" icon={<UserIcon />} size="sm" />
+ * ```
+ */
+interface AvatarProps extends BaseProps {
+    /** Ícone ou conteúdo a ser exibido no fallback quando não há imagem ou ela falha ao carregar */
+    icon?: React$1.ReactNode;
+    /** Tamanho do avatar: 'sm' (32px) ou 'lg' (44px). @default 'lg' */
+    size?: Size;
+    /** URL da imagem do avatar. Quando fornecido, exibe a imagem; caso contrário, mostra o ícone */
+    src?: string;
+    /** Texto alternativo da imagem do avatar, usado como as iniciais do nome */
+    initialLetters?: string;
+}
+
+declare const Avatar: React__default.FC<AvatarProps>;
+
+/** Tipos de badge suportados */
+type BadgeType = 'notification' | 'status';
+/** Valores possíveis para exibição no badge */
+type BadgeValue = number | string | null;
+/**
+ * Props do componente Badge
+ * @example
+ * ```tsx
+ * <Badge type="notification" badgeValue={5}>
+ *   <IconButton icon={<BellIcon />} />
+ * </Badge>
+ * ```
+ * @example
+ * ```tsx
+ * <Badge
+ *   type="status"
+ *   badgeValue="novo"
+ *   aria-label="Novo item disponível"
+ * >
+ *   <Avatar icon={<UserIcon />} />
+ * </Badge>
+ * ```
+ */
+interface BadgeProps extends BaseProps {
+    /** 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;
+    /** Valor máximo a ser exibido (ex: 99+ quando badgeValue > maxValue) */
+    maxValue?: number;
+    /** Label acessível para leitores de tela */
+    'aria-label'?: string;
+}
+
+declare const Badge: React__default.FC<BadgeProps>;
+
+/**
+ * Props base do Button, independentes da variante iconOnly/icon.
+ * `target`, `rel`, `type` e `onClick` são declarados aqui para garantir
+ * que o destructuring funcione em todos os modos (button | a | custom).
+ */
+type ButtonOwnPropsBase = {
+    /** Elemento customizado a ser renderizado (ex: 'a', Link do React Router) */
+    as?: React__default.ElementType;
+    /** Conteúdo do botão */
+    children?: React__default.ReactNode;
+    /** Variante visual do botão */
+    variant?: Variant;
+    /** Posição do ícone em relação ao texto */
+    iconPosition?: Position;
+    /** URL de destino quando usado como link (renderiza <a>) */
+    href?: string;
+    /** Rota de destino para roteadores (ex: React Router) */
+    to?: string;
+    /** Define se o link abre em nova aba */
+    external?: boolean;
+    /** Atributo target do HTML para links */
+    target?: string;
+    /** Atributo rel do HTML para links */
+    rel?: string;
+    /** Tipo HTML do botão */
+    type?: 'button' | 'submit' | 'reset';
+    /** Tamanho do botão */
+    size?: Size;
+    /** Define se o botão ocupa 100% da largura do container */
+    fullWidth?: boolean;
+    /** Label acessível para leitores de tela */
+    ariaLabel?: string;
+    /** Estado de carregamento (exibe spinner) */
+    loading?: boolean;
+    /** Texto do tooltip exibido quando o botão é apenas ícone */
+    tooltipText?: string;
+    /** Lado em que o tooltip será exibido */
+    tooltipSide?: 'top' | 'bottom' | 'left' | 'right';
+    /** Alinhamento do tooltip */
+    tooltipAlign?: 'start' | 'center' | 'end';
+    /** Handler de clique; tipado em HTMLElement para ser compatível com todos os modos */
+    onClick?: React__default.MouseEventHandler<HTMLElement>;
+} & BaseProps;
+/**
+ * Props próprias do componente Button.
+ * Quando `iconOnly: true`, a prop `icon` é **obrigatória**.
+ * Isso evita que botões icon-only sejam renderizados sem ícone definido.
+ */
+type ButtonOwnProps = (ButtonOwnPropsBase & {
+    /** Exibe apenas o ícone, sem texto. Requer obrigatoriamente a prop `icon`. */
+    iconOnly: true;
+    /** Ícone exibido no botão — obrigatório quando `iconOnly` é true */
+    icon: React__default.ReactNode;
+}) | (ButtonOwnPropsBase & {
+    /** @default false */
+    iconOnly?: false;
+    /** Ícone a ser exibido no botão */
+    icon?: React__default.ReactNode;
+});
+/** Button renderizado como `<button>` — recebe atributos HTML precisos de HTMLButtonElement */
+type ButtonAsButton = ButtonOwnProps & Omit<React__default.ButtonHTMLAttributes<HTMLButtonElement>, keyof ButtonOwnProps>;
+/** Button renderizado como `<a>` — recebe atributos HTML precisos de HTMLAnchorElement */
+type ButtonAsAnchor = ButtonOwnProps & Omit<React__default.AnchorHTMLAttributes<HTMLAnchorElement>, keyof ButtonOwnProps>;
+/** Button renderizado como elemento customizado via prop `as` */
+type ButtonAsCustom = ButtonOwnProps & Omit<React__default.HTMLAttributes<HTMLElement>, keyof ButtonOwnProps> & {
+    as: React__default.ElementType;
+};
+/**
+ * Props do componente Button
+ * @example
+ * ```tsx
+ * <Button variant="filled" size="lg" onClick={handleClick}>
+ *   Clique aqui
+ * </Button>
+ * ```
+ * @example
+ * ```tsx
+ * <Button
+ *   variant="outlined"
+ *   icon={<Icon />}
+ *   iconPosition="left"
+ *   loading={isLoading}
+ * >
+ *   Salvar
+ * </Button>
+ * ```
+ */
+type ButtonProps = ButtonAsButton | ButtonAsAnchor | ButtonAsCustom;
+
+declare const Button: React__default.ForwardRefExoticComponent<ButtonProps & React__default.RefAttributes<HTMLButtonElement | HTMLAnchorElement>>;
+
+/** Formato de exibição da data aceito pelo componente. */
+type DateFormat = 'dd/mm/yyyy' | 'mm/dd/yyyy' | (string & {});
+interface CalendarBaseProps extends Omit<BaseProps, 'disabled'> {
+    /** Data selecionada atualmente (usada pelo DatePicker). */
+    selected?: Date | null;
+    /**
+     * Mês exibido no calendário. Use junto com `onDateChange` para
+     * controlar a navegação externamente.
+     */
+    currentDate?: Date | null;
+    /**
+     * Mês inicial padrão exibido quando não controlado.
+     * @default currentDate
+     */
+    defaultMonth?: Date;
+    /** Primeiro mês navegável. */
+    startMonth?: Date;
+    /** Último mês navegável. */
+    endMonth?: Date;
+    /** Chamado quando o usuário seleciona um dia. */
+    onDaySelect?: (date: Date) => void;
+    /** Chamado quando o usuário navega entre meses. */
+    onDateChange?: (date: Date) => void;
+    /** Chamado quando o usuário limpa a seleção. */
+    onClear?: () => void;
+    /** Data mínima selecionável. */
+    minDate?: Date;
+    /** Data máxima selecionável. */
+    maxDate?: Date;
+    /**
+     * Dias desabilitados — aceita qualquer `Matcher` do react-day-picker
+     * (Date, DateRange, DateBefore, DateAfter, DayOfWeek, função…).
+     */
+    disabled?: Matcher | Matcher[];
+    /**
+     * Formato de exibição da data.
+     * @example 'dd/mm/yyyy' | 'mm/dd/yyyy'
+     */
+    format?: DateFormat;
+    /**
+     * Locale da interface — aceita os códigos internos do design system.
+     * @default 'pt-br'
+     */
+    locale?: Locale;
+    /** Atributo `aria-label` para o elemento raiz. */
+    'aria-label'?: string;
+    /** Foca automaticamente o primeiro dia selecionado ou hoje. */
+    autoFocus?: boolean;
+    /** Substitui os `classNames` padrão do react-day-picker. */
+    classNames?: Partial<Record<string, string>>;
+}
+type CalendarProps = CalendarBaseProps;
+
+declare const Calendar: ({ selected, currentDate, defaultMonth, startMonth, endMonth, onDaySelect, onDateChange, onClear: _onClear, minDate, maxDate, disabled, format: _format, locale, autoFocus, id, "aria-label": ariaLabel, }: CalendarProps) => react_jsx_runtime.JSX.Element;
+
+/**
+ * Props do componente Callout
+ * @example
+ * ```tsx
+ * <Callout
+ *   type="success"
+ *   title="Sucesso!"
+ *   text="Operação realizada com sucesso"
+ *   icon={<CheckIcon />}
+ * />
+ * ```
+ * @example
+ * ```tsx
+ * <Callout
+ *   type="alert"
+ *   title="Atenção"
+ *   text="Verifique os campos obrigatórios"
+ * />
+ * ```
+ */
+interface CalloutProps extends BaseProps {
+    /** Tipo visual do callout */
+    type?: TextVariant;
+    /** Título principal do callout (texto em destaque) */
+    title?: string | null;
+    /** Texto descritivo do callout */
+    text?: string;
+    /** Ícone a ser exibido no callout */
+    icon?: React$1.ReactNode;
+    /** Props adicionais para o elemento div */
+    [key: string]: any;
+}
+
+declare const Callout: React__default.FC<CalloutProps>;
+
+/**
+ * Props do componente Checkbox
+ * @example
+ * ```tsx
+ * <Checkbox
+ *   label="Aceito os termos"
+ *   checked={accepted}
+ *   onCheckedChange={setAccepted}
+ * />
+ * ```
+ * @example
+ * ```tsx
+ * <Checkbox
+ *   label="Selecionar todos"
+ *   indeterminate={someSelected}
+ *   onCheckedChange={handleSelectAll}
+ *   disabled={isLoading}
+ * />
+ * ```
+ */
+interface CheckboxProps extends BaseProps {
+    /** Label ou conteúdo a ser exibido ao lado do checkbox */
+    label?: React__default.ReactNode;
+    /** Callback executado quando o estado muda: (checked) => void */
+    onCheckedChange?: (checked: boolean) => void;
+    /** Estado inicial (modo não controlado) */
+    defaultChecked?: boolean;
+    /** Estado atual (modo controlado) */
+    checked?: boolean;
+    /** Estado indeterminado (usado em selecionar todos com seleção parcial) */
+    indeterminate?: boolean;
+}
+
+declare const Checkbox: React$1.FC<CheckboxProps>;
+
+/**
+ * Props do componente Chips
+ * @example
+ * ```tsx
+ * <Chips variant="success" leftIcon={<CheckIcon />}>
+ *   Ativo
+ * </Chips>
+ * ```
+ * @example
+ * ```tsx
+ * <Chips
+ *   backgroundColor="color-brand-secondary-medium"
+ *   textColor="color-brand-secondary-dark"
+ * >
+ *   Alerta
+ * </Chips>
+ * ```
+ */
+interface ChipsProps extends BaseProps, Omit<React$1.HTMLAttributes<HTMLDivElement>, 'color'> {
+    /** Variante semântica do chip. Define o preset de cor de fundo. */
+    variant?: Exclude<TextVariant, 'color'>;
+    /** Token CSS para a cor de fundo. Ex: 'color-brand-secondary-medium'. Sobrescreve o variant. */
+    backgroundColor?: string;
+    /** Token CSS para a cor do texto e ícones. Ex: 'color-brand-secondary-dark'. Sobrescreve o variant. */
+    textColor?: string;
+    /** Conteúdo exibido dentro do chip */
+    children: React$1.ReactNode;
+    /** Ícone posicionado à esquerda do texto */
+    leftIcon?: React$1.ReactNode;
+    /** Ícone posicionado à direita do texto */
+    rightIcon?: React$1.ReactNode;
+    /** Estilos inline adicionais */
+    style?: React$1.CSSProperties;
+}
+
+declare const MemoizedChips: React__default.NamedExoticComponent<ChipsProps>;
+
+/**
+ * Props do componente Container
+ * @example
+ * ```tsx
+ * <Container>
+ *   <h1>Conteúdo da página</h1>
+ *   <p>Texto dentro do container</p>
+ * </Container>
+ * ```
+ */
+interface ContainerProps {
+    /** Conteúdo a ser renderizado dentro do container */
+    children: React__default.ReactNode;
+}
+
+declare function Container({ children }: ContainerProps): react_jsx_runtime.JSX.Element;
+
+/**
+ * Props do componente DatePicker
+ * @example
+ * ```tsx
+ * <DatePicker
+ *   label="Data de nascimento"
+ *   value={birthDate}
+ *   onChange={setBirthDate}
+ *   locale="pt-br"
+ * />
+ * ```
+ * @example
+ * ```tsx
+ * <DatePicker
+ *   label="Data de início"
+ *   required
+ *   helperText="Selecione a data de início do projeto"
+ *   minDate={new Date()}
+ *   calendarSide="right"
+ *   error={errorMessage}
+ * />
+ * ```
+ */
+interface DatePickerProps extends BaseProps {
+    /** Locale para formatação da data */
+    locale?: Locale;
+    /** Posição do calendário em relação ao campo */
+    calendarSide?: Side;
+    /** Alinhamento do calendário em relação ao campo */
+    calendarAlign?: Exclude<Align, 'center'>;
+    /** Texto de ajuda exibido abaixo do campo */
+    helperText?: string;
+    /** Define se o campo é obrigatório */
+    required?: boolean;
+    /** Label do campo de data */
+    label?: string;
+    /** Valor controlado da data */
+    value?: Date | null;
+    /** Valor inicial para modo não controlado */
+    defaultValue?: Date | null;
+    /** Callback executado quando a data muda: (date) => void */
+    onChange?: (date: Date | null) => void;
+    /** Mensagem de erro a ser exibida */
+    error?: string;
+    /** Data mínima selecionável */
+    minDate?: Date;
+    /** Data máxima selecionável */
+    maxDate?: Date;
+    /** ID para testes automatizados */
+    'data-testid'?: string;
+}
+
+declare const _default$2: React__default.NamedExoticComponent<DatePickerProps>;
+
+/**
+ * Props do componente Dialog
+ * @example
+ * <Dialog
+ *   title="Confirmar ação"
+ *   bodyContent="Tem certeza que deseja continuar?"
+ *   textPrimaryAction="Confirmar"
+ *   textSecondaryAction="Cancelar"
+ * />
+ */
+interface DialogProps extends BaseProps, React.HTMLAttributes<HTMLDivElement> {
+    show?: boolean;
+    /** Título exibido no cabeçalho do diálogo */
+    title?: string;
+    /** Texto ou conteúdo do corpo do diálogo */
+    bodyContent?: ReactNode;
+    /** Texto do botão de ação primária */
+    textPrimaryAction?: string;
+    /** Texto do botão de ação secundária */
+    textSecondaryAction?: string;
+    /** Função chamada ao executar a ação primária */
+    onPrimaryAction?: () => void;
+    /** Função chamada ao executar a ação secundária */
+    onSecondaryAction?: () => void;
+}
+
+declare const Dialog: React$1.FC<DialogProps>;
+
+/**
+ * Props do componente Drawer
+ * @example
+ * ```tsx
+ * <Drawer
+ *   isOpen={isDrawerOpen}
+ *   onClose={handleClose}
+ *   title="Menu"
+ * >
+ *   <nav>
+ *     <a href="/home">Home</a>
+ *     <a href="/about">Sobre</a>
+ *   </nav>
+ * </Drawer>
+ * ```
+ * @example
+ * ```tsx
+ * <Drawer
+ *   isOpen={showDrawer}
+ *   onClose={() => setShowDrawer(false)}
+ *   title="Configurações"
+ *   customWidth="400px"
+ *   closeOnOverlayClick={true}
+ *   closeOnEscape={true}
+ * >
+ *   <Settings />
+ * </Drawer>
+ * ```
+ */
+interface DrawerProps extends BaseProps {
+    /** Conteúdo a ser exibido dentro do drawer */
+    children?: ReactNode;
+    /** Conteúdo customizado do cabeçalho */
+    headerContent?: ReactNode;
+    /** Largura customizada do drawer (ex: '400px', '50%') */
+    customWidth?: string;
+    /** Callback executado ao fechar o drawer: () => void */
+    onClose: () => void;
+    /** Título exibido no cabeçalho do drawer */
+    title?: string;
+    /** Define se o drawer está aberto */
+    isOpen: boolean;
+    /** Callback executado ao abrir o drawer: () => void */
+    onOpen?: () => void;
+    /** Callback executado ao clicar no overlay: () => void */
+    onOverlayClick?: () => void;
+    /** Define se o drawer fecha ao clicar no overlay */
+    closeOnOverlayClick?: boolean;
+    /** Define se o drawer fecha ao pressionar ESC */
+    closeOnEscape?: boolean;
+}
+
+declare const Drawer: React__default.FC<DrawerProps>;
+
+interface FilterItem$1 {
+    id?: string;
+    text: string;
+    subText?: string;
+    icon?: ReactNode;
+    disabled?: boolean;
+}
+type FilterType = 'text' | 'checkbox' | 'icon' | 'calendar';
+/**
+ * Props do componente Filter
+ * @example
+ * ```tsx
+ * <Filter
+ *   items={filterItems}
+ *   type="checkbox"
+ *   placeholder="Filtrar por categoria"
+ *   onApplyFilter={(ids) => handleFilter(ids)}
+ *   buttonText="Filtros"
+ * />
+ * ```
+ * @example
+ * ```tsx
+ * <Filter
+ *   type="calendar"
+ *   selectedDate={selectedDate}
+ *   onDateSelect={handleDateSelect}
+ *   minDate={new Date('2024-01-01')}
+ *   locale="pt-br"
+ *   icon={<CalendarIcon />}
+ * />
+ * ```
+ */
+interface FilterProps extends BaseProps {
+    /** Array de itens para filtros do tipo dropdown */
+    items?: FilterItem$1[];
+    /** Tipo do filtro (dropdown ou calendário) */
+    type?: FilterType;
+    /** IDs dos itens selecionados */
+    selectedIds?: string[];
+    /** Callback executado ao aplicar filtro: (selectedIds) => void */
+    onApplyFilter?: (selectedIds: string[]) => void;
+    /** Placeholder do campo de busca */
+    placeholder?: string;
+    /** Habilita campo de busca no dropdown */
+    enableSearch?: boolean;
+    /** Texto ou conteúdo do botão de filtro */
+    buttonText?: string | ReactNode;
+    /** Ícone do botão de filtro */
+    icon?: ReactElement;
+    /** Variante visual do botão */
+    variant?: Variant;
+    /** Callback executado ao abrir o filtro: () => void */
+    onOpen?: () => void;
+    /** Callback executado ao fechar o filtro: () => void */
+    onClose?: () => void;
+    /** Posição do popover em relação ao botão */
+    side?: Side;
+    /** Alinhamento do popover em relação ao botão */
+    align?: Exclude<Align, 'center'>;
+    /** Data selecionada (para tipo calendar) */
+    selectedDate?: Date | null;
+    /** Callback executado ao selecionar data: (date) => void */
+    onDateSelect?: (date: Date) => void;
+    /** Callback executado ao limpar data: () => void */
+    onClearDate?: () => void;
+    /** Data mínima selecionável (para tipo calendar) */
+    minDate?: Date;
+    /** Data máxima selecionável (para tipo calendar) */
+    maxDate?: Date;
+    /** Locale do calendário */
+    locale?: Locale;
+}
+
+declare const Filter: React__default.FC<FilterProps>;
+
+/** Variantes disponíveis para o ListItem */
+type ListItemVariant = 'text' | 'checkbox' | 'radio' | 'icon';
+/**
+ * Props do componente ListItem
+ * @example
+ * ```tsx
+ * <ListItem
+ *   variant="text"
+ *   text="Item da lista"
+ *   subText="Descrição do item"
+ *   onClick={handleClick}
+ * />
+ * ```
+ * @example
+ * ```tsx
+ * <ListItem
+ *   variant="checkbox"
+ *   text="Aceitar termos"
+ *   checked={isChecked}
+ *   onChange={setIsChecked}
+ *   disabled={false}
+ * />
+ * ```
+ */
+interface ListItemProps extends BaseProps {
+    /** Variante do item da lista */
+    variant?: ListItemVariant;
+    /** Texto principal do item */
+    text?: string;
+    /** Nome do input (para variantes checkbox/radio) */
+    name?: string;
+    /** Texto secundário/descrição do item */
+    subText?: string;
+    /** Estado de checked (para variantes checkbox/radio) */
+    checked?: boolean;
+    /** Estado de selecionado (para variantes text/icon) */
+    selected?: boolean;
+    /** Callback executado ao clicar no item: (event) => void */
+    onClick?: (event: React$1.MouseEvent<HTMLElement> | React$1.KeyboardEvent<HTMLElement>) => void;
+    /** Callback executado quando o estado muda: (checked) => void */
+    onChange?: (checked: boolean) => void;
+    /** Ícone do item (para variante icon) */
+    icon?: React$1.ReactNode;
+    /** Valor do input (para variantes checkbox/radio) */
+    value?: string;
+    /** Define se deve mostrar o subtexto */
+    showSubText?: boolean;
+    /** Estado de hover */
+    hovered?: boolean;
+}
+
+declare const ListItem: React__default.FC<ListItemProps>;
+
+/**
+ * Representa um item do menu (suporta subitens aninhados)
+ */
+interface MenuItemProps {
+    /** ID único do item */
+    id?: string;
+    /** Texto principal do item */
+    text?: string;
+    /** Texto secundário/descrição do item */
+    subText?: string;
+    /** Estado desabilitado do item */
+    disabled?: boolean;
+    /** Ícone do item */
+    icon?: React$1.ReactNode;
+    /** Subitens do menu (para menus aninhados) */
+    children?: MenuItemProps[];
+    /** Valor do item */
+    value?: string;
+}
+/**
+ * Props do componente Menu
+ * @example
+ * ```tsx
+ * <Menu
+ *   items={[
+ *     { id: '1', text: 'Perfil', icon: <UserIcon /> },
+ *     { id: '2', text: 'Configurações', icon: <SettingsIcon /> }
+ *   ]}
+ *   onItemSelect={(item) => handleSelect(item)}
+ * >
+ *   <Button>Menu</Button>
+ * </Menu>
+ * ```
+ * @example
+ * ```tsx
+ * <Menu
+ *   items={menuItems}
+ *   type="icon"
+ *   search={true}
+ *   enableInfiniteScroll={true}
+ *   onScrollEnd={loadMore}
+ *   maxHeight="400px"
+ *   align="end"
+ * />
+ * ```
+ */
+interface MenuProps extends BaseProps {
+    /** Array de itens do menu */
+    items: MenuItemProps[];
+    /** Elemento trigger customizado para abrir o menu */
+    children?: ReactElement;
+    /** Tipo de visualização do menu */
+    type?: 'text' | 'icon';
+    /** Callback executado quando um item é selecionado: (item) => void */
+    onItemSelect?: (items: MenuItemProps) => void;
+    /** Array de itens selecionados */
+    selectedItems?: MenuItemProps[];
+    /** Habilita campo de busca */
+    search?: boolean;
+    /** Alinhamento do menu */
+    align?: 'start' | 'end' | 'center';
+    /** Altura máxima do menu */
+    maxHeight?: number | string;
+    /** Habilita scroll infinito */
+    enableInfiniteScroll?: boolean;
+    /** Callback executado ao chegar ao final do scroll: () => void */
+    onScrollEnd?: () => void;
+    /** Estado de carregamento de mais itens */
+    isLoadingMore?: boolean;
+    /** Habilita busca via API */
+    enableApiSearch?: boolean;
+    /** Callback executado na busca via API: (searchTerm) => void */
+    onApiSearch?: (searchTerm: string) => void;
+    /** Callback executado quando o menu abre/fecha: (open) => void */
+    onOpenChange?: (open: boolean) => void;
+}
+
+declare const Menu: React__default.FC<MenuProps>;
+
+/**
+ * Props do componente Modal
+ * @example
+ * ```tsx
+ * <Modal
+ *   isOpen={isModalOpen}
+ *   onClose={() => setIsModalOpen(false)}
+ *   title="Título do Modal"
+ * >
+ *   <p>Conteúdo do modal</p>
+ * </Modal>
+ * ```
+ * @example
+ * ```tsx
+ * <Modal
+ *   isOpen={showModal}
+ *   onClose={handleClose}
+ *   title="Confirmar ação"
+ *   closeOnOverlayClick={false}
+ * >
+ *   <MyForm />
+ * </Modal>
+ * ```
+ */
+interface ModalProps extends BaseProps {
+    /** Define se o modal está aberto */
+    isOpen: boolean;
+    /** Callback executado ao fechar o modal */
+    onClose: () => void;
+    /** Título exibido no cabeçalho do modal */
+    title?: string;
+    /** Conteúdo a ser exibido dentro do modal */
+    children?: ReactNode;
+    /** Conteúdo customizado no cabeçalho, exibido ao lado do título */
+    headerContent?: ReactNode;
+    /** Define se o modal fecha ao clicar no overlay (padrão: true) */
+    closeOnOverlayClick?: boolean;
+    /** Conteúdo do rodapé do modal */
+    footer?: ReactNode;
+    /** Largura customizada do modal (ex: '500px', '80%') */
+    customWidth?: string;
+    /** Define se o modal ocupa toda a tela. Tem prioridade sobre customWidth */
+    fullscreen?: boolean;
+}
+
+declare const Modal: React$1.FC<ModalProps>;
+
+interface PopoverProps {
+    trigger: React.ReactNode;
+    content: React.ReactNode;
+    align?: Align;
+    side?: Side;
+    /** Distância em pixels entre o conteúdo e o trigger */
+    sideOffset?: number;
+    /** Controla o estado de abertura em modo controlado */
+    open?: boolean;
+    /** Callback chamado quando o estado de abertura muda */
+    onOpenChange?: (open: boolean) => void;
+    /**
+    * Quando `true`, o trigger atua como âncora de posicionamento e o popover
+    * é aberto/fechado exclusivamente via `open`/`onOpenChange` (modo DatePicker).
+    * Quando `false` (padrão), o trigger continua abrindo/fechando o popover
+    * normalmente, mas o estado pode ser sincronizado via `open`/`onOpenChange`
+    * (modo Filter).
+    */
+    asAnchor?: boolean;
+    /** Callback chamado quando o foco automático é ativado ao abrir o popover */
+    onOpenAutoFocus?: (event: Event) => void;
+    /** Callback chamado quando o foco automático é ativado ao fechar o popover */
+    onCloseAutoFocus?: (event: Event) => void;
+    /** Quando `true`, exibe uma seta apontando para o trigger */
+    showArrow?: boolean;
+}
+
+declare const Popover: React$1.FC<PopoverProps>;
+
+/**
+ * Props do componente Quantity
+ * @example
+ * ```tsx
+ * <Quantity
+ *   value={quantity}
+ *   onChange={setQuantity}
+ *   size="lg"
+ * />
+ * ```
+ * @example
+ * ```tsx
+ * <Quantity
+ *   value={1}
+ *   decimal={true}
+ *   decimalPlaces={2}
+ *   step={0.5}
+ *   disabled={false}
+ * />
+ * ```
+ */
+interface QuantityProps extends BaseProps {
+    /** Valor do componente */
+    value?: number;
+    /** Callback executado quando o valor muda: (value) => void */
+    onChange?: (value: number) => void;
+    /** Habilita entrada de valores decimais */
+    decimal?: boolean;
+    /** Tamanho do componente */
+    size?: Size;
+    /** Número de casas decimais permitidas */
+    decimalPlaces?: number;
+    /** Incremento/decremento ao clicar nos botões */
+    valueIncrement?: number;
+    /**
+     * Tamanho fixo do input, medido em caracteres (unidade CSS `ch`).
+     * O valor define quantos caracteres cabem visivelmente no campo sem necessidade de rolar.
+     * Exemplo: `inputSize={4}` reserva espaço para 4 caracteres ("9999").
+     * Se omitido, o tamanho é ajustado automaticamente conforme o conteúdo digitado.
+     */
+    inputSize?: number;
+    /** Valor mínimo permitido */
+    minValue?: number;
+    /** Valor máximo permitido */
+    maxValue?: number;
+    /** Aria label for the decrement button. Default: 'Decrease quantity' */
+    decrementAriaLabel?: string;
+    /** Aria label for the increment button. Default: 'Increase quantity' */
+    incrementAriaLabel?: string;
+    /** Aria label for the quantity input. Default: 'Quantity' */
+    inputAriaLabel?: string;
+}
+
+declare const memorizedQuantity: React__default.NamedExoticComponent<QuantityProps>;
+
+/**
+ * Props de um item individual de rádio
+ */
+interface RadioProps {
+    /** ID único do elemento */
+    id?: string | number;
+    /** Valor do radio button */
+    value: string;
+    /** Label exibida ao lado do radio button */
+    label: string;
+    /** Estado desabilitado do item */
+    disabled?: boolean;
+}
+/**
+ * Props do componente RadioGroup
+ * @example
+ * ```tsx
+ * <RadioGroup
+ *   items={[
+ *     { value: 'option1', label: 'Opção 1' },
+ *     { value: 'option2', label: 'Opção 2' }
+ *   ]}
+ *   onValueChange={(value) => setSelected(value)}
+ *   defaultValue="option1"
+ * />
+ * ```
+ * @example
+ * ```tsx
+ * <RadioGroup
+ *   items={options}
+ *   onValueChange={handleChange}
+ *   name="preference"
+ *   orientation="horizontal"
+ *   ariaLabel="Selecione sua preferência"
+ * />
+ * ```
+ */
+interface RadioGroupProps extends BaseProps {
+    /** Array de itens de rádio */
+    items: RadioProps[];
+    /** Callback executado quando o valor muda: (value) => void */
+    onValueChange?: (value: string) => void;
+    /** Valor inicial selecionado */
+    defaultValue?: string;
+    /** Nome do grupo de radio buttons */
+    name?: string;
+    /** Label acessível para leitores de tela */
+    ariaLabel?: string;
+    /** Orientação do layout dos radio buttons */
+    orientation?: "horizontal" | "vertical";
+}
+
+declare const Radio: React__default.FC<RadioGroupProps>;
+
+/**
+ * Props do componente Search
+ * @example
+ * ```tsx
+ * <Search
+ *   placeholder="Buscar..."
+ *   value={searchTerm}
+ *   onChange={(e) => setSearchTerm(e.target.value)}
+ *   onClear={() => setSearchTerm('')}
+ * />
+ * ```
+ * @example
+ * ```tsx
+ * <Search
+ *   placeholder="Pesquisar produtos"
+ *   disabled={isLoading}
+ *   onKeyDown={(e) => e.key === 'Enter' && handleSearch()}
+ *   onFocus={handleFocus}
+ * />
+ * ```
+ */
+type NativeInputProps = Omit<ComponentPropsWithoutRef<'input'>, 'value' | 'defaultValue' | 'onChange' | 'onClick' | 'onMouseDown'>;
+interface SearchProps extends BaseProps, NativeInputProps {
+    /** Placeholder do campo de busca */
+    placeholder?: string;
+    /** Valor controlado do campo */
+    value?: string;
+    /** Callback executado quando o valor muda: (e) => void */
+    onChange?: (e: React$1.ChangeEvent<HTMLInputElement>) => void;
+    /** Callback executado ao pressionar tecla: (e) => void */
+    onKeyDown?: (e: React$1.KeyboardEvent<HTMLInputElement>) => void;
+    /** Callback executado ao focar no campo: (e) => void */
+    onFocus?: (e: React$1.FocusEvent<HTMLInputElement>) => void;
+    /** Callback executado ao desfocar do campo: (e) => void */
+    onBlur?: (e: React$1.FocusEvent<HTMLInputElement>) => void;
+    /** Callback executado ao limpar o campo: () => void */
+    onClear?: () => void;
+    /** Callback executado ao clicar no componente: (e) => void */
+    onClick?: (e: React$1.MouseEvent<HTMLDivElement>) => void;
+    /** Callback executado ao pressionar mouse no componente: (e) => void */
+    onMouseDown?: (e: React$1.MouseEvent<HTMLDivElement>) => void;
+    /** ID para testes automatizados */
+    'data-testid'?: string;
+}
+
+declare const Search: React__default.ForwardRefExoticComponent<SearchProps & React__default.RefAttributes<HTMLInputElement>>;
+
+/**
+ * Representa um item do select
+ */
+interface SelectItemProps extends BaseProps {
+    /** Texto principal do item */
+    text: ReactNode;
+    /** Subtítulo ou descrição do item */
+    subTitle?: ReactNode;
+    /** Ícone do item */
+    icon?: ReactNode;
+    /** Valor do item */
+    value: string;
+    /** Define se o item está selecionado */
+    selected?: boolean;
+    /** Subitens do select (para selects aninhados) */
+    children?: SelectItemProps[];
+}
+/** Variantes disponíveis para o Select */
+type SelectVariant = 'text' | 'icon' | 'checkbox';
+/**
+ * Props do componente Select
+ * @example
+ * ```tsx
+ * <Select
+ *   items={[
+ *     { value: '1', text: 'Opção 1' },
+ *     { value: '2', text: 'Opção 2' }
+ *   ]}
+ *   variant="text"
+ *   placeholder="Selecione uma opção"
+ *   onValueChange={(value) => console.log(value)}
+ * />
+ * ```
+ * @example
+ * ```tsx
+ * <Select
+ *   items={options}
+ *   variant="checkbox"
+ *   multiple={true}
+ *   search={true}
+ *   label="Selecione múltiplas opções"
+ *   helperText="Você pode selecionar mais de uma"
+ *   required={true}
+ * />
+ * ```
+ */
+interface SelectProps extends BaseProps {
+    /** Array de itens do select */
+    items: SelectItemProps[];
+    /** Callback executado quando o valor muda: (value) => void */
+    onValueChange?: (value: string | string[]) => void;
+    /** Callback executado quando o select abre/fecha: (open) => void */
+    onOpenChange?: (open: boolean) => void;
+    /** Variante visual do select */
+    variant: SelectVariant;
+    /** Define se o campo é obrigatório */
+    required?: boolean;
+    /** Valor(es) selecionado(s) */
+    value?: string | string[];
+    /** Habilita seleção múltipla */
+    multiple?: boolean;
+    /** Placeholder do campo */
+    placeholder?: string;
+    /** Habilita campo de busca */
+    search?: boolean;
+    /** Label do campo */
+    label?: string;
+    /** Texto de ajuda exibido abaixo do campo */
+    helperText?: string;
+    /** Largura máxima do select */
+    maxWidth?: number;
+    /** Mensagem de erro a ser exibida */
+    errorMessage?: string;
+    /** Label acessível para leitores de tela */
+    'aria-label'?: string;
+    /** ID para testes automatizados */
+    'data-testid'?: string;
+    /** Habilita tooltip */
+    tooltip?: boolean;
+    /** Texto do tooltip */
+    tooltipText?: string;
+    /** Lado onde o dropdown abre */
+    side?: Side;
+    /** Alinhamento do dropdown */
+    align?: Align;
+    /** Habilita scroll infinito */
+    enableInfiniteScroll?: boolean;
+    /** Callback executado ao chegar ao final do scroll: () => void */
+    onScrollEnd?: () => void;
+    /** Estado de carregamento de mais itens */
+    isLoadingMore?: boolean;
+    /** Habilita busca via API */
+    enableApiSearch?: boolean;
+    /** Callback executado na busca via API: (term) => void */
+    onApiSearch?: (term: string) => void;
+    /** Estado de busca em andamento */
+    isSearching?: boolean;
+}
+
+declare const Select: React__default.FC<SelectProps>;
+
+/**
+ * Tipo base para dados da tabela. Use `<Table<SeuTipo>>` para type-safety completo.
+ * @example <Table<User> dataSource={users} />
+ */
+type TableRowData = Record<string, any>;
+/** Tipos de coluna suportados */
+type TableColumnType = 'text' | 'datetime' | 'custom';
+/** Opções de alinhamento de coluna */
+type TableAlign = 'left' | 'center' | 'right';
+/**
+ * Configuração de coluna da tabela
+ * @typeParam T - Tipo dos dados da linha
+ */
+interface TableColumn<T = TableRowData> {
+    /** Chave única identificadora da coluna */
+    key: string;
+    /** Conteúdo do cabeçalho da coluna */
+    label: ReactNode;
+    /** Tipo de dados da coluna */
+    type?: TableColumnType;
+    /** Formato de exibição (ex: 'dd/MM/yyyy' para datetime) */
+    format?: string;
+    /** Função customizada para renderizar o conteúdo da célula */
+    render?: (row: T, index: number) => ReactNode;
+    /** Alinhamento do conteúdo */
+    align?: TableAlign;
+    /** Estilos CSS customizados */
+    style?: CSSProperties;
+}
+/**
+ * Props do componente Table. Use genérico para autocomplete: `<Table<User>>`
+ * @typeParam T - Tipo dos dados da linha
+ */
+interface TableProps<T = TableRowData> extends BaseProps {
+    /** Configuração das colunas */
+    columns: TableColumn<T>[];
+    /** Array de dados a serem exibidos */
+    dataSource: T[];
+    /** Estado de carregamento */
+    loading?: boolean;
+    /** Configuração de seleção de linhas */
+    rowSelection?: {
+        /** Keys das linhas selecionadas (modo controlado) */
+        selectedRowKeys?: (string | number)[];
+        /** Callback quando seleção muda: (keys, rows) => void */
+        onChange?: (keys: (string | number)[], rows: T[]) => void;
+        /** Customiza props dos checkboxes: (row, index) => { disabled? } */
+        getCheckboxProps?: (row: T, index: number) => {
+            disabled?: boolean;
+        };
+        /** Desabilita o checkbox "selecionar todos" */
+        disableSelectAll?: boolean;
+    };
+    /** Configurações de localização */
+    locale?: {
+        /** Texto quando não há dados */
+        emptyText?: ReactNode;
+    };
+    /** Eventos de linha: (row, index) => { onClick?, onDoubleClick?, className? } */
+    onRow?: (row: T, index: number) => {
+        /** Clique simples na linha */
+        onClick?: () => void;
+        /** Clique duplo na linha */
+        onDoubleClick?: () => void;
+        /** Classe CSS da linha */
+        className?: string;
+    };
+}
+
+declare const Table: <T extends TableRowData = TableRowData>({ columns, dataSource, className, loading, rowSelection, locale, onRow, ...rest }: TableProps<T>) => react_jsx_runtime.JSX.Element | null;
+
+interface BaseFilterItem {
+    id?: string;
+    buttonText: string | React__default.ReactNode;
+    icon?: React__default.ReactElement;
+    side?: Side;
+    align?: Exclude<Align, 'center'>;
+    disabled?: boolean;
+    onToggle?: (isOpen: boolean) => void;
+    tooltip?: string;
+}
+interface CheckboxFilterItem extends BaseFilterItem {
+    type: 'checkbox' | 'text' | 'icon';
+    items: FilterItem$1[];
+    selectedIds?: string[];
+    onSelectionChange?: (selectedIds: string[]) => void;
+    placeholder?: string;
+    enableSearch?: boolean;
+}
+interface CalendarFilterItem extends BaseFilterItem {
+    type: 'calendar';
+    selectedDate?: Date | null;
+    onDateSelect?: (date: Date) => void;
+    onClear?: () => void;
+    minDate?: Date;
+    maxDate?: Date;
+    locale?: string;
+    placeholder?: string;
+}
+type FilterItem = CheckboxFilterItem | CalendarFilterItem;
+interface TableHeaderProps extends React__default.HTMLAttributes<HTMLDivElement> {
+    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 extends React__default.HTMLAttributes<HTMLDivElement> {
+    currentPage: number;
+    totalItems: number;
+    itemsPerPage: number;
+    onPageChange: (page: number) => void;
+    onItemsPerPageChange: (itemsPerPage: number) => void;
+    pageSizeOptions?: number[];
+    disabled?: boolean;
+    className?: string;
+}
+declare const TablePagination: React__default.FC<TablePaginationProps>;
+
+/**
+ * Props do componente TextArea
+ * @example
+ * ```tsx
+ * <TextArea
+ *   label="Descrição"
+ *   value={description}
+ *   onChange={setDescription}
+ *   placeholder="Digite uma descrição"
+ * />
+ * ```
+ * @example
+ * ```tsx
+ * <TextArea
+ *   label="Comentário"
+ *   required
+ *   maxLength={500}
+ *   showCharCount
+ *   helperText="Máximo de 500 caracteres"
+ *   errorMessage={error}
+ * />
+ * ```
+ */
+interface TextAreaProps extends Omit<React__default.TextareaHTMLAttributes<HTMLTextAreaElement>, 'onChange' | 'value'> {
+    /** Valor controlado do campo */
+    value?: string;
+    /** Callback executado quando o valor muda: (value) => void */
+    onChange?: (value: string) => void;
+    /** Label do campo */
+    label?: string;
+    /** Texto de ajuda exibido abaixo do campo */
+    helperText?: string;
+    /** Habilita tooltip */
+    tooltip?: boolean;
+    /** Texto do tooltip */
+    tooltipText?: string;
+    /** Lado onde o tooltip aparece */
+    side?: Side;
+    /** Alinhamento do tooltip */
+    align?: Align;
+    /**
+     * Mensagem de erro exibida no campo.
+     * Usada tanto pela validação interna (required, etc.)
+     * quanto pelo controle externo via formulários (react-hook-form, formik, etc.)
+     */
+    errorMessage?: string;
+    /** Sinaliza erro externo para controle via formulários (react-hook-form, formik, etc.) */
+    error?: boolean;
+    /** Controla o redimensionamento do textarea */
+    resize?: 'none' | 'vertical' | 'both';
+    /** Exibe contador de caracteres (requer maxLength) */
+    showCharCount?: boolean;
+    height?: number;
+}
+
+declare const _default$1: React__default.NamedExoticComponent<TextAreaProps & React__default.RefAttributes<HTMLTextAreaElement>>;
+
+/** Tipos de input suportados pelo TextField */
+type TextFieldType = 'text' | 'email' | 'password' | 'number' | 'tel' | 'url';
+/**
+ * Props do componente TextField
+ * @example
+ * ```tsx
+ * <TextField
+ *   label="Email"
+ *   type="email"
+ *   value={email}
+ *   onChange={setEmail}
+ *   placeholder="Digite seu email"
+ * />
+ * ```
+ * @example
+ * ```tsx
+ * <TextField
+ *   label="Senha"
+ *   type="password"
+ *   required
+ *   helperText="Mínimo 8 caracteres"
+ *   errorMessage={error}
+ *   tooltip={true}
+ *   tooltipText="Deve conter letras e números"
+ *   icon={<LockIcon />}
+ * />
+ * ```
+ */
+interface TextFieldProps extends Omit<React__default.InputHTMLAttributes<HTMLInputElement>, 'onChange' | 'value' | 'type'> {
+    /** Valor controlado do campo */
+    value?: string | number;
+    /** Callback executado quando o valor muda: (value) => void */
+    onChange?: (value: string) => void;
+    /** Label do campo */
+    label?: string;
+    /** Tipo do input */
+    type?: TextFieldType;
+    /** Texto de ajuda exibido abaixo do campo */
+    helperText?: string;
+    /** Habilita tooltip */
+    tooltip?: boolean;
+    /** Texto do tooltip */
+    tooltipText?: string;
+    /** Lado onde o tooltip aparece */
+    side?: Side;
+    /** Alinhamento do tooltip */
+    align?: Align;
+    /**
+     * Mensagem de erro exibida no campo.
+     * Usada tanto pela validação interna (required, formato, etc.)
+     * quanto pelo controle externo via formulários (react-hook-form, formik, etc.)
+     */
+    errorMessage?: string;
+    /** Sinaliza erro externo para controle via formulários (react-hook-form, formik, etc.) */
+    error?: boolean;
+    /** Ícone a ser exibido no campo */
+    icon?: React__default.ReactNode;
+    /** Mantém o ícone visível mesmo quando o campo tem valor */
+    persistIcon?: boolean;
+}
+
+declare const _default: React__default.NamedExoticComponent<TextFieldProps & React__default.RefAttributes<HTMLInputElement>>;
+
+/**
+ * Props do componente individual de notificação `Toast`.
+ *
+ * Estende {@link BaseProps} e os atributos nativos do `Toast.Root` do Radix UI,
+ * excluindo as propriedades controladas internamente (`open`, `onOpenChange`,
+ * `duration`, `className`).
+ *
+ * @example
+ * ```tsx
+ * showToast({
+ *   title: 'Sucesso!',
+ *   iconType: 'Success',
+ *   duration: 3000,
+ * });
+ * ```
+ */
+interface ToastProps extends BaseProps, Omit<React$1.ComponentPropsWithoutRef<typeof Toast$1.Root>, 'open' | 'onOpenChange' | 'duration' | 'className'> {
+    /**
+     * Título principal exibido no toast.
+     */
+    title: string;
+    /**
+     * Define se o toast fecha automaticamente após o tempo definido em `duration`.
+     * @default true
+     */
+    automaticClose?: boolean;
+    /**
+     * Tempo em milissegundos até o toast fechar automaticamente.
+     * Só tem efeito quando `automaticClose` é `true`.
+     * @default 5000
+     */
+    duration?: number;
+    /**
+     * Ícone customizado exibido no toast.
+     * Quando fornecido, substitui o ícone gerado automaticamente por `iconType`.
+     */
+    icon?: React$1.ReactNode;
+    /**
+     * Ícone exibido no botão de fechar o toast.
+     * @default <Dismiss16Filled />
+     */
+    iconClosed?: React$1.ReactNode;
+    /**
+     * Tipo do ícone exibido automaticamente no toast.
+     *
+     * - `'Info'` → ícone informativo (`Info20Filled`)
+     * - `'Success'` → ícone de sucesso (`CheckmarkCircle20Filled`)
+     * - `'Alert'` → ícone de alerta/erro (`Warning20Filled`)
+     *
+     * Ignorado quando a prop `icon` for fornecida.
+     * @default 'Info'
+     */
+    iconType?: 'Info' | 'Success' | 'Alert';
+}
+
+/**
+ * Componente individual de notificação Toast.
+ *
+ * Consome o contexto do `ToastProvider` para gerenciar seu próprio ciclo de vida.
+ * Cada instância recebe um `id` único gerado pelo provider e o utiliza para
+ * se remover da fila ao ser fechada.
+ *
+ * Construído sobre `Toast.Root` do **Radix UI**, com suporte completo a
+ * acessibilidade (ARIA) e gesto de swipe para a esquerda.
+ *
+ * @remarks
+ * Este componente não deve ser usado diretamente. Utilize o hook `useToast`
+ * para exibir toasts programaticamente.
+ *
+ * @example
+ * ```tsx
+ * // Uso indireto via hook (recomendado)
+ * const { showToast } = useToast();
+ *
+ * showToast({
+ *   title: 'Item salvo',
+ *   iconType: 'Success',
+ *   duration: 3000,
+ * });
+ * ```
+ *
+ * @param props - {@link ToastProps} combinadas com o `id` único do toast
+ */
+declare const Toast: React$1.FC<ToastProps & {
+    id: string;
+}>;
+
+/**
+ * Provider que gerencia o estado global dos toasts na aplicação.
+ *
+ * Deve envolver toda a árvore de componentes que precisará exibir toasts.
+ * Disponibiliza o contexto com `showToast` e `dismissToast` para todos os
+ * componentes filhos via `useToast()`.
+ *
+ * @remarks
+ * O `ToastContainer` deve ser renderizado **dentro** do `ToastProvider`.
+ *
+ * @example
+ * ```tsx
+ * // App.tsx ou layout principal
+ * import { ToastProvider, ToastContainer } from '@giro-ds/react';
+ *
+ * function App() {
+ *   return (
+ *     <ToastProvider maxToasts={5}>
+ *       <Routes />
+ *       <ToastContainer />
+ *     </ToastProvider>
+ *   );
+ * }
+ * ```
+ *
+ * @param children - Árvore de componentes filhos da aplicação.
+ * @param maxToasts - Número máximo de toasts exibidos simultaneamente.
+ *   Quando o limite é excedido, o toast mais antigo é removido automaticamente.
+ *   @default 5
+ */
+declare const ToastProvider: React$1.FC<{
+    children: React$1.ReactNode;
+    maxToasts?: number;
+}>;
+
+/**
+ * Componente responsável por renderizar todos os toasts ativos na tela.
+ *
+ * Lê a lista de toasts do contexto fornecido pelo `ToastProvider` e os
+ * renderiza individualmente. Configura o `Toast.Provider` do Radix UI com
+ * direção de swipe para a esquerda.
+ *
+ * @remarks
+ * - Deve ser posicionado **dentro** do `ToastProvider`.
+ * - Geralmente é colocado próximo à raiz da aplicação, após os demais filhos.
+ * - Toasts sem `id` são ignorados automaticamente.
+ *
+ * @example
+ * ```tsx
+ * <ToastProvider>
+ *   <App />
+ *   <ToastContainer /> {/* Deve estar aqui *\/}
+ * </ToastProvider>
+ * ```
+ */
+declare const ToastContainer: React$1.FC;
+
+/**
+ * Hook para exibir e remover toasts na aplicação.
+ *
+ * O componente que usa este hook deve ser filho de um `ToastProvider`.
+ *
+ * @throws {Error} Lança um erro se utilizado fora de um `ToastProvider`:
+ * *"useToastContext deve ser usado dentro de ToastProvider"*
+ *
+ * @returns Objeto com os métodos `showToast` e `dismissToast`.
+ *
+ * @example
+ * ```tsx
+ * import { useToast } from '@giro-ds/react';
+ *
+ * function MeuComponente() {
+ *   const { showToast } = useToast();
+ *
+ *   const handleSalvar = async () => {
+ *     try {
+ *       await salvarDados();
+ *       showToast({ title: 'Sucesso!', iconType: 'Success', duration: 3000 });
+ *     } catch (err) {
+ *       showToast({ title: 'Erro ao salvar', iconType: 'Alert', automaticClose: false });
+ *     }
+ *   };
+ *
+ *   return <button onClick={handleSalvar}>Salvar</button>;
+ * }
+ * ```
+ */
+declare const useToast: () => {
+    showToast: (toast: Omit<ToastProps, "id">) => void;
+    dismissToast: (id: string) => void;
+};
+
+interface TooltipProps extends BaseProps {
+    text: React__default.ReactNode;
+    side?: Side;
+    align?: Align;
+    sideOffset?: number;
+    /** Deslocamento em pixels no eixo de alinhamento */
+    alignOffset?: number;
+    /** Largura máxima do tooltip em pixels */
+    maxWidth?: number;
+    /** Elemento que dispara o tooltip ao hover */
+    children: React__default.ReactNode;
+}
+
+declare const Tooltip: React__default.FC<TooltipProps>;
+
+/**
+ * Props do componente Switch
+ * @example
+ * ```tsx
+ * <Switch
+ *   checked={isEnabled}
+ *   onCheckedChange={setIsEnabled}
+ * />
+ * ```
+ * @example
+ * ```tsx
+ * <Switch
+ *   defaultChecked={true}
+ *   disabled={isLoading}
+ *   onCheckedChange={(checked) => console.log(checked)}
+ *   name="notifications"
+ * />
+ * ```
+ */
+interface SwitchProps extends BaseProps {
+    /** Estado inicial (modo não controlado) */
+    defaultChecked?: boolean;
+    /** Callback executado quando o estado muda: (checked) => void */
+    onCheckedChange?: (checked: boolean) => void;
+    /** Nome do input */
+    name?: string;
+    /** Valor do input */
+    value?: string;
+    /** Estado atual (modo controlado) */
+    checked?: boolean;
+}
+
+declare const Switch: React$1.FC<SwitchProps>;
+
+/** Tipos de entrada suportados pelo VerificationCode */
+type InputType = 'numeric' | 'alpha' | 'alphanumeric';
+/**
+ * Props do componente VerificationCode
+ * @example
+ * ```tsx
+ * <VerificationCode
+ *   length={6}
+ *   inputType="numeric"
+ *   onComplete={(code) => handleVerification(code)}
+ * />
+ * ```
+ * @example
+ * ```tsx
+ * <VerificationCode
+ *   length={4}
+ *   inputType="alphanumeric"
+ *   onComplete={handleCode}
+ *   hasError={!!error}
+ *   errorMessage="Código inválido"
+ *   disabled={isVerifying}
+ * />
+ * ```
+ */
+interface VerificationCodeProps extends BaseProps {
+    /** Número de dígitos do código (padrão: 6) */
+    length?: number;
+    /** Tipo de entrada permitida (padrão: "numeric") */
+    inputType?: InputType;
+    /** Callback executado quando todos os campos são preenchidos: (value) => void */
+    onComplete?: (value: string) => void;
+    /** Define se o campo está em estado de erro */
+    hasError?: boolean;
+    /** Mensagem de erro exibida abaixo do componente */
+    errorMessage?: 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, Calendar, Callout, Checkbox, MemoizedChips as Chips, Container, _default$2 as DatePicker, Dialog, Drawer, Filter, ListItem, Menu, Modal, Popover, memorizedQuantity as Quantity, Radio, Search, Select, Switch, Table, TableHeader, TablePagination, _default$1 as TextArea, _default as TextField, Toast, ToastContainer, ToastProvider, Tooltip, VerificationCode, normalizeText, useApiSimulation, useInfiniteScroll, useToast };
+export type { AvatarProps, BadgeProps, ButtonProps, CalendarProps, CalloutProps, CheckboxProps, ChipsProps, ContainerProps, DatePickerProps, DialogProps, DrawerProps, FilterItem, FilterProps, ListItemProps, MenuProps, ModalProps, PopoverProps, QuantityProps, RadioGroupProps, RadioProps, SearchProps, SelectProps, SwitchProps, TableHeaderProps, TablePaginationProps, TableProps, TextAreaProps, TextFieldProps, ToastProps, TooltipProps, VerificationCodeProps };