@proef/common-ui 0.0.0-stage → 2.2.0

package/dist/types/v1/components/tables/Table/Table.d.ts

@@ -0,0 +1,250 @@
+import React from 'react';
+import { type TableLabels } from './labels';
+export interface TableColumn<T> {
+    /** Identifica a coluna (ordenação, filtros, agrupamento, ordem). Única na tabela. */
+    key: string;
+    /** Título no cabeçalho. */
+    label: string;
+    /** O que a célula mostra. */
+    render: (row: T) => React.ReactNode;
+    /**
+     * O valor por trás da célula: é por ele que se ordena, filtra e agrupa. Sem
+     * ele a coluna não ordena, não filtra e não agrupa.
+     */
+    value?: (row: T) => string | number | null | undefined;
+    /** Por omissão `true` (quando há `value`). */
+    sortable?: boolean;
+    /** Por omissão `true` (quando há `value`). */
+    filterable?: boolean;
+    /**
+     * Como se filtra esta coluna:
+     *  - `text` (omissão): lista de valores únicos com vistos
+     *  - `date`: intervalo De/Até
+     *  - `number`: intervalo Mín/Máx, ou a lista de valores
+     *
+     * Numa coluna de dinheiro ou de contagem, a lista de valores é inútil: são
+     * centenas de números distintos, e ninguém procura "10.04".
+     */
+    filterType?: 'text' | 'date' | 'number';
+    /** Agrupar é opt-in: só com `true`. Evita agrupar por valores contínuos (datas, decimais, €). */
+    groupable?: boolean;
+    /**
+     * Filtros extra no cabeçalho desta coluna, cada um com o seu funil.
+     *
+     * Para uma coluna que mostra mais do que um dado — um "Início e Fim" mostra
+     * as duas pontas de um período, e um só filtro dava a lista dos PARES
+     * ("2026-07-03 → 2026-09-12"), que não é por onde alguém procura.
+     *
+     * `filterType: 'date'` dá-lhe o intervalo De/Até em vez da lista de valores.
+     */
+    extraFilters?: {
+        key: string;
+        label: string;
+        value: (row: T) => string | number | null | undefined;
+        filterType?: 'text' | 'date' | 'number';
+    }[];
+    headerClassName?: string;
+    cellClassName?: string;
+    /** Conteúdo extra por baixo do título da coluna (ex: um total). Recebe as linhas já filtradas. */
+    headerExtra?: (rows: T[]) => React.ReactNode;
+}
+/**
+ * Ordenação e filtros do cabeçalho vivem dentro da tabela. Quem está por fora
+ * (ex: exportar para Excel) precisa deles para não exportar linhas que a pessoa
+ * filtrou fora: daí este handle, preenchido em `viewRef`.
+ */
+export interface TableView<T> {
+    /** Aplica a ordenação e os filtros de coluna a qualquer lista (ex: o conjunto completo). */
+    apply: (rows: T[]) => T[];
+    /** O mesmo, com a ordenação e os filtros de `state` em vez dos do cabeçalho. */
+    applyWith: (rows: T[], state: TableState) => T[];
+    /** Linhas à vista, já ordenadas e filtradas (todas as páginas em modo cliente). */
+    rows: T[];
+    hasFilters: boolean;
+    /**
+     * Há filtros, ordenação ou agrupamento ativos no cabeçalho, todos do lado do
+     * cliente. Quem alimenta a tabela usa isto para não largar o conjunto
+     * completo: sem ele, filtrar só olha para a página.
+     */
+    needsAllData: boolean;
+    /** Estado guardável da vista: filtros, ordenação e agrupamento. */
+    getState: () => TableState;
+    /** Repõe um estado guardado (ex: ao aplicar uma vista que a pessoa guardou). */
+    restore: (state: TableState | undefined) => void;
+}
+/**
+ * O que uma vista guardada leva da tabela. Conjuntos viram arrays para se
+ * poder guardar em JSON.
+ */
+export interface TableState {
+    columnFilters?: Record<string, string[]>;
+    dateFilters?: Record<string, {
+        from?: string;
+        to?: string;
+    }>;
+    /** Intervalos Mín/Máx. */
+    numFilters?: Record<string, {
+        min?: string;
+        max?: string;
+    }>;
+    sortCol?: string | null;
+    sortDir?: 'asc' | 'desc';
+    /** Colunas por que se agrupa, pela ordem dos níveis. */
+    groupBy?: string[];
+}
+export interface TableProps<T> {
+    columns: TableColumn<T>[];
+    /** As linhas a mostrar (a página atual, quando quem alimenta a tabela pagina). */
+    data: T[];
+    /**
+     * O conjunto completo, para ordenar, filtrar e agrupar do lado do cliente.
+     * Pode chegar mais tarde: a tabela pede-o com `onAllDataNeeded`.
+     */
+    allData?: T[];
+    /** Linhas por página quando a tabela se pagina a si mesma (modo cliente). */
+    pageSize?: number;
+    rowKey: (row: T) => string;
+    onRowClick?: (row: T) => void;
+    /** Duplo clique na linha: atalho para o detalhe, sem roubar o clique simples (seleção, edição). */
+    onRowDoubleClick?: (row: T) => void;
+    loading?: boolean;
+    /** O conjunto completo (`allData`) está a carregar: ordenar, filtrar e agrupar esperam por ele. */
+    allDataLoading?: boolean;
+    loadingLabel?: string;
+    /** Sem linhas. Por omissão `labels.empty`. */
+    emptyLabel?: string;
+    emptySubLabel?: string;
+    /** Guarda os filtros na sessão do browser (`sessionStorage`) com esta chave, e repõe-nos ao voltar. */
+    storageKey?: string;
+    /** Caixa de seleção em cada linha. */
+    selectable?: boolean;
+    onSelectionChange?: (selectedKeys: Set<string>) => void;
+    /** Mudar este número limpa a seleção. */
+    clearSelectionTrigger?: number;
+    /** Chamado quando a tabela precisa do conjunto completo (ordenar, filtrar ou agrupar sem `allData`). */
+    onAllDataNeeded?: () => void;
+    /** Modo cliente sempre (paginação, ordenação e filtros sobre `allData`), mesmo sem interação. */
+    alwaysClient?: boolean;
+    /** Ordenação inicial: a coluna. */
+    defaultSortColumn?: string;
+    defaultSortDirection?: 'asc' | 'desc';
+    /** Recebe o estado da vista (ordenação e filtros) para uso por fora. Ver `TableView`. */
+    viewRef?: React.MutableRefObject<TableView<T> | null>;
+    /**
+     * A tabela ocupa a ALTURA TODA que o pai lhe der, em vez de encolher com o
+     * número de linhas. O cabeçalho fica fixo e só as linhas rolam.
+     *
+     * Sem isto, filtrar até sobrar uma linha encolhia a tabela, com meio ecrã em
+     * branco por baixo e o rodapé a meio da página.
+     *
+     * Precisa de um pai com altura DEFINIDA (ex: `flex-1 min-h-0` dentro de uma
+     * coluna de altura fixa). Para uma tabela pequena dentro de uma caixa, que
+     * deve encolher com o conteúdo, deixar desligado.
+     */
+    fillHeight?: boolean;
+    /** Sem `fillHeight`: altura máxima da caixa (ex: `400` ou `'60vh'`), a partir da qual as linhas rolam. */
+    maxHeight?: number | string;
+    /**
+     * Quantas linhas a tabela está MESMO a mostrar, e se os filtros do cabeçalho
+     * contam para isso.
+     *
+     * Uma contagem por fora (ex: o total que o servidor devolveu) não sabe dos
+     * filtros de coluna, que são cá de dentro: filtrar até sobrar uma linha
+     * deixava "14 223 resultados" por cima de uma lista de uma.
+     *
+     * `filtered: false` quer dizer "não contes comigo": não há filtros de coluna,
+     * ou o conjunto completo ainda não chegou.
+     *
+     * `selfPaginated`: com o conjunto completo, a tabela ignora a página que lhe
+     * dão e pagina-se a si mesma. Quem a alimenta deve então esconder a SUA
+     * paginação, que deixa de ter efeito.
+     */
+    onVisibleChange?: (v: {
+        visible: number;
+        filtered: boolean;
+        selfPaginated: boolean;
+    }) => void;
+    /**
+     * Quantas colunas do início ficam congeladas no scroll horizontal. A caixa de
+     * seleção, quando existe, vai junto.
+     */
+    frozenColumns?: number;
+    /**
+     * Arrastar os cabeçalhos para mudar a ordem das colunas. Opt-in: a tabela só
+     * avisa que coluna foi largada antes de qual. A ordem é de quem a alimenta,
+     * que a guarda e muda `columns`.
+     *
+     * `beforeKey: null` = largada depois da última. Esc durante o arrasto desfaz.
+     */
+    onMoveColumn?: (key: string, beforeKey: string | null) => void;
+    /**
+     * Com `fillHeight`: cada coluna fica com a largura do valor MAIS LARGO de
+     * todo o `allData` (ou do título, se for maior), e não com a da página à
+     * vista. Mudar de página ou filtrar não mexe nas larguras.
+     *
+     * Para conjuntos que já vêm inteiros: mede um exemplar de cada valor
+     * distinto de cada coluna.
+     */
+    measureAllData?: boolean;
+    /**
+     * Com `fillHeight`: barras de scroll desenhadas por cima das linhas, em vez
+     * das do browser. A vertical do browser obrigava o cabeçalho a reservar-lhe
+     * espaço; a horizontal punha uma faixa grossa por baixo das linhas.
+     */
+    overlayScrollbars?: boolean;
+    /** Classes da faixa dos títulos (com `onMoveColumn`). Por omissão `bg-slate-50`. */
+    headerRowClassName?: string;
+    /**
+     * Com `overlayScrollbars`: a barra horizontal centrada na aresta de baixo
+     * (meio por cima do que vem a seguir). Desligar quando a tabela vive numa
+     * caixa com `overflow-hidden`, senão a barra aparece cortada ao meio.
+     */
+    scrollbarOnEdge?: boolean;
+    /**
+     * Com `overlayScrollbars`: a barra horizontal numa faixa própria POR BAIXO
+     * das linhas (12px), em vez de por cima da última linha à vista.
+     */
+    horizontalScrollbarBelow?: boolean;
+    /**
+     * A carregar: linhas-esqueleto nas colunas verdadeiras em vez do spinner ao
+     * centro. O `loadingLabel` fica só para leitores de ecrã.
+     */
+    skeleton?: boolean;
+    /**
+     * Com mais colunas à direita do que cabem, a aresta direita esbate-se em vez
+     * de cortar as colunas a seco. Some ao chegar à última coluna.
+     */
+    fadeRight?: boolean;
+    /** Classes extra por linha (ex: uma cor por grupo de linhas). */
+    rowClassName?: (row: T) => string | undefined;
+    /** Textos da tabela e dos filtros. Por omissão em português. */
+    labels?: Partial<TableLabels>;
+}
+/**
+ * A barra de paginação em cima da tabela (a do `PaginatedTable`), em vez da
+ * troca de páginas no fundo. Interna: a app escolhe o `PaginatedTable`, não
+ * liga isto na `Table`.
+ */
+export interface PaginacaoNoTopo {
+    /** Total de linhas no servidor, quando é ele que pagina. */
+    total?: number;
+    /** Página atual do servidor (a contar de 1). Com `onPageChange`, é o servidor que pagina. */
+    page?: number;
+    onPageChange?: (page: number) => void;
+    /** Tamanhos de página à escolha. Sem isto não há escolha. */
+    pageSizeOptions?: number[];
+    onPageSizeChange?: (pageSize: number) => void;
+}
+/** A tabela, com tudo. A `Table` e o `PaginatedTable` são predefinições dela. */
+export declare function TableBase<T>({ paginacaoNoTopo, columns: colunasBase, data, allData, pageSize, rowKey, onRowClick, onRowDoubleClick, loading: isLoading, allDataLoading: isAllDataLoading, loadingLabel, emptyLabel, emptySubLabel, storageKey, selectable, onSelectionChange, clearSelectionTrigger, onAllDataNeeded: onDataNeeded, alwaysClient, defaultSortColumn: defaultSortCol, defaultSortDirection: defaultSortDir, viewRef, fillHeight: preencheAltura, onVisibleChange: onVista, frozenColumns: colunasFixas, onMoveColumn: onMoverColuna, measureAllData: larguraPeloConjunto, overlayScrollbars: barraSobreposta, headerRowClassName: classeCabecalho, scrollbarOnEdge: barraNaBorda, horizontalScrollbarBelow: barraHorizontalFora, skeleton: esqueletoAoCarregar, fadeRight: esbaterDireita, rowClassName, maxHeight, labels, }: TableProps<T> & {
+    paginacaoNoTopo?: PaginacaoNoTopo;
+}): React.JSX.Element;
+/**
+ * Tabela com ordenação, filtros por coluna, agrupamento, seleção e colunas que
+ * se arrastam para mudar a ordem. Com o conjunto completo (`allData`) pagina-se
+ * a si mesma, com a troca de páginas no fundo.
+ *
+ * Para a paginação EM CIMA, com a contagem e o tamanho de página (uma lista de
+ * página inteira), ver o [PaginatedTable](?path=/docs/v1-components-tables-paginatedtable--docs).
+ */
+export default function Table<T>(props: TableProps<T>): React.JSX.Element;

package/dist/types/v1/components/tables/Table/labels.d.ts

@@ -0,0 +1,54 @@
+/** Os textos da tabela e dos filtros. Por omissão em português; a app troca os que quiser (ex: noutra língua). */
+export interface TableLabels {
+    /** Sem linhas para mostrar (quando não há `emptyLabel`). */
+    empty: string;
+    page: string;
+    /** Nome acessível da navegação entre páginas. */
+    pagination: string;
+    /** O nome das linhas na contagem (`PaginatedTable`), ex: "linhas", "ordens". */
+    rowsNoun: (count: number) => string;
+    /** Na contagem filtrada (`PaginatedTable`): "1 de 120 ordens". */
+    of: string;
+    /** Cada opção do tamanho de página (`PaginatedTable`). */
+    perPage: (size: number) => string;
+    /** Nome acessível da escolha do tamanho de página. */
+    pageSize: string;
+    prev: string;
+    next: string;
+    apply: string;
+    cancel: string;
+    search: string;
+    noResults: string;
+    clearFilter: string;
+    clearAll: string;
+    clearGroups: string;
+    /** O "+N" dos chips que não cabem na barra (`PaginatedTable`), para leitores de ecrã. */
+    moreChips: (count: number) => string;
+    /** O × de um chip de filtro ou agrupamento. */
+    removeChip: (chip: string) => string;
+    /** O rótulo do chip de um agrupamento, antes do nome da coluna. */
+    groupedBy: string;
+    selectAll: string;
+    selectAllFound: (count: number) => string;
+    /** Num chip de filtro com mais de dois valores escolhidos. */
+    selectedCount: (count: number) => string;
+    loadingOptions: string;
+    filterBy: (column: string) => string;
+    groupBy: (column: string) => string;
+    ungroupBy: (column: string) => string;
+    sortAsc: string;
+    sortDesc: string;
+    sortDateAsc: string;
+    sortDateDesc: string;
+    sortNumAsc: string;
+    sortNumDesc: string;
+    dateFrom: string;
+    dateTo: string;
+    min: string;
+    max: string;
+    /** Numa coluna de números: passar do intervalo para a lista de valores. */
+    showList: string;
+    /** Numa coluna de números: passar da lista de valores para o intervalo. */
+    showRange: string;
+}
+export declare const DEFAULT_TABLE_LABELS: TableLabels;

package/dist/types/v1/foundations/icons/icons.d.ts

@@ -0,0 +1,61 @@
+import React from 'react';
+/**
+ * Conjunto de ícones do V1: traço de 1,7 a 1,9 em grelha de 24, cor do texto
+ * (`currentColor`), sem preenchimento. Decorativos por omissão (`aria-hidden`):
+ * quem os usa dá o nome acessível ao botão ou etiqueta à volta.
+ */
+export interface IconProps {
+    /** Lado em px. */
+    size?: number;
+    className?: string;
+    /** Espessura do traço. Por omissão 1,8; mais grosso em ícones muito pequenos (ex: o visto de uma caixa). */
+    strokeWidth?: number;
+}
+/** Lido de um QR code. */
+export declare function QrCodeIcon(props: IconProps): React.JSX.Element;
+/** Identificado automaticamente (IA). */
+export declare function SparklesIcon(props: IconProps): React.JSX.Element;
+/** Pré-preenchido a partir de outro registo (ex: linha de um extrato). */
+export declare function PrefilledIcon(props: IconProps): React.JSX.Element;
+/** Bloqueado: o valor não se pode alterar. */
+export declare function LockIcon(props: IconProps): React.JSX.Element;
+/** Mais informação. */
+export declare function InfoIcon(props: IconProps): React.JSX.Element;
+export declare function SearchIcon(props: IconProps): React.JSX.Element;
+export declare function CheckIcon(props: IconProps): React.JSX.Element;
+export declare function ChevronDownIcon(props: IconProps): React.JSX.Element;
+export declare function ChevronUpIcon(props: IconProps): React.JSX.Element;
+export declare function ChevronLeftIcon(props: IconProps): React.JSX.Element;
+export declare function ChevronRightIcon(props: IconProps): React.JSX.Element;
+/** Ordenável: ainda sem ordem escolhida. */
+export declare function ChevronsUpDownIcon(props: IconProps): React.JSX.Element;
+/** Filtro (funil). */
+export declare function FilterIcon(props: IconProps): React.JSX.Element;
+/** Fechar, remover (×). */
+export declare function CloseIcon(props: IconProps): React.JSX.Element;
+/** Abrir o menu (gaveta em ecrãs pequenos). */
+export declare function MenuIcon(props: IconProps): React.JSX.Element;
+/** Agrupar (camadas). */
+export declare function LayersIcon(props: IconProps): React.JSX.Element;
+/** Expandir o menu lateral recolhido. */
+export declare function PanelOpenIcon(props: IconProps): React.JSX.Element;
+/** Lista de valores. */
+export declare function ListIcon(props: IconProps): React.JSX.Element;
+/** Tema claro. */
+export declare function SunIcon(props: IconProps): React.JSX.Element;
+/** Tema escuro. */
+export declare function MoonIcon(props: IconProps): React.JSX.Element;
+/** Tema do sistema. */
+export declare function MonitorIcon(props: IconProps): React.JSX.Element;
+/** Idioma. */
+export declare function GlobeIcon(props: IconProps): React.JSX.Element;
+/** Terminar sessão. */
+export declare function LogOutIcon(props: IconProps): React.JSX.Element;
+/** Abre fora da aplicação (separador novo). */
+export declare function ExternalLinkIcon(props: IconProps): React.JSX.Element;
+/** Atenção (avisos, confirmações perigosas). */
+export declare function WarningIcon(props: IconProps): React.JSX.Element;
+/** Erro. */
+export declare function ErrorIcon(props: IconProps): React.JSX.Element;
+/** Intervalo (mínimo e máximo). */
+export declare function SlidersIcon(props: IconProps): React.JSX.Element;

package/dist/types/v1/index.d.ts

@@ -0,0 +1,81 @@
+export { default as DocumentDropzone, accepts as documentDropzoneAccepts } from './components/documents/DocumentDropzone/DocumentDropzone';
+export type { DocumentDropzoneProps, DocumentDropzoneLabels } from './components/documents/DocumentDropzone/DocumentDropzone';
+export { default as PdfPreview } from './primitives/documents/PdfPreview/PdfPreview';
+export type { PdfPreviewProps } from './primitives/documents/PdfPreview/PdfPreview';
+export { configurePdfWorker } from './primitives/documents/PdfPreview/pdfjs';
+export { scanQRCodes, configureQRScanner } from './capabilities/documents/QRScanning/scanQRCodes';
+export type { ScanQRCodesOptions } from './capabilities/documents/QRScanning/scanQRCodes';
+export { useTheme, applyTheme, themeBootScript, THEME_STORAGE_KEY } from './capabilities/theme/useTheme';
+export type { Theme } from './capabilities/theme/useTheme';
+export { useIsDark } from './capabilities/theme/useIsDark';
+export { QrCodeIcon, SparklesIcon, PrefilledIcon, LockIcon, InfoIcon, SearchIcon, CheckIcon, ChevronDownIcon, ChevronLeftIcon, CloseIcon, MenuIcon, PanelOpenIcon, SunIcon, MoonIcon, MonitorIcon, GlobeIcon, LogOutIcon, ExternalLinkIcon, WarningIcon, ErrorIcon, ChevronUpIcon, ChevronRightIcon, ChevronsUpDownIcon, FilterIcon, LayersIcon, ListIcon, SlidersIcon, } from './foundations/icons/icons';
+export type { IconProps } from './foundations/icons/icons';
+export { default as TextInput } from './primitives/forms/TextInput/TextInput';
+export type { TextInputProps } from './primitives/forms/TextInput/TextInput';
+export { default as SelectInput } from './primitives/forms/SelectInput/SelectInput';
+export type { SelectInputProps } from './primitives/forms/SelectInput/SelectInput';
+export { default as TextArea } from './primitives/forms/TextArea/TextArea';
+export type { TextAreaProps } from './primitives/forms/TextArea/TextArea';
+export { default as DateInput } from './primitives/forms/DateInput/DateInput';
+export type { DateInputProps } from './primitives/forms/DateInput/DateInput';
+export { default as SearchInput } from './primitives/forms/SearchInput/SearchInput';
+export type { SearchInputProps } from './primitives/forms/SearchInput/SearchInput';
+export { default as Checkbox } from './primitives/forms/Checkbox/Checkbox';
+export type { CheckboxProps } from './primitives/forms/Checkbox/Checkbox';
+export { default as LookupInput } from './primitives/forms/LookupInput/LookupInput';
+export type { LookupInputProps } from './primitives/forms/LookupInput/LookupInput';
+export { default as FormGrid, FormDivider } from './components/forms/FormGrid/FormGrid';
+export type { FormGridProps } from './components/forms/FormGrid/FormGrid';
+export { default as FormField, FieldMark } from './components/forms/FormField/FormField';
+export type { FormFieldProps, FieldMarkProps } from './components/forms/FormField/FormField';
+export { default as Button } from './primitives/buttons/Button/Button';
+export type { ButtonProps } from './primitives/buttons/Button/Button';
+export { default as Dialog, useDialogContainer } from './components/overlays/Dialog/Dialog';
+export type { DialogProps } from './components/overlays/Dialog/Dialog';
+export { default as ConfirmDialog, ConfirmProvider, useConfirm } from './components/overlays/ConfirmDialog/ConfirmDialog';
+export type { ConfirmDialogProps, ConfirmOptions, ConfirmProviderProps } from './components/overlays/ConfirmDialog/ConfirmDialog';
+export { default as Tooltip } from './components/overlays/Tooltip/Tooltip';
+export type { TooltipProps } from './components/overlays/Tooltip/Tooltip';
+export { default as TooltipLayer } from './components/overlays/Tooltip/TooltipLayer';
+export { default as ToastProvider, useToast } from './components/feedback/Toast/Toast';
+export type { ToastApi, ToastOptions, ToastProviderProps, ToastTone } from './components/feedback/Toast/Toast';
+export { default as AppShell } from './components/layout/AppShell/AppShell';
+export type { AppShellProps, AppShellLabels } from './components/layout/AppShell/AppShell';
+export { default as Page } from './components/layout/Page/Page';
+export type { PageProps } from './components/layout/Page/Page';
+export { default as PageHeader } from './components/layout/PageHeader/PageHeader';
+export type { PageHeaderProps, BreadcrumbItem } from './components/layout/PageHeader/PageHeader';
+export { default as SideNav } from './components/layout/SideNav/SideNav';
+export type { SideNavProps, SideNavItem, SideNavBadge, SideNavLabels, SideNavTheme } from './components/layout/SideNav/SideNav';
+export { Badge } from './primitives/display/Badge/Badge';
+export type { BadgeProps, BadgeTone } from './primitives/display/Badge/Badge';
+export { Notice } from './primitives/display/Notice/Notice';
+export type { NoticeProps, NoticeTone } from './primitives/display/Notice/Notice';
+export { Avatar, initials } from './primitives/display/Avatar/Avatar';
+export type { AvatarProps, AvatarSize } from './primitives/display/Avatar/Avatar';
+export { Person } from './primitives/display/Person/Person';
+export type { PersonProps } from './primitives/display/Person/Person';
+export { Pagination } from './components/data/Pagination/Pagination';
+export type { PaginationProps, PaginationLabels } from './components/data/Pagination/Pagination';
+export { FilterChips } from './primitives/display/FilterChips/FilterChips';
+export type { FilterChipsProps, FilterChipItem } from './primitives/display/FilterChips/FilterChips';
+export { Card } from './primitives/display/Card/Card';
+export type { CardProps } from './primitives/display/Card/Card';
+export { Kpi } from './primitives/display/Kpi/Kpi';
+export type { KpiProps, KpiTone } from './primitives/display/Kpi/Kpi';
+export { default as Tabs } from './primitives/navigation/Tabs/Tabs';
+export type { TabsProps, TabsSingleProps, TabsMultipleProps, TabItem } from './primitives/navigation/Tabs/Tabs';
+export { default as SegmentedControl } from './primitives/buttons/SegmentedControl/SegmentedControl';
+export type { SegmentedControlProps, SegmentedOption } from './primitives/buttons/SegmentedControl/SegmentedControl';
+export { default as Table } from './components/tables/Table/Table';
+export type { TableProps, TableColumn, TableView, TableState } from './components/tables/Table/Table';
+export { default as PaginatedTable } from './components/tables/PaginatedTable/PaginatedTable';
+export type { PaginatedTableProps } from './components/tables/PaginatedTable/PaginatedTable';
+export { DEFAULT_TABLE_LABELS } from './components/tables/Table/labels';
+export type { TableLabels } from './components/tables/Table/labels';
+export { default as ListItem } from './primitives/lists/ListItem/ListItem';
+export type { ListItemProps, ListItemContent } from './primitives/lists/ListItem/ListItem';
+export { default as ListFinder } from './components/lists/ListFinder/ListFinder';
+export type { ListFinderProps } from './components/lists/ListFinder/ListFinder';
+export { DEFAULT_LIST_FINDER_LABELS } from './components/lists/ListFinder/labels';
+export type { ListFinderLabels } from './components/lists/ListFinder/labels';

package/dist/types/v1/primitives/buttons/Button/Button.d.ts

@@ -0,0 +1,35 @@
+import React from 'react';
+export interface ButtonProps extends React.ButtonHTMLAttributes<HTMLButtonElement> {
+    /**
+     * `primary`: a ação principal (navy, uma por ecrã). `secondary` (contorno): as
+     * outras (ex: Fechar, Exportar). `success` (verde): aprovar, aceitar, concluir.
+     * `danger`: apaga ou não se pode desfazer (ex: Apagar). `ghost`: sem contorno,
+     * para ações discretas.
+     *
+     * Sobre fundo escuro (ex: uma barra navy): `inverse` (contorno branco) para as
+     * ações normais e `accent` (turquesa) para a principal.
+     */
+    variant?: 'primary' | 'secondary' | 'success' | 'danger' | 'ghost' | 'inverse' | 'accent';
+    /** `sm`: mais pequeno (28px), para ícones dentro de linhas de tabelas e cartões. */
+    size?: 'md' | 'sm';
+    /** Ligado (ex: um filtro ativo): o `secondary` fica navy. Dá `aria-pressed`. */
+    active?: boolean;
+    /** Ícone antes do texto (ex: `<CheckIcon size={13} />`). Sem texto, o botão fica quadrado (dar `aria-label`). */
+    icon?: React.ReactNode;
+    /** A guardar/enviar: mostra uma roda no lugar do ícone e fica desativado. */
+    loading?: boolean;
+}
+/**
+ * Botão de ação (ex: Confirmar, Novo projeto). Por omissão não submete
+ * formulários (`type="button"`); para submeter, passar `type="submit"`.
+ *
+ * O aspeto dos portais proef: MAIÚSCULAS, letra grossa e espaçada, a mesma
+ * altura dos outros controlos (32px).
+ *
+ * **Aceita os atributos HTML do [&lt;button&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Reference/Elements/button)**, com o mesmo comportamento: `onClick`, `disabled`, `type`, `name`, `form`, `ref`, ...
+ * Só os próprios do V1 aparecem na tabela abaixo.
+ *
+ * **Onde aparece:** no rodapé de um [Dialog](?path=/docs/v1-components-overlays-dialog--docs) (ver [Formulário em modal](?path=/docs/v1-patterns-forms-formulário-em-modal--docs)).
+ */
+declare const Button: React.ForwardRefExoticComponent<ButtonProps & React.RefAttributes<HTMLButtonElement>>;
+export default Button;

package/dist/types/v1/primitives/buttons/SegmentedControl/SegmentedControl.d.ts

@@ -0,0 +1,28 @@
+import React from 'react';
+export interface SegmentedOption<V extends string = string> {
+    value: V;
+    label: React.ReactNode;
+    /** Ícone antes do texto (ex: um ícone do lucide com `size={12}`). */
+    icon?: React.ReactNode;
+    disabled?: boolean;
+}
+export interface SegmentedControlProps<V extends string = string> {
+    /** A opção escolhida. A app guarda este estado. */
+    value: V;
+    options: SegmentedOption<V>[];
+    onChange: (value: V) => void;
+    /** Rótulo visível à esquerda (ex: "Situação"). Também é o nome do grupo para leitores de ecrã. */
+    label?: string;
+    /** Nome do grupo para leitores de ecrã, quando não há `label` visível. */
+    ariaLabel?: string;
+    className?: string;
+}
+/**
+ * Escolha de uma opção entre poucas, em botões lado a lado (ex: Dia · Semana ·
+ * Mês, ou Todos · Atribuição · Devolução). Para filtros e modos de vista numa
+ * barra; para trocar de vista com conteúdo próprio, usar `Tabs`.
+ *
+ * Mesmo aspeto dos `Tabs` segmentados: botões juntos numa caixa, o escolhido
+ * a navy. Setas ← → mudam de opção.
+ */
+export default function SegmentedControl<V extends string = string>({ value, options, onChange, label, ariaLabel, className, }: SegmentedControlProps<V>): React.JSX.Element;

package/dist/types/v1/primitives/buttons/SegmentedControl/segmentedStyles.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Aspeto "segmentado": botões juntos numa caixa, o escolhido a navy.
+ *
+ * Partilhado pelo `SegmentedControl` (escolher um valor, ex: 7D · 30D) e pelos
+ * `Tabs` com `variant="segmented"` (trocar de vista): fazem coisas diferentes
+ * mas têm de parecer o mesmo controlo.
+ *
+ * A caixa tem a altura dos outros controlos (`--spacing-control`), para ficar
+ * alinhada com botões, pesquisa e campos na mesma barra.
+ */
+export declare const SEGMENTED: {
+    list: string;
+    item: string;
+    active: string;
+    idle: string;
+};

package/dist/types/v1/primitives/display/Avatar/Avatar.d.ts

@@ -0,0 +1,30 @@
+import React from 'react';
+/** Iniciais a partir do nome completo (primeira + última). Sem nome: "?". */
+export declare function initials(fullName?: string | null): string;
+/** `none`: sem tamanho nem cores das iniciais — quem usa põe as classes (ex: o UserAvatar da Legacy). */
+export type AvatarSize = 'sm' | 'md' | 'lg' | 'none';
+export interface AvatarProps {
+    name?: string | null;
+    /** URL da fotografia. Sem ela (ou se falhar) ficam as iniciais. */
+    photo?: string | null;
+    /** Fotografia maior para o cartão (por omissão, a mesma). */
+    photoLarge?: string | null;
+    email?: string | null;
+    company?: string | null;
+    department?: string | null;
+    jobTitle?: string | null;
+    /** `sm` 24px (tabelas e listas), `md` 28px, `lg` 32px (formulários, cabeçalhos). */
+    size?: AvatarSize;
+    /** Cartão com a fotografia grande e os dados ao passar o rato (no toque, ao tocar). */
+    card?: boolean;
+    className?: string;
+}
+/**
+ * A fotografia de uma pessoa (ou as iniciais), redonda. Com `card`, mostra a
+ * fotografia grande, o email, a empresa, o departamento e a função ao passar o rato;
+ * no toque abre e fecha ao tocar, sem passar o toque à linha por baixo.
+ *
+ * Para uma pessoa com o nome ao lado (ex: numa tabela), usar o `Person`.
+ */
+export default function Avatar({ name, photo, photoLarge, email, company, department, jobTitle, size, card, className, }: AvatarProps): React.JSX.Element;
+export { Avatar };

package/dist/types/v1/primitives/display/Badge/Badge.d.ts

@@ -0,0 +1,25 @@
+import React from 'react';
+/**
+ * Estados com significado: `ok` (verde), `risco` (âmbar), `incumprido` (vermelho).
+ * Sem estado: `neutral` (cinzento) e `accent` (azul).
+ * Classificações (distinguir valores que não são bons nem maus, ex: origem, tipo,
+ * área): `blue`, `violet`, `cyan`, `orange`, `pink` — sem significado, só para os
+ * valores se reconhecerem de relance. Não usar verde/âmbar/vermelho para isto.
+ */
+export type BadgeTone = 'ok' | 'risco' | 'incumprido' | 'neutral' | 'accent' | 'blue' | 'violet' | 'cyan' | 'orange' | 'pink';
+/** Aceita os atributos do `<span>` (ex: `data-tip`, `title`, `aria-label`). */
+export interface BadgeProps extends Omit<React.HTMLAttributes<HTMLSpanElement>, 'children'> {
+    tone?: BadgeTone;
+    /** Ponto à esquerda. Por omissão sim; sem ponto para etiquetas que não são um estado (ex: categoria). */
+    dot?: boolean;
+    /** Ícone no lugar do ponto (ex: `<Eye size={11} />`). */
+    icon?: React.ReactNode;
+    children: React.ReactNode;
+}
+/**
+ * Etiqueta em pílula: o estado de um registo (ex: "Publicado", "Em atraso") ou
+ * uma classificação (ex: a categoria, a origem). As cores dos estados vêm dos
+ * tokens, por isso acompanham o tema escuro.
+ */
+export default function Badge({ tone, dot, icon, children, className, ...props }: BadgeProps): React.JSX.Element;
+export { Badge };

package/dist/types/v1/primitives/display/Card/Card.d.ts

@@ -0,0 +1,22 @@
+import React from 'react';
+export interface CardProps extends Omit<React.HTMLAttributes<HTMLDivElement>, 'title'> {
+    /** Título no topo (ex: "Por estado"). */
+    title?: React.ReactNode;
+    /** Ações à direita do título (ex: um botão, um seletor). */
+    actions?: React.ReactNode;
+    /** `none`: sem margem interior, para tabelas ou listas que vão até à borda. */
+    padding?: 'md' | 'none';
+    /** @deprecated Nome antigo (Legacy) de `actions`. */
+    extra?: React.ReactNode;
+}
+/**
+ * Cartão: agrupa um bloco de conteúdo (um gráfico, uma lista, um resumo) num
+ * fundo próprio com cantos redondos, com título opcional.
+ *
+ * Os indicadores soltos usam o `Kpi`; as tabelas da biblioteca já trazem o seu
+ * contorno e não vão dentro de um cartão.
+ *
+ * **Aceita os atributos HTML do `<div>`** (ex: `id`, `data-*`, `onClick`).
+ */
+export default function Card({ title, actions, extra, padding, className, children, ...props }: CardProps): React.JSX.Element;
+export { Card };

package/dist/types/v1/primitives/display/FilterChips/FilterChips.d.ts

@@ -0,0 +1,33 @@
+import React from 'react';
+export interface FilterChipItem {
+    /** Identificador único da etiqueta. */
+    key: string;
+    /** Texto (ex: "Estado: Cancelado"). */
+    label: React.ReactNode;
+    /** Tira este filtro. */
+    onRemove: () => void;
+    /** Ícone antes do texto (ex: o de agrupar). */
+    icon?: React.ReactNode;
+    /** `filter` (turquesa): um filtro. `group` (violeta): um agrupamento. */
+    tone?: 'filter' | 'group';
+    /** Cores próprias (classes), em vez das do `tone` — ex: a cor do estado. */
+    colorClassName?: string;
+}
+export interface FilterChipsProps {
+    items: FilterChipItem[];
+    /** Tira todos. Sem isto não aparece o "Limpar tudo". */
+    onClearAll?: () => void;
+    clearAllLabel?: string;
+    /** Nome do botão × para leitores de ecrã (recebe o texto da etiqueta, quando é texto). */
+    removeLabel?: string;
+    className?: string;
+}
+/**
+ * Etiquetas dos filtros ativos, cada uma com × para o tirar, e "Limpar tudo".
+ *
+ * É o mesmo que a `DataTable` mostra por cima da tabela: usar este sempre que
+ * um ecrã mostra os filtros escolhidos (ex: ao clicar num gráfico), para se
+ * reconhecerem como a mesma coisa em todo o lado. Sem itens não desenha nada.
+ */
+export default function FilterChips({ items, onClearAll, clearAllLabel, removeLabel, className }: FilterChipsProps): React.JSX.Element | null;
+export { FilterChips };