@assembleo/ui 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,676 @@
+import * as react from 'react';
+import { ComponentProps, HTMLAttributes, ReactNode, ButtonHTMLAttributes, ComponentPropsWithoutRef, InputHTMLAttributes, TextareaHTMLAttributes, MouseEventHandler } from 'react';
+import * as class_variance_authority_types from 'class-variance-authority/types';
+import { VariantProps, cx } from 'class-variance-authority';
+import { Avatar as Avatar$1, Checkbox as Checkbox$1, Dialog as Dialog$1, Popover as Popover$1, RadioGroup as RadioGroup$1, Select as Select$1, Separator as Separator$1, Switch as Switch$1, Tabs as Tabs$1 } from 'radix-ui';
+
+declare const avatar: (props?: ({
+    size?: "sm" | "md" | "lg" | "xl" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+type AvatarVariants = VariantProps<typeof avatar>;
+interface AvatarProps extends Omit<ComponentProps<typeof Avatar$1.Root>, 'className' | 'children'> {
+    /** Nome da pessoa — é o nome acessível e a origem das iniciais e da cor. */
+    name: string;
+    src?: string;
+    size?: AvatarVariants['size'];
+    className?: string;
+}
+declare function Avatar({ name, src, size, className, ...props }: AvatarProps): react.JSX.Element;
+interface AvatarGroupProps extends Omit<HTMLAttributes<HTMLDivElement>, 'className'> {
+    /** Quantos avatares aparecem antes do excedente virar "+N". */
+    max?: number;
+    /** O mesmo `size` dos Avatars filhos — mantém o círculo "+N" no mesmo compasso. */
+    size?: AvatarVariants['size'];
+    className?: string;
+    children: ReactNode;
+}
+declare function AvatarGroup({ max, size, className, children, ...props }: AvatarGroupProps): react.JSX.Element;
+
+declare const badge: (props?: ({
+    tone?: "accent" | "neutral" | "success" | "warning" | "danger" | "terracota" | "jardim" | "ambar" | "lavanda" | "ceu" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+type BadgeVariants = VariantProps<typeof badge>;
+interface BadgeProps extends Omit<HTMLAttributes<HTMLSpanElement>, 'className'> {
+    tone?: BadgeVariants['tone'];
+    /** Bolinha na cor forte do tom — reforço visual do status, invisível ao leitor de tela. */
+    dot?: boolean;
+    className?: string;
+    children: ReactNode;
+}
+declare function Badge({ tone, dot, className, children, ...props }: BadgeProps): react.JSX.Element;
+
+declare const banner: (props?: ({
+    tone?: "success" | "warning" | "danger" | "info" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+type BannerVariants = VariantProps<typeof banner>;
+interface BannerProps extends Omit<HTMLAttributes<HTMLDivElement>, 'className' | 'title'> {
+    tone?: BannerVariants['tone'];
+    /** Primeira linha, em negrito; o corpo vem em `children`. */
+    title?: string;
+    /** Presente = banner dispensável; o X chama este callback. */
+    onDismiss?: () => void;
+    className?: string;
+    children: ReactNode;
+}
+/**
+ * Aviso inline — o callout do iOS traduzido para o condomínio: fica no fluxo
+ * da página, perto do que explica, e não some sozinho como um toast.
+ *
+ * `danger` vira `role="alert"` porque é o único tom que justifica interromper
+ * o leitor de tela; o resto anuncia com calma via `status`.
+ */
+declare function Banner({ tone, title, onDismiss, className, children, ...props }: BannerProps): react.JSX.Element;
+
+declare const button: (props?: ({
+    variant?: "danger" | "primary" | "tonal" | "secondary" | "ghost" | "danger-tonal" | null | undefined;
+    size?: "sm" | "md" | "lg" | null | undefined;
+    width?: "auto" | "full" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+type ButtonVariants = VariantProps<typeof button>;
+interface ButtonProps extends Omit<ButtonHTMLAttributes<HTMLButtonElement>, 'className'> {
+    variant?: ButtonVariants['variant'];
+    size?: ButtonVariants['size'];
+    width?: ButtonVariants['width'];
+    /**
+     * Em curso: desabilita e mostra o spinner sem trocar a largura — o rótulo
+     * fica invisível mas continua ocupando espaço, então nada salta.
+     */
+    loading?: boolean;
+    className?: string;
+    children: ReactNode;
+}
+declare function Button({ variant, size, width, loading, className, type, disabled, children, ...props }: ButtonProps): react.JSX.Element;
+
+declare const card: (props?: ({
+    variant?: "flat" | "raised" | "floating" | null | undefined;
+    padding?: "md" | "lg" | "none" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+type CardVariants = VariantProps<typeof card>;
+interface CardProps extends Omit<HTMLAttributes<HTMLElement>, 'className'> {
+    variant?: CardVariants['variant'];
+    padding?: CardVariants['padding'];
+    /**
+     * Cartão de navegação: vira um <button> de verdade — foco, teclado e leitor
+     * de tela de graça — em vez de um div com onClick que só o mouse alcança.
+     */
+    interactive?: boolean;
+    className?: string;
+    children: ReactNode;
+}
+declare function Card({ variant, padding, interactive, className, children, ...props }: CardProps): react.JSX.Element;
+
+interface CheckboxProps extends Omit<ComponentProps<typeof Checkbox$1.Root>, 'className' | 'children'> {
+    /**
+     * Texto ao lado da caixa; a linha inteira vira alvo de toque de 44px.
+     * Sem `label`, o checkbox fica mudo para leitores de tela — nesse caso
+     * `aria-label` é obrigatório.
+     */
+    label?: string;
+    className?: string;
+}
+declare function Checkbox({ label, className, id, ...props }: CheckboxProps): react.JSX.Element;
+
+/**
+ * O modal de confirmação: uma pergunta, uma decisão. Radix cuida do portal,
+ * do foco preso e do Escape; aqui entram só a pele e a composição.
+ */
+declare const Dialog: react.FC<Dialog$1.DialogProps>;
+interface DialogTriggerProps extends ComponentPropsWithoutRef<typeof Dialog$1.Trigger> {
+}
+/**
+ * `asChild` por padrão: o gatilho quase sempre é um <Button> do sistema, e
+ * embrulhá-lo em outro <button> seria HTML inválido.
+ */
+declare function DialogTrigger({ asChild, ...props }: DialogTriggerProps): react.JSX.Element;
+interface DialogContentProps extends Omit<ComponentPropsWithoutRef<typeof Dialog$1.Content>, 'className'> {
+    className?: string;
+    children: ReactNode;
+}
+declare function DialogContent({ className, children, ...props }: DialogContentProps): react.JSX.Element;
+interface DialogSectionProps extends Omit<HTMLAttributes<HTMLDivElement>, 'className'> {
+    className?: string;
+    children: ReactNode;
+}
+declare function DialogHeader({ className, children, ...props }: DialogSectionProps): react.JSX.Element;
+interface DialogTitleProps extends Omit<ComponentPropsWithoutRef<typeof Dialog$1.Title>, 'className'> {
+    className?: string;
+}
+declare function DialogTitle({ className, ...props }: DialogTitleProps): react.JSX.Element;
+interface DialogDescriptionProps extends Omit<ComponentPropsWithoutRef<typeof Dialog$1.Description>, 'className'> {
+    className?: string;
+}
+declare function DialogDescription({ className, ...props }: DialogDescriptionProps): react.JSX.Element;
+declare function DialogFooter({ className, children, ...props }: DialogSectionProps): react.JSX.Element;
+interface DialogCloseProps extends ComponentPropsWithoutRef<typeof Dialog$1.Close> {
+}
+/** Mesmo raciocínio do trigger: o "Cancelar" do rodapé é um <Button> nosso. */
+declare function DialogClose({ asChild, ...props }: DialogCloseProps): react.JSX.Element;
+
+interface EmptyStateProps extends Omit<HTMLAttributes<HTMLDivElement>, 'className' | 'title'> {
+    /**
+     * Slot livre para uma ilustração da camada expressiva (um prédio, um
+     * livreto). Quando presente, vence o `icon` — os dois juntos brigariam.
+     */
+    illustration?: ReactNode;
+    /** Ícone simples; ganha a moldura squircle suave do sistema. */
+    icon?: ReactNode;
+    title: string;
+    description?: string;
+    /** Slot para a ação que tira a tela do vazio — em geral um Button. */
+    action?: ReactNode;
+    className?: string;
+}
+/**
+ * O vazio como convite: em vez de uma lista em branco, uma tela que explica o
+ * que este lugar vai ser e oferece o primeiro passo. O texto faz o trabalho —
+ * título nomeia o vazio, descrição diz o que fazer, a ação faz.
+ */
+declare function EmptyState({ illustration, icon, title, description, action, className, ...props }: EmptyStateProps): react.JSX.Element;
+
+interface FieldContextValue {
+    controlId: string;
+    hintId: string | undefined;
+    errorId: string | undefined;
+    invalid: boolean;
+}
+/**
+ * O controle (Input, Textarea, Select…) lê daqui os ids de label, dica e erro.
+ * Fora de um Field, devolve null e o controle segue autônomo.
+ */
+declare function useFieldContext(): FieldContextValue | null;
+interface FieldProps {
+    label: string;
+    /** Ajuda curta, permanente, abaixo do controle. */
+    hint?: string;
+    /** Mensagem de erro; presente = campo inválido. */
+    error?: string;
+    /** Marca visual e semântica de obrigatório. */
+    required?: boolean;
+    className?: string;
+    children: ReactNode;
+}
+/**
+ * A moldura de todo campo de formulário: label, controle, dica e erro, com a
+ * fiação de acessibilidade feita uma vez só — `htmlFor`, `aria-describedby` e
+ * `aria-invalid` nascem daqui, e nenhuma tela precisa lembrar deles.
+ */
+declare function Field({ label, hint, error, required, className, children }: FieldProps): react.JSX.Element;
+
+declare const iconButton: (props?: ({
+    variant?: "primary" | "tonal" | "secondary" | "ghost" | "danger-tonal" | null | undefined;
+    size?: "sm" | "md" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+type IconButtonVariants = VariantProps<typeof iconButton>;
+interface IconButtonProps extends Omit<ButtonHTMLAttributes<HTMLButtonElement>, 'className' | 'aria-label'> {
+    /**
+     * Obrigatório porque um ícone sozinho não diz nada ao leitor de tela —
+     * vira o `aria-label` e é a única fonte do nome acessível.
+     */
+    label: string;
+    variant?: IconButtonVariants['variant'];
+    size?: IconButtonVariants['size'];
+    className?: string;
+    /** O ícone (lucide), e só ele — texto visível pede o Button. */
+    children: ReactNode;
+}
+declare function IconButton({ label, variant, size, className, type, children, ...props }: IconButtonProps): react.JSX.Element;
+
+interface InputProps extends Omit<InputHTMLAttributes<HTMLInputElement>, 'className'> {
+    className?: string;
+}
+declare function Input({ className, id, type, ...props }: InputProps): react.JSX.Element;
+
+interface TextareaProps extends Omit<TextareaHTMLAttributes<HTMLTextAreaElement>, 'className'> {
+    className?: string;
+}
+declare function Textarea({ className, id, rows, ...props }: TextareaProps): react.JSX.Element;
+
+interface ListProps {
+    /** Título da seção, fora da superfície — como nos Ajustes do iOS. */
+    header?: string;
+    /** Nota de rodapé explicando a seção, também fora da superfície. */
+    footer?: string;
+    className?: string;
+    children: ReactNode;
+}
+/**
+ * A lista agrupada do iOS: itens sobre uma superfície única, separados por
+ * fios, com título e nota do lado de fora. É a espinha dorsal das telas de
+ * síndico e morador — ajustes do condomínio, pautas, associados.
+ */
+declare function List({ header, footer, className, children }: ListProps): react.JSX.Element;
+declare const iconBadge: (props?: ({
+    tone?: "accent" | "terracota" | "jardim" | "ambar" | "lavanda" | "ceu" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+type IconBadgeVariants = VariantProps<typeof iconBadge>;
+interface ListItemProps {
+    /** Ícone decorativo no quadradinho colorido; o sentido vem do título. */
+    icon?: ReactNode;
+    iconTone?: IconBadgeVariants['tone'];
+    title: string;
+    subtitle?: string;
+    /** Valor atual à direita, como "12 unidades" nos Ajustes. */
+    value?: string;
+    /** Com onClick o item inteiro vira um <button> e ganha o chevron de navegação. */
+    onClick?: MouseEventHandler<HTMLButtonElement>;
+    className?: string;
+}
+declare function ListItem({ icon, iconTone, title, subtitle, value, onClick, className, }: ListItemProps): react.JSX.Element;
+
+/**
+ * O cartão flutuante ancorado num gatilho — detalhe de quórum, filtro rápido.
+ * O Radix cuida do portal, do posicionamento, do Escape e do clique fora.
+ */
+declare const Popover: react.FC<Popover$1.PopoverProps>;
+interface PopoverTriggerProps extends ComponentPropsWithoutRef<typeof Popover$1.Trigger> {
+}
+/**
+ * `asChild` por padrão: o gatilho quase sempre é um Button/IconButton do
+ * sistema, e embrulhá-lo em outro <button> seria HTML inválido.
+ */
+declare function PopoverTrigger({ asChild, ...props }: PopoverTriggerProps): react.JSX.Element;
+interface PopoverContentProps extends Omit<ComponentPropsWithoutRef<typeof Popover$1.Content>, 'className'> {
+    className?: string;
+    children: ReactNode;
+}
+declare function PopoverContent({ className, sideOffset, collisionPadding, children, ...props }: PopoverContentProps): react.JSX.Element;
+
+interface ProgressProps {
+    /**
+     * Progresso de 0 a 100. Ausente = indeterminado: a barra vira um trilho
+     * pulsante, para "apurando…" sem número não fingir precisão.
+     */
+    value?: number;
+    /**
+     * Nome acessível obrigatório: uma barra sozinha não diz o que está medindo,
+     * e "62%" sem contexto é ruído para quem ouve a tela.
+     */
+    label: string;
+    className?: string;
+}
+/**
+ * Barra de progresso determinada ou indeterminada — quórum subindo, votos
+ * sendo apurados. O Radix cuida do papel `progressbar` e dos `aria-value*`.
+ */
+declare function Progress({ value, label, className }: ProgressProps): react.JSX.Element;
+
+interface RadioGroupProps extends Omit<ComponentProps<typeof RadioGroup$1.Root>, 'className'> {
+    className?: string;
+}
+/**
+ * O grupo carrega a fiação de formulário; cada opção é um RadioGroupItem.
+ * Fora de um Field, dê nome ao grupo com `aria-label`.
+ */
+declare function RadioGroup({ className, id, ...props }: RadioGroupProps): react.JSX.Element;
+interface RadioGroupItemProps extends Omit<ComponentProps<typeof RadioGroup$1.Item>, 'className' | 'children'> {
+    /** Rádio sem texto não existe: a opção precisa se apresentar. */
+    label: string;
+    className?: string;
+}
+declare function RadioGroupItem({ label, className, id, ...props }: RadioGroupItemProps): react.JSX.Element;
+
+interface SearchFieldProps extends Omit<InputHTMLAttributes<HTMLInputElement>, 'className' | 'type'> {
+    /**
+     * Chamado ao apertar o X. No modo não controlado o campo já se limpa sozinho
+     * (via ref) antes de avisar; no controlado é aqui que o consumidor zera o
+     * `value` — o componente não tenta adivinhar o estado de quem o usa.
+     */
+    onClear?: () => void;
+    className?: string;
+}
+/**
+ * A busca com cara de iOS: pílula rebaixada, lupa à esquerda e um X próprio à
+ * direita — o do WebKit é escondido porque só existe em um motor e não fala
+ * com leitor de tela.
+ */
+declare function SearchField({ onClear, className, onChange, 'aria-label': ariaLabel, ...props }: SearchFieldProps): react.JSX.Element;
+
+declare const container: (props?: ({
+    width?: "auto" | "full" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+type ContainerVariants = VariantProps<typeof container>;
+interface SegmentedControlOption {
+    value: string;
+    label: string;
+}
+interface SegmentedControlProps {
+    options: SegmentedControlOption[];
+    value?: string;
+    /** Sem `value` nem `defaultValue`, a primeira opção nasce selecionada. */
+    defaultValue?: string;
+    /** Só dispara com valor de verdade — desmarcar não existe aqui. */
+    onValueChange?: (value: string) => void;
+    /** O grupo precisa se apresentar: "Filtro de pautas", "Período"… */
+    'aria-label': string;
+    width?: ContainerVariants['width'];
+    disabled?: boolean;
+    className?: string;
+}
+/**
+ * O controle segmentado da Apple: um trilho rebaixado onde exatamente um
+ * segmento está sempre ativo — é filtro/aba, não checkbox. Por isso o valor é
+ * controlado por dentro e o '' que o ToggleGroup emite ao reclicar o segmento
+ * ativo é ignorado: nunca existe estado "nada selecionado".
+ */
+declare function SegmentedControl({ options, value, defaultValue, onValueChange, 'aria-label': ariaLabel, width, disabled, className, }: SegmentedControlProps): react.JSX.Element;
+
+interface SelectProps extends Omit<ComponentProps<typeof Select$1.Root>, 'children'> {
+    /** Convite exibido enquanto nada foi escolhido. */
+    placeholder?: string;
+    /** Sem Field por perto, dê nome ao campo com `aria-label`. */
+    'aria-label'?: string;
+    id?: string;
+    /** Aplica no trigger — é ele o "campo" que a tela enxerga. */
+    className?: string;
+    /** Os SelectItem's (e nada além deles). */
+    children: ReactNode;
+}
+/**
+ * O Select já vem montado — trigger com cara de campo e lista pronta — porque
+ * a composição livre do Radix é liberdade que nenhuma tela nossa usa: todo
+ * select do produto é "campo que abre lista de opções".
+ */
+declare function Select({ placeholder, 'aria-label': ariaLabel, id, className, children, ...props }: SelectProps): react.JSX.Element;
+interface SelectItemProps extends Omit<ComponentProps<typeof Select$1.Item>, 'className'> {
+    className?: string;
+}
+declare function SelectItem({ className, children, ...props }: SelectItemProps): react.JSX.Element;
+
+interface SeparatorProps extends Omit<ComponentPropsWithoutRef<typeof Separator$1.Root>, 'className'> {
+    className?: string;
+}
+/**
+ * O fio que divide seções quando a sombra não alcança. Decorativo por padrão:
+ * a divisão visual raramente é uma divisão semântica — quando for (grupos de
+ * um menu, por exemplo), passe `decorative={false}` e o papel de separador
+ * volta para o leitor de tela.
+ */
+declare function Separator({ orientation, decorative, className, ...props }: SeparatorProps): react.JSX.Element;
+
+/**
+ * O bottom sheet: o modal com sotaque de celular. Sobre o mesmo Radix Dialog
+ * do modal centrado — portal, foco preso e Escape idênticos — muda só a pele:
+ * sobe do rodapé, cola nas bordas e respeita a barra de gestos do iPhone.
+ */
+declare const Sheet: react.FC<Dialog$1.DialogProps>;
+interface SheetTriggerProps extends ComponentPropsWithoutRef<typeof Dialog$1.Trigger> {
+}
+/** `asChild` por padrão, como no Dialog: o gatilho é um controle do sistema. */
+declare function SheetTrigger({ asChild, ...props }: SheetTriggerProps): react.JSX.Element;
+interface SheetContentProps extends Omit<ComponentPropsWithoutRef<typeof Dialog$1.Content>, 'className'> {
+    className?: string;
+    children: ReactNode;
+}
+declare function SheetContent({ className, children, ...props }: SheetContentProps): react.JSX.Element;
+interface SheetSectionProps extends Omit<HTMLAttributes<HTMLDivElement>, 'className'> {
+    className?: string;
+    children: ReactNode;
+}
+declare function SheetHeader({ className, children, ...props }: SheetSectionProps): react.JSX.Element;
+interface SheetTitleProps extends Omit<ComponentPropsWithoutRef<typeof Dialog$1.Title>, 'className'> {
+    className?: string;
+}
+declare function SheetTitle({ className, ...props }: SheetTitleProps): react.JSX.Element;
+interface SheetDescriptionProps extends Omit<ComponentPropsWithoutRef<typeof Dialog$1.Description>, 'className'> {
+    className?: string;
+}
+declare function SheetDescription({ className, ...props }: SheetDescriptionProps): react.JSX.Element;
+
+declare const skeleton: (props?: ({
+    shape?: "text" | "title" | "circle" | "block" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+type SkeletonVariants = VariantProps<typeof skeleton>;
+interface SkeletonProps extends Omit<HTMLAttributes<HTMLDivElement>, 'className' | 'children'> {
+    shape?: SkeletonVariants['shape'];
+    className?: string;
+}
+/**
+ * Placeholder de carregamento: ocupa o lugar do conteúdo que ainda não chegou
+ * para a tela não saltar quando ele chega.
+ *
+ * É sempre `aria-hidden`: o esqueleto é puro teatro visual — quem anuncia o
+ * carregamento para o leitor de tela é o contêiner (`aria-busy`) ou um status
+ * de verdade, nunca uma fileira de retângulos cinzas.
+ */
+declare function Skeleton({ shape, className, ...props }: SkeletonProps): react.JSX.Element;
+
+declare const spinner: (props?: ({
+    size?: "sm" | "md" | "lg" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+type SpinnerVariants = VariantProps<typeof spinner>;
+interface SpinnerProps {
+    size?: SpinnerVariants['size'];
+    /**
+     * O que o leitor de tela anuncia. Quando o spinner acompanha um texto visível
+     * (ex.: botão em loading), passe `label=""` para não anunciar duas vezes.
+     */
+    label?: string;
+    className?: string;
+}
+declare function Spinner({ size, label, className }: SpinnerProps): react.JSX.Element;
+
+interface SwitchProps extends Omit<ComponentProps<typeof Switch$1.Root>, 'className' | 'children'> {
+    /**
+     * Texto à esquerda, switch à direita — a linha de ajustes do iOS, clicável
+     * inteira. Sem `label`, o switch fica mudo para leitores de tela — nesse
+     * caso `aria-label` é obrigatório.
+     */
+    label?: string;
+    className?: string;
+}
+declare function Switch({ label, className, id, ...props }: SwitchProps): react.JSX.Element;
+
+/**
+ * Navegação por abas no estilo sublinha — a do topo de tela do iOS. O Radix
+ * cuida dos papéis (tablist/tab/tabpanel), do foco e das setas; aqui entra só
+ * a pele.
+ */
+declare const Tabs: react.ForwardRefExoticComponent<Tabs$1.TabsProps & react.RefAttributes<HTMLDivElement>>;
+interface TabsListProps extends Omit<ComponentPropsWithoutRef<typeof Tabs$1.List>, 'className'> {
+    className?: string;
+    children: ReactNode;
+}
+declare function TabsList({ className, children, ...props }: TabsListProps): react.JSX.Element;
+interface TabsTriggerProps extends Omit<ComponentPropsWithoutRef<typeof Tabs$1.Trigger>, 'className'> {
+    className?: string;
+    children: ReactNode;
+}
+declare function TabsTrigger({ className, children, ...props }: TabsTriggerProps): react.JSX.Element;
+interface TabsContentProps extends Omit<ComponentPropsWithoutRef<typeof Tabs$1.Content>, 'className'> {
+    className?: string;
+    children: ReactNode;
+}
+declare function TabsContent({ className, children, ...props }: TabsContentProps): react.JSX.Element;
+
+type ToastVariant = 'default' | 'success' | 'danger';
+interface ToastOptions {
+    title: string;
+    description?: string;
+    variant?: ToastVariant;
+}
+interface ToastContextValue {
+    /** Dispara um aviso transitório; some sozinho depois de 5 segundos. */
+    toast: (options: ToastOptions) => void;
+}
+/**
+ * Devolve `{ toast }` para qualquer tela disparar avisos. A API é imperativa
+ * de propósito: quem confirma um voto quer uma linha de código, não um estado
+ * local de "aviso aberto" em cada página.
+ */
+declare function useToast(): ToastContextValue;
+interface ToastProviderProps {
+    children: ReactNode;
+}
+/**
+ * Envolve a app uma única vez e passa a ser o dono dos avisos: guarda a fila,
+ * expõe `toast()` via contexto e renderiza os cards sobre o conteúdo. No
+ * celular ocupa a largura toda rente ao polegar; no desktop recolhe para o
+ * canto inferior direito.
+ */
+declare function ToastProvider({ children }: ToastProviderProps): react.JSX.Element;
+
+interface TooltipProps {
+    /** O que a dica mostra — texto curto na maioria dos casos. */
+    content: ReactNode;
+    /** De que lado do gatilho a dica aparece. */
+    side?: 'top' | 'right' | 'bottom' | 'left';
+    className?: string;
+    /**
+     * O gatilho. Renderizado via `asChild`: o filho vira o próprio trigger e por
+     * isso precisa aceitar `ref` e repassar props — um elemento nativo ou um
+     * componente que espalhe as duas coisas (o Button do sistema serve).
+     */
+    children: ReactNode;
+}
+/**
+ * Dica flutuante para rótulos que não cabem na tela — o nome de um ícone, o
+ * detalhe de um número. O Provider vive aqui dentro para o uso ser de uma
+ * linha; o preço (sem delay compartilhado entre tooltips vizinhos) é aceitável
+ * num produto onde tooltip é exceção, não tapete.
+ *
+ * Sem seta, de propósito: a proximidade e a sombra já dizem de onde a dica
+ * veio, e a forma limpa é mais fiel à linguagem do sistema.
+ */
+declare function Tooltip({ content, side, className, children }: TooltipProps): react.JSX.Element;
+
+/**
+ * O crachá — como um associado aparece na listagem.
+ *
+ * A metáfora é a do crachá de evento pendurado no cordão: furo no topo, faixa
+ * de cor, foto grande e o nome em destaque. A listagem de associados vira um
+ * quadro de gente, não uma tabela de cadastros.
+ */
+declare const TONES$2: readonly ["terracota", "jardim", "ambar", "lavanda", "ceu"];
+type Tone$2 = (typeof TONES$2)[number];
+declare const cracha: (props?: ({
+    size?: "md" | "lg" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+type CrachaVariants = VariantProps<typeof cracha>;
+interface CrachaProps {
+    name: string;
+    /** "Apto 42 · Bloco B" — a unidade é o sobrenome de quem mora em condomínio. */
+    unit?: string;
+    src?: string;
+    /** Papel na comunidade: "Síndica", "Conselho"… vira a etiqueta do crachá. */
+    memberRole?: string;
+    tone?: Tone$2;
+    size?: CrachaVariants['size'];
+    className?: string;
+}
+declare function Cracha({ name, unit, src, memberRole, tone, size, className, }: CrachaProps): react.JSX.Element;
+
+/**
+ * O livreto — a capa de uma pauta.
+ *
+ * Pauta de assembleia é documento que se folheia, discute e arquiva; a estante
+ * de livretos conta isso de longe. A lombada colorida à esquerda e o bloco de
+ * páginas à direita fazem o objeto; o resto é tipografia.
+ */
+declare const TONES$1: readonly ["terracota", "jardim", "ambar", "lavanda", "ceu"];
+type Tone$1 = (typeof TONES$1)[number];
+declare const livreto: (props?: ({
+    size?: "sm" | "md" | "lg" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+type LivretoVariants = VariantProps<typeof livreto>;
+interface LivretoProps {
+    title: string;
+    /** A sobrelinha da capa: "Pauta", "Ata", "Edital"… */
+    kind?: string;
+    tone?: Tone$1;
+    size?: LivretoVariants['size'];
+    /** Rodapé da capa — o lugar do Badge de status. */
+    footer?: ReactNode;
+    className?: string;
+}
+declare function Livreto({ title, kind, tone, size, footer, className, }: LivretoProps): react.JSX.Element;
+
+/**
+ * O prediozinho do Assembleo — a cara de um condomínio na tela de seleção, no
+ * mapinha, no cabeçalho.
+ *
+ * Ele é determinístico: o mesmo nome desenha sempre o mesmo prédio (andares,
+ * cor do telhado, quais janelas estão acesas). O condomínio da pessoa vira um
+ * lugar reconhecível, não um ícone genérico — e sem guardar estado nenhum.
+ */
+declare const TONES: readonly ["terracota", "jardim", "ambar", "lavanda", "ceu"];
+type Tone = (typeof TONES)[number];
+declare const predio: (props?: ({
+    size?: "sm" | "md" | "lg" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+type PredioVariants = VariantProps<typeof predio>;
+interface PredioProps {
+    /** Semente do desenho e nome anunciado ao leitor de tela. */
+    name: string;
+    /** Sobrescreve o sorteio quando o produto quiser fixar a cor. */
+    tone?: Tone;
+    /** Sobrescreve o sorteio de andares (3 a 6). */
+    floors?: number;
+    size?: PredioVariants['size'];
+    /**
+     * Decorativo quando o nome já está escrito ao lado — o leitor de tela não
+     * precisa ouvir "prédio de X" duas vezes.
+     */
+    decorative?: boolean;
+    className?: string;
+}
+declare function Predio({ name, tone, floors, size, decorative, className }: PredioProps): react.JSX.Element;
+
+/**
+ * Junta classes resolvendo conflito pelo que vem por último.
+ *
+ * Sem o merge, `cn('p-2', 'p-4')` emitiria as duas e o vencedor sairia da
+ * ordem no CSS gerado, não da ordem da chamada — o que torna sobrescrever o
+ * estilo de um componente base uma questão de sorte.
+ */
+declare function cn(...classes: Parameters<typeof cx>): string;
+
+interface VisuallyHiddenProps {
+    children: ReactNode;
+}
+/**
+ * Presente para o leitor de tela, invisível para todo o resto.
+ *
+ * É a técnica clássica de clip — `display: none` e `aria-hidden` removeriam o
+ * conteúdo da árvore de acessibilidade, que é exatamente o que não se quer.
+ */
+declare function VisuallyHidden({ children }: VisuallyHiddenProps): react.JSX.Element;
+
+/**
+ * O gerenciador de tema do Assembleo.
+ *
+ * Os tokens já seguem o aparelho sozinhos (`prefers-color-scheme`); este módulo
+ * existe para a escolha explícita do usuário: claro, escuro ou "sistema". A
+ * escolha vira `data-theme` no <html> — o mesmo mecanismo que o theme.css
+ * escuta — e persiste em localStorage para sobreviver ao próximo acesso.
+ */
+type Theme = 'light' | 'dark' | 'system';
+/**
+ * Aplica o tema guardado antes do React montar — chame no topo do main.tsx.
+ * Em SPA isso elimina qualquer flash: quando o app pinta, o tema já é o certo.
+ */
+declare function initTheme(): void;
+interface ThemeContextValue {
+    /** A escolha do usuário — 'system' significa "sigo o aparelho". */
+    theme: Theme;
+    /** O que está de fato na tela agora: 'light' ou 'dark'. */
+    resolvedTheme: 'light' | 'dark';
+    setTheme: (theme: Theme) => void;
+}
+interface ThemeProviderProps {
+    children: ReactNode;
+}
+declare function ThemeProvider({ children }: ThemeProviderProps): react.JSX.Element;
+declare function useTheme(): ThemeContextValue;
+
+interface ThemeToggleProps {
+    width?: 'full' | 'auto';
+    className?: string;
+}
+/**
+ * O seletor de tema pronto para a tela de ajustes: o controle segmentado da
+ * casa, já ligado ao useTheme. "Sistema" fica por último porque é o padrão de
+ * quem nunca mexeu — as escolhas ativas vêm primeiro.
+ */
+declare function ThemeToggle({ width, className }: ThemeToggleProps): react.JSX.Element;
+
+export { Avatar, AvatarGroup, Badge, Banner, Button, Card, Checkbox, Cracha, Dialog, DialogClose, DialogContent, DialogDescription, DialogFooter, DialogHeader, DialogTitle, DialogTrigger, EmptyState, Field, IconButton, Input, List, ListItem, Livreto, Popover, PopoverContent, PopoverTrigger, Predio, Progress, RadioGroup, RadioGroupItem, SearchField, SegmentedControl, type SegmentedControlOption, Select, SelectItem, Separator, Sheet, SheetContent, SheetDescription, SheetHeader, SheetTitle, SheetTrigger, Skeleton, Spinner, Switch, Tabs, TabsContent, TabsList, TabsTrigger, Textarea, type Theme, ThemeProvider, ThemeToggle, type ToastOptions, ToastProvider, type ToastVariant, Tooltip, VisuallyHidden, cn, initTheme, useFieldContext, useTheme, useToast };