@rendra-ui/web 2.1.0

package/dist/types/components/ui/table.d.ts

@@ -0,0 +1,134 @@
+import { type ReactNode } from 'react';
+import { type BadgeProps } from './badge';
+import { type DataToolbarProps } from './data-toolbar';
+export interface TableColumn<T> {
+    id: string;
+    header: string;
+    /** Valor da célula (para ordenar, buscar e formatar). */
+    accessor: (row: T) => unknown;
+    /** Renderização própria da célula. */
+    cell?: (row: T) => ReactNode;
+    /**
+     * Linhas extras abaixo do valor, em texto menor (ex.: razão social e CNPJ abaixo do nome;
+     * e-mail abaixo do telefone). Valores vazios são ignorados.
+     */
+    details?: (row: T) => (ReactNode | null | undefined)[];
+    /** O valor vira link para esta rota (ex.: abrir o cadastro), com hover de clicável. */
+    href?: (row: T) => string;
+    /**
+     * Formato automático: number e currency alinham à direita; date vira DD/MM/AAAA;
+     * badge usa badgeTone para escolher a cor.
+     */
+    kind?: 'text' | 'number' | 'currency' | 'date' | 'badge';
+    badgeTone?: (row: T) => BadgeProps['tone'];
+    align?: 'left' | 'right' | 'center';
+    sortable?: boolean;
+    /** Pode ser ocultada pelo menu Colunas. */
+    hideable?: boolean;
+    /** Começa oculta (o usuário mostra pelo menu Colunas). */
+    hidden?: boolean;
+    /** Linhas máximas do texto antes das reticências (máximo 3). */
+    lines?: 1 | 2 | 3;
+    /**
+     * No mobile, a tabela vira cards:
+     *   primary   no topo do card (até 3; o primeiro é o título)
+     *   secondary recolhido em "Ver detalhes"
+     *   hidden    não aparece no card
+     */
+    mobile?: 'primary' | 'secondary' | 'hidden';
+    /** Largura mínima no desktop. */
+    width?: 'sm' | 'md' | 'lg';
+}
+export interface RowAction<T> {
+    label: string;
+    icon?: ReactNode;
+    onClick: (row: T) => void;
+    destructive?: boolean;
+    hidden?: (row: T) => boolean;
+}
+/** O que a Table pede ao servidor em cada carregamento (modo remoto, prop source). */
+export interface TableQuery {
+    /** Página, começando em 1. */
+    page: number;
+    pageSize: number;
+    /** Texto da busca, aplicado pelo servidor a todos os registros (não só à página). */
+    search: string;
+    sort: {
+        id: string;
+        desc: boolean;
+    } | null;
+    /** Cancela a requisição quando o usuário muda de página ou digita de novo. */
+    signal: AbortSignal;
+}
+/** Resposta do servidor: os registros da página e o total que atende à busca e aos filtros. */
+export interface TablePage<T> {
+    rows: T[];
+    total: number;
+}
+/** Registros por página em todas as tabelas do sistema. */
+export declare const TABLE_PAGE_SIZE = 15;
+export interface TableProps<T> {
+    /** Dados já carregados (modo local). Com source, é ignorado. */
+    data?: T[];
+    /**
+     * Modo remoto: a Table pede ao servidor só a página visível. Busca, ordenação e
+     * filtros são enviados na requisição e valem para todos os registros. A função precisa
+     * ser estável (definida fora do componente ou com useCallback).
+     */
+    source?: (query: TableQuery) => Promise<TablePage<T>>;
+    /** Mude este valor quando filtros externos mudarem: a Table recarrega a partir da página 1. */
+    queryKey?: string;
+    columns: TableColumn<T>[];
+    getRowId: (row: T) => string;
+    /** Seleção por checkbox (primeira coluna; no mobile, no topo do card). */
+    selectable?: boolean;
+    /** Conteúdo expandido da linha. */
+    expandable?: (row: T) => ReactNode;
+    /** Ordenação por clique no cabeçalho (padrão por coluna: sortable). */
+    sortable?: boolean;
+    /** Busca global: texto aplicado a todas as colunas. */
+    globalFilter?: string;
+    /** Menu Colunas na barra de ferramentas. */
+    columnVisibility?: boolean;
+    /** Ações em massa para os selecionados (botões). No mobile, barra fixa no rodapé da tela. */
+    bulkActions?: (selected: T[], clear: () => void) => ReactNode;
+    /** Mais ações em massa, no menu de três pontinhos ao lado dos botões. */
+    bulkMenu?: {
+        label: string;
+        icon?: ReactNode;
+        destructive?: boolean;
+        onClick: (selected: T[], clear: () => void) => void;
+    }[];
+    /** Ações por linha. Até 2 visíveis como ícone; acima disso, menu. */
+    rowActions?: RowAction<T>[];
+    density?: 'compact' | 'default' | 'comfortable';
+    loading?: boolean;
+    error?: string | null;
+    onRetry?: () => void;
+    /** Estado vazio. */
+    empty?: {
+        title: string;
+        description?: string;
+        action?: ReactNode;
+    };
+    /** Itens por página. Padrão: 15 (TABLE_PAGE_SIZE). Use 0 para mostrar tudo sem paginação. */
+    pageSize?: number;
+    /** No mobile: "anterior e próxima" ou "carregar mais". */
+    mobilePagination?: 'pages' | 'loadMore';
+    /** Barra de ferramentas no mesmo card, acima da tabela. */
+    toolbar?: Omit<DataToolbarProps, 'columns' | 'selectionBar' | 'sort'>;
+    /**
+     * Colunas de situação (kind: 'badge') vão para o fim, logo antes das ações.
+     * Padrão true; use false para manter a ordem exata de columns.
+     */
+    statusLast?: boolean;
+    /** Rótulo da tabela para leitores de tela. */
+    'aria-label': string;
+}
+/**
+ * Table única do sistema (TanStack Table). Tudo é prop: seleção, expansão, ordenação,
+ * busca, colunas visíveis, ações em massa e por linha, densidade e estados.
+ * Mobile (< 768px): a mesma tabela vira lista de cards, sem rolagem horizontal.
+ * Desktop: tabela larga rola na horizontal só dentro do próprio contêiner.
+ */
+export declare function Table<T>({ data: dataProp, source, queryKey, columns: columnsProp, statusLast, getRowId, selectable, expandable, sortable, globalFilter, columnVisibility, bulkActions, bulkMenu, rowActions, density, loading, error, onRetry, empty, pageSize: pageSizeProp, mobilePagination, toolbar, ...aria }: TableProps<T>): import("react").JSX.Element;

package/dist/types/components/ui/tabs.d.ts

@@ -0,0 +1,25 @@
+import { type ReactNode } from 'react';
+export interface TabItem {
+    value: string;
+    label: string;
+    icon?: ReactNode;
+    /** Contador ao lado do rótulo. */
+    count?: number;
+    disabled?: boolean;
+    content: ReactNode;
+}
+export interface TabsProps {
+    items: TabItem[];
+    value?: string;
+    defaultValue?: string;
+    onChange?: (value: string) => void;
+    /** line: sublinhado; pill: pílulas sobre fundo suave. */
+    variant?: 'line' | 'pill';
+    'aria-label'?: string;
+    className?: string;
+}
+/**
+ * Tabs único. Se as abas não couberem na largura, a mesma lista vira um Select
+ * (nunca rolagem lateral). A troca é medida no próprio contêiner, não na tela.
+ */
+export declare function Tabs({ items, value, defaultValue, onChange, variant, className, ...aria }: TabsProps): import("react").JSX.Element;

package/dist/types/components/ui/textarea.d.ts

@@ -0,0 +1,10 @@
+import { type TextareaHTMLAttributes } from 'react';
+export interface TextareaProps extends Omit<TextareaHTMLAttributes<HTMLTextAreaElement>, 'onChange'> {
+    invalid?: boolean;
+    /** Mostra contador "12/200". Usa maxLength quando definido. */
+    counter?: boolean;
+    value?: string;
+    onChange?: (value: string) => void;
+}
+/** Textarea único, com contador opcional. Cresce com o conteúdo até a altura máxima e depois rola por dentro. */
+export declare const Textarea: import("react").ForwardRefExoticComponent<TextareaProps & import("react").RefAttributes<HTMLTextAreaElement>>;

package/dist/types/components/ui/timeline.d.ts

@@ -0,0 +1,18 @@
+import type { ReactNode } from 'react';
+import type { FeedbackType } from '../../brand/types';
+export interface TimelineEvent {
+    id: string;
+    title: ReactNode;
+    description?: ReactNode;
+    /** Data em formato curto (ex.: "22/09/2026 14:30"). */
+    date: string;
+    tone?: FeedbackType | 'neutral';
+    icon?: ReactNode;
+    /** Resultado do evento: mostrado com ícone e texto, nunca só pela cor. */
+    status?: 'succeeded' | 'failed' | 'skipped';
+}
+/** Linha do tempo única, com eventos em ordem e tom semântico por evento. */
+export declare function Timeline({ events, className }: {
+    events: TimelineEvent[];
+    className?: string;
+}): import("react").JSX.Element;

package/dist/types/components/ui/toast.d.ts

@@ -0,0 +1,18 @@
+interface ToastOptions {
+    description?: string;
+    action?: {
+        label: string;
+        onClick: () => void;
+    };
+    duration?: number;
+}
+export declare const toast: {
+    success: (title: string, opts?: ToastOptions) => string | number;
+    error: (title: string, opts?: ToastOptions) => string | number;
+    warning: (title: string, opts?: ToastOptions) => string | number;
+    info: (title: string, opts?: ToastOptions) => string | number;
+    dismiss: (id?: number | string) => string | number;
+};
+/** Posição: embaixo no centro no mobile (perto do polegar), canto inferior direito no desktop. */
+export declare function Toaster(): import("react").JSX.Element;
+export {};

package/dist/types/components/ui/tooltip.d.ts

@@ -0,0 +1,17 @@
+import type { ReactNode } from 'react';
+/**
+ * Tooltip: só para informação complementar, nunca essencial (não existe hover no toque).
+ * Informação essencial vai em texto de ajuda visível ou em Popover acionado por toque.
+ */
+export declare function TooltipProvider({ children }: {
+    children: ReactNode;
+}): import("react").JSX.Element;
+interface TooltipProps {
+    content: ReactNode;
+    children: ReactNode;
+    side?: 'top' | 'right' | 'bottom' | 'left';
+    /** Desliga o tooltip sem mudar a árvore (ex.: sidebar expandida já mostra o rótulo). */
+    disabled?: boolean;
+}
+export declare function Tooltip({ content, children, side, disabled }: TooltipProps): import("react").JSX.Element;
+export {};

package/dist/types/components/ui/upload.d.ts

@@ -0,0 +1,50 @@
+import { type ImageCropperAspect } from './image-cropper';
+export interface UploadItem {
+    id: string;
+    file: File;
+    progress: number;
+    status: 'uploading' | 'done' | 'error';
+    error?: string;
+    /** URL local (miniatura) para imagem ou vídeo; revogada ao remover ou desmontar. */
+    previewUrl?: string;
+    /** Espelha progress (0-100), lido pelo layout "gallery". */
+    progressPercent?: number;
+    /** Espelha error, lido pelo layout "gallery". */
+    errorMessage?: string;
+    kind?: 'image' | 'video' | 'other';
+}
+export interface UploadProps {
+    /** Tipos aceitos, como no input file (ex.: "image/*,.pdf"). */
+    accept?: string;
+    multiple?: boolean;
+    /** Tamanho máximo por arquivo, em MB. */
+    maxSizeMb?: number;
+    /** Envia o arquivo; chame onProgress(0..100). Rejeite a promessa em caso de erro. */
+    onUpload?: (file: File, onProgress: (pct: number) => void) => Promise<void>;
+    onChange?: (items: UploadItem[]) => void;
+    hint?: string;
+    disabled?: boolean;
+    invalid?: boolean;
+    id?: string;
+    /** Lista (padrão) ou galeria com miniaturas. */
+    layout?: 'list' | 'gallery';
+    /** Total de arquivos permitido; passando dele, a área de soltar arquivo some. */
+    maxItems?: number;
+    /** Além da remoção interna, avisa quem usa o Upload (ex.: para apagar no servidor). */
+    onRemove?: (id: string) => void;
+    /** Além da tentativa interna, avisa quem usa o Upload que o arquivo tentou de novo. */
+    onRetry?: (id: string) => void;
+    /** Reordena os arquivos (motor de src/lib/sortable.ts, o mesmo da List e do Kanban). */
+    onReorder?: (ids: string[]) => void;
+    /**
+     * Com ela, toda imagem passa pelo recorte antes de virar arquivo enviado: o arquivo só é
+     * entregue (a onUpload e a onChange) depois de confirmado no recorte.
+     */
+    crop?: {
+        aspects: ImageCropperAspect[];
+        maxOutputWidth?: number;
+    };
+    'aria-describedby'?: string;
+}
+/** Upload único: arrastar e soltar ou tocar para escolher, em lista ou em galeria. */
+export declare function Upload({ accept, multiple, maxSizeMb, onUpload, onChange, hint, disabled, invalid, id, layout, maxItems, onRemove, onRetry, onReorder, crop, ...aria }: UploadProps): import("react").JSX.Element;

package/dist/types/components/ui/widget-grid.d.ts

@@ -0,0 +1,22 @@
+import { type ReactNode } from 'react';
+import 'react-grid-layout/css/styles.css';
+export interface Widget {
+    id: string;
+    /** Largura em colunas de 12 e altura em linhas (cada linha tem 40px). */
+    w: number;
+    h: number;
+    minW?: number;
+    minH?: number;
+    content: ReactNode;
+}
+export interface WidgetGridProps {
+    widgets: Widget[];
+    /** Libera arrastar e redimensionar. */
+    editable?: boolean;
+    /** Chave no navegador para lembrar a arrumação de cada pessoa. */
+    storageKey?: string;
+    className?: string;
+}
+export declare function WidgetGrid({ widgets, editable, storageKey, className }: WidgetGridProps): import("react").JSX.Element;
+/** Apaga a arrumação salva (volta ao padrão na próxima renderização). */
+export declare function resetWidgetLayout(storageKey: string): void;

package/dist/types/components/ui/wizard.d.ts

@@ -0,0 +1,38 @@
+import { type ReactNode } from 'react';
+export interface WizardStep {
+    id: string;
+    title: string;
+    description?: string;
+}
+export type StepStatus = 'complete' | 'current' | 'pending' | 'error';
+export interface StepperProps {
+    steps: WizardStep[];
+    /** Índice da etapa atual (0 é a primeira). */
+    current: number;
+    /** Etapas com erro de validação (índices). */
+    errors?: number[];
+    orientation?: 'horizontal' | 'vertical';
+    /** Permite voltar clicando em etapas concluídas. */
+    onStepClick?: (index: number) => void;
+    className?: string;
+}
+/**
+ * Indicador de etapas. Desktop: todas as etapas (horizontal ou vertical).
+ * Mobile: reconstruído como "Etapa 2 de 5", barra de progresso e nome da etapa.
+ */
+export declare function Stepper({ steps, current, errors, orientation, onStepClick, className, }: StepperProps): import("react").JSX.Element;
+export interface WizardProps {
+    steps: WizardStep[];
+    /** Conteúdo de cada etapa, na mesma ordem. */
+    children: ReactNode[];
+    /** Valida a etapa antes de avançar. Retorne false para bloquear (e marcar erro). */
+    onValidateStep?: (index: number) => boolean | Promise<boolean>;
+    onFinish?: () => void | Promise<void>;
+    onCancel?: () => void;
+    finishLabel?: string;
+    orientation?: 'horizontal' | 'vertical';
+    /** Botões no rodapé fixo da tela. Padrão: não, seguem junto do card do wizard. */
+    stickyFooter?: boolean;
+}
+/** Cadastro em etapas, com validação por etapa e rodapé Voltar / Avançar. */
+export declare function Wizard({ steps, children, onValidateStep, onFinish, onCancel, finishLabel, orientation, stickyFooter, }: WizardProps): import("react").JSX.Element;

package/dist/types/document-viewer.d.ts

@@ -0,0 +1 @@
+export * from './components/ui/document-viewer';

package/dist/types/hooks/use-breakpoint.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Pontos de quebra, espelhando os padrões do Tailwind (sm 40rem, md 48rem, lg 64rem...).
+ * Único hook de detecção de tela do sistema. Para adaptação ao espaço disponível
+ * dentro de um bloco (e não à tela), use container queries (@container) no CSS.
+ */
+export declare const breakpoints: {
+    readonly sm: 640;
+    readonly md: 768;
+    readonly lg: 1024;
+    readonly xl: 1280;
+    readonly '2xl': 1536;
+};
+export type Breakpoint = keyof typeof breakpoints;
+export declare function useBreakpoint(): {
+    current: "sm" | "base" | "lg" | "xl" | "2xl" | "md";
+    up: (bp: Breakpoint) => boolean;
+    /** Abaixo de 768px: componentes se reconstroem no formato mobile. */
+    isMobile: boolean;
+    isTablet: boolean;
+    isDesktop: boolean;
+};

package/dist/types/hooks/use-debounced-value.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Devolve o valor só depois que ele para de mudar por `delay` ms.
+ * Usado na busca da Table remota: uma requisição por pausa na digitação, não por tecla.
+ */
+export declare function useDebouncedValue<T>(value: T, delay?: number): T;

package/dist/types/hooks/use-fill-height.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Mede o espaço que sobra na área de conteúdo (o <main>) abaixo do elemento e grava em
+ * --board-h. Com a classe h-board, o elemento ocupa exatamente essa altura: a página não
+ * rola e a rolagem acontece dentro dele (kanban, chat).
+ */
+export declare function useFillHeight<T extends HTMLElement = HTMLDivElement>(): import("react").RefObject<T | null>;

package/dist/types/hooks/use-lookup.d.ts

@@ -0,0 +1,30 @@
+import { type Address, type Company } from '../lib/lookup';
+/** Resultado da busca embutida no Input (CEP e CNPJ). */
+export type LookupResult = {
+    status: 'loading';
+    kind: 'cep' | 'cnpj';
+} | {
+    status: 'found';
+    kind: 'cep';
+    data: Address;
+    message: string;
+} | {
+    status: 'found';
+    kind: 'cnpj';
+    data: Company;
+    message: string;
+} | {
+    status: 'not-found';
+    kind: 'cep' | 'cnpj';
+    message: string;
+} | {
+    status: 'error';
+    kind: 'cep' | 'cnpj';
+    message: string;
+};
+/**
+ * Busca CEP (8 dígitos) ou CNPJ (14 dígitos) assim que o valor fica completo. Cancela a
+ * busca anterior quando o valor muda. `kind` 'auto' decide pelo tamanho (CPF ou CNPJ: só
+ * o CNPJ busca). Sem `onResult`, não faz nada.
+ */
+export declare function useLookup(kind: 'cep' | 'cnpj' | 'auto' | undefined, value: string, onResult: ((r: LookupResult) => void) | undefined): boolean;

package/dist/types/hooks/use-reduced-motion.d.ts

@@ -0,0 +1 @@
+export declare function usePrefersReducedMotion(): boolean;

package/dist/types/index.d.ts

@@ -0,0 +1,76 @@
+export * from './components/ui/accordion';
+export * from './components/ui/action-bar';
+export * from './components/ui/alert';
+export * from './components/ui/avatar';
+export * from './components/ui/badge';
+export * from './components/ui/brand-feedback-icon';
+export * from './components/ui/brand-logo';
+export * from './components/ui/breadcrumb';
+export * from './components/ui/button';
+export * from './components/ui/button-group';
+export * from './components/ui/calendar';
+export * from './components/ui/card';
+export * from './components/ui/chat';
+export * from './components/ui/checkbox';
+export * from './components/ui/checklist';
+export * from './components/ui/color-picker';
+export * from './components/ui/data-toolbar';
+export * from './components/ui/date-picker';
+export * from './components/ui/drawer';
+export * from './components/ui/dropdown-menu';
+export * from './components/ui/empty-state';
+export * from './components/ui/error-page';
+export * from './components/ui/field';
+export * from './components/ui/form';
+export * from './components/ui/image-cropper';
+export * from './components/ui/image-viewer';
+export * from './components/ui/info-hint';
+export * from './components/ui/input';
+export * from './components/ui/kanban';
+export * from './components/ui/list';
+export * from './components/ui/modal';
+export * from './components/ui/otp-input';
+export * from './components/ui/pagination';
+export * from './components/ui/popover';
+export * from './components/ui/progress';
+export * from './components/ui/qr-code';
+export * from './components/ui/radio-group';
+export * from './components/ui/rating';
+export * from './components/ui/rendra-credit';
+export * from './components/ui/repeatable-field';
+export * from './components/ui/select';
+export * from './components/ui/separator';
+export * from './components/ui/skeleton';
+export * from './components/ui/slider';
+export * from './components/ui/spinner';
+export * from './components/ui/stat-card';
+export * from './components/ui/switch';
+export * from './components/ui/table';
+export * from './components/ui/tabs';
+export * from './components/ui/textarea';
+export * from './components/ui/timeline';
+export * from './components/ui/toast';
+export * from './components/ui/tooltip';
+export * from './components/ui/upload';
+export * from './components/ui/wizard';
+export * from './components/layout';
+export * from './components/app-shell/app-shell';
+export * from './components/app-shell/layout';
+export * from './components/app-shell/types';
+export * from './components/rendra-provider';
+export * from './catalog/components';
+export * from './hooks/use-breakpoint';
+export * from './hooks/use-debounced-value';
+export * from './hooks/use-fill-height';
+export * from './hooks/use-lookup';
+export * from './hooks/use-reduced-motion';
+export * from './lib/cn';
+export * from './lib/contrast';
+export * from './lib/control';
+export * from './lib/lookup';
+export * from './lib/masks';
+export * from './lib/qr-encode';
+export * from './lib/shape';
+export * from './lib/sortable';
+export * from './lib/validators';
+export * from './brand/public';

package/dist/types/lib/cn.d.ts

@@ -0,0 +1,2 @@
+import { type ClassValue } from 'clsx';
+export declare function cn(...inputs: ClassValue[]): string;

package/dist/types/lib/contrast.d.ts

@@ -0,0 +1,2 @@
+export declare function readVar(name: string): string;
+export declare function contrastRatio(fg: string, bg: string): number | null;

package/dist/types/lib/control.d.ts

@@ -0,0 +1,20 @@
+import { type VariantProps } from 'class-variance-authority';
+/**
+ * Moldura única dos campos (Input, Select, DatePicker, Textarea). Mesma altura dos botões
+ * em cada tamanho; fonte de 16px no mobile para o iOS não dar zoom ao focar.
+ */
+/** Marque o elemento com data-slot="control": o teste de toque mede a moldura, não o input. */
+export declare const controlFrame: (props?: ({
+    size?: "sm" | "lg" | "md" | null | undefined;
+    invalid?: boolean | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+export type ControlSize = NonNullable<VariantProps<typeof controlFrame>['size']>;
+/** Classe do <input> nativo dentro da moldura. */
+export declare const controlInput = "h-full min-w-0 flex-1 bg-transparent outline-none placeholder:text-muted-foreground disabled:cursor-not-allowed";
+/** Botão pequeno dentro da moldura (limpar, mostrar senha). */
+export declare const controlAdornmentButton = "-mr-2 flex size-control-sm shrink-0 cursor-pointer items-center justify-center rounded-item text-muted-foreground transition-colors outline-none hover:bg-accent hover:text-foreground focus-visible:ring-2 focus-visible:ring-ring md:-mr-1 md:size-8 [&_svg]:size-icon-sm";
+/**
+ * Reserva, dentro de um gatilho, o espaço do botão sobreposto (limpar do Select e do
+ * DatePicker), para o texto não passar por baixo dele.
+ */
+export declare const controlAdornmentSpace = "size-control-sm shrink-0 md:size-8";

package/dist/types/lib/lookup.d.ts

@@ -0,0 +1,22 @@
+export interface Address {
+    cep: string;
+    logradouro: string;
+    complemento: string;
+    bairro: string;
+    cidade: string;
+    uf: string;
+}
+/** Endereço do CEP (8 dígitos). null se não existir; lança erro se a busca falhar. */
+export declare function lookupCep(cep: string, signal?: AbortSignal): Promise<Address | null>;
+export interface Company {
+    razaoSocial: string;
+    nomeFantasia: string;
+    email: string;
+    telefone: string;
+    situacao: string;
+    endereco: Address & {
+        numero: string;
+    };
+}
+/** Dados públicos do CNPJ (14 dígitos). null se não existir; lança erro se a busca falhar. */
+export declare function lookupCnpj(cnpj: string, signal?: AbortSignal): Promise<Company | null>;

package/dist/types/lib/masks.d.ts

@@ -0,0 +1,46 @@
+import type { FactoryArg } from 'imask';
+/** Máscaras disponíveis na prop mask do Input. Cada uma já define o teclado certo no mobile. */
+export type MaskName = 'cpf' | 'cnpj' | 'cpfCnpj' | 'phone' | 'cep' | 'date' | 'time' | 'currency' | 'percent';
+type InputMode = 'numeric' | 'tel' | 'decimal';
+export declare const masks: Record<MaskName, {
+    options: FactoryArg;
+    inputMode: InputMode;
+    placeholder: string;
+}>;
+/** Máscara de percentual com teto configurável (padrão 100), para o Input com unidades (A9). */
+export declare function percentMask(max?: number): {
+    options: FactoryArg;
+    inputMode: InputMode;
+    placeholder: string;
+};
+/** País para o seletor de DDI do telefone. */
+export interface PhoneCountry {
+    /** DDI sem o "+", ex.: "55". */
+    ddi: string;
+    /** Nome em português, mostrado na lista. */
+    name: string;
+}
+/** DDI padrão do campo de telefone. */
+export declare const DEFAULT_DDI = "55";
+/** Lista padrão do seletor de DDI (Brasil primeiro). Troque com a prop ddiOptions do Input. */
+export declare const phoneCountries: PhoneCountry[];
+/** Máscara do número fora do Brasil: só dígitos, em grupos, até 15 (limite do padrão E.164). */
+export declare const internationalPhoneMask: {
+    options: FactoryArg;
+    inputMode: InputMode;
+    placeholder: string;
+};
+/** Número completo no padrão internacional: toE164("55", "(11) 91234-5678") = "+5511912345678". */
+export declare function toE164(ddi: string, national: string): string;
+/** Converte "R$ 1.250,00" ou "12,5 %" em número. */
+export declare function parseLocaleNumber(masked: string): number | null;
+/**
+ * Moeda em centavos inteiros, sem erro de arredondamento de ponto flutuante:
+ * "R$ 1.250,50" -> 125050. Vazio -> null. Use centavos para guardar e somar dinheiro.
+ */
+export declare function toCents(masked: string): number | null;
+/** Centavos para o texto do campo de moeda: 125050 -> "R$ 1.250,50". */
+export declare function formatCents(cents: number): string;
+/** Formata número como moeda brasileira: 1250 -> "R$ 1.250,00". */
+export declare function formatCurrency(value: number): string;
+export {};

package/dist/types/lib/qr-encode.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Codificador de QR Code próprio, sem biblioteca externa. Modo byte (qualquer texto,
+ * inclusive acentos, via UTF-8), versões 1 a 10, as quatro correções de erro (L, M, Q, H),
+ * Reed-Solomon em GF(256), as 8 máscaras com penalidade (ISO/IEC 18004) e informação de
+ * formato (e de versão, a partir da versão 7). Cada etapa segue o algoritmo publicado do
+ * padrão; as tabelas de capacidade, os coeficientes do Reed-Solomon e as posições de
+ * alinhamento vêm da própria especificação.
+ */
+export type ErrorCorrectionLevel = 'low' | 'medium' | 'quartile' | 'high';
+export interface QrMatrix {
+    version: number;
+    size: number;
+    /** modules[linha][coluna]; true é módulo escuro. */
+    modules: boolean[][];
+}
+/** Valor grande demais (ou codificação impossível) até a versão 10 no nível pedido. */
+export declare class QrEncodingError extends Error {
+}
+export declare const QR_MAX_VERSION = 10;
+export declare function reedSolomonMultiply(x: number, y: number): number;
+/** Polinômio gerador de grau `degree` (produto de (x - 2^i) para i de 0 a degree-1). */
+export declare function reedSolomonComputeDivisor(degree: number): number[];
+/** Resto da divisão polinomial de `data` pelo `divisor`: os codewords de correção de erro. */
+export declare function reedSolomonComputeRemainder(data: number[], divisor: number[]): number[];
+/** Codewords de correção de erro para `data`, com `ecLength` codewords de saída. */
+export declare function reedSolomonEncode(data: number[], ecLength: number): number[];
+/** Exportada só para teste direto (isola a montagem dos codewords de dados do resto do pipeline). */
+export declare function buildDataCodewords(bytes: Uint8Array, version: number, totalDataCodewords: number): number[];
+/** BCH(15,5) da informação de formato: nível (2 bits) + máscara (3 bits), com a máscara fixa 0x5412. */
+export declare function computeFormatBits(levelBits: number, mask: number): number;
+/** BCH(18,6) da informação de versão (só usada a partir da versão 7). */
+export declare function computeVersionBits(version: number): number;
+/** As quatro regras de penalidade da máscara (ISO/IEC 18004: 3, 3, 40 e a proporção de módulos escuros). */
+export declare function computeMaskPenalty(matrix: boolean[][], size: number): number;
+/**
+ * Codifica `value` (modo byte, UTF-8) num QR Code, escolhendo a menor versão (1 a 10) que
+ * comporta o valor no nível de correção pedido. Lança QrEncodingError se não couber em
+ * nenhuma versão suportada.
+ */
+export declare function encodeQrMatrix(value: string, level?: ErrorCorrectionLevel): QrMatrix;
+/**
+ * Só para teste: relê os codewords (dados + correção de erro) de um QrMatrix já pronto,
+ * redescobrindo a máscara pela informação de formato armazenada. Serve para comparar a
+ * saída do codificador com um valor publicado, sem repetir a tabela de máscaras aqui.
+ */
+export declare function readCodewordsForTest(matrix: QrMatrix, level: ErrorCorrectionLevel): number[];
+/** Um único `<path>` com todos os módulos escuros, para `fill="currentColor"` no SVG. */
+export declare function qrMatrixToSvgPath(matrix: QrMatrix): string;

package/dist/types/lib/shape.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Formato visual do template. Cada template tem o seu, fixo, definido em brand.config.ts:
+ *   Safira: square (pedra lapidada)   Equilíbrio: rounded (meio-termo)   Aurora: pill (100% arredondado)
+ * Os componentes não recebem formato por prop: usam rounded-control, rounded-surface,
+ * rounded-item e rounded-avatar, que obedecem ao formato do template ativo.
+ */
+export type Shape = 'square' | 'rounded' | 'pill';
+export declare const shapeLabels: Record<Shape, string>;