@proef/common-ui 0.0.0-stage → 2.2.0

package/dist/types/legacy/components/organisms/Kanban/Kanban.d.ts

@@ -0,0 +1,44 @@
+import React, { type ReactNode } from 'react';
+/**
+ * Quadro em colunas, ao estilo do Planner/Jira.
+ *
+ * Não conhece domínio nenhum: recebe as colunas, os itens, a função que diz em
+ * que coluna cai cada item e o que desenhar dentro do cartão. Foi extraído do
+ * quadro do portal de Tickets, que estava preso aos tipos daquele projeto.
+ *
+ * Arrastar e largar é opcional: sem `onMover`, o quadro é só de leitura — é o
+ * caso de quem mostra dados de um sistema externo que não pode escrever.
+ * @deprecated Legacy — não usar em código novo. Ver Storybook › Legacy.
+ */
+export interface KanbanColuna {
+    id: string;
+    titulo: string;
+    /** Classe de cor do ponto do cabeçalho (ex: `bg-emerald-500`). */
+    cor?: string;
+    /** Conteúdo extra no cabeçalho, à direita da contagem (ex: total de horas). */
+    extra?: ReactNode;
+}
+/** @deprecated Legacy — não usar em código novo. Ver Storybook › Legacy. */
+export interface KanbanProps<T> {
+    colunas: KanbanColuna[];
+    itens: T[];
+    /** Em que coluna cai o item — devolve o `id` da coluna. */
+    colunaDoItem: (item: T) => string;
+    chaveDoItem: (item: T) => string;
+    /** Conteúdo do cartão. O invólucro (moldura, arrastar, clique) é do Kanban. */
+    cartao: (item: T) => ReactNode;
+    onAbrirItem?: (item: T) => void;
+    /**
+     * Largar um cartão noutra coluna. Sem isto não há arrastar: um quadro de
+     * leitura não deve sugerir que se pode mexer.
+     */
+    onMover?: (itemId: string, colunaId: string) => void;
+    /** Botão "+" no cabeçalho de cada coluna. */
+    onAdicionar?: (colunaId: string) => void;
+    labels?: {
+        semItens?: string;
+        adicionar?: string;
+    };
+}
+/** @deprecated Legacy — não usar em código novo. Ver Storybook › Legacy. */
+export default function Kanban<T>({ colunas, itens, colunaDoItem, chaveDoItem, cartao, onAbrirItem, onMover, onAdicionar, labels, }: KanbanProps<T>): React.JSX.Element;

package/dist/types/legacy/components/organisms/LazyLoader/LazyLoader.d.ts

@@ -0,0 +1,16 @@
+import React, { ReactNode } from 'react';
+interface LazyLoaderProps<T> {
+    endpoint: string;
+    params?: Record<string, unknown>;
+    children: (items: T[], loading: boolean, error: ReactNode | null) => ReactNode;
+    scrollableTarget?: string;
+    className?: string;
+    height?: number | string;
+    scrollThreshold?: number | string;
+    limit?: number;
+}
+/** @deprecated Legacy — não usar em código novo. Ver Storybook › Legacy. */
+export declare const LazyLoader: <T extends {
+    id: string | number;
+}>({ endpoint, params, children, scrollableTarget, className, height, scrollThreshold, limit, }: LazyLoaderProps<T>) => React.JSX.Element;
+export {};

package/dist/types/legacy/components/organisms/MapaPontos/MapaPontos.d.ts

@@ -0,0 +1,206 @@
+import React from 'react';
+import 'leaflet.markercluster';
+import 'leaflet.heat';
+/**
+ * Mapa de pontos com agrupamento, para listas grandes.
+ *
+ * Genérico de propósito: recebe pontos com coordenadas e devolve as funções de
+ * cor e de rótulo a quem o usa. Não sabe o que é uma ordem de trabalho nem um
+ * cliente — quem sabe é o ecrã que o monta.
+ *
+ * O Leaflet entra por import ESTÁTICO, e não dinâmico.
+ *
+ * As duas alternativas falharam, cada uma à sua maneira:
+ *  - import dinâmico + webpack `externals` → o UMD gera
+ *    `try{return require("leaflet")}catch{}`, e no browser não há `require`:
+ *    o catch engole o erro e o componente diz que falta a biblioteca;
+ *  - import dinâmico sem `externals` → o Leaflet fica em chunks separados
+ *    (481.bundle.js) que vivem no node_modules da biblioteca e nunca chegam ao
+ *    dist da aplicação: o pedido devolve o index.html e dá
+ *    `Unexpected token '<'`.
+ *
+ * Estático, o bundler da aplicação resolve-o como qualquer outro import. Custa
+ * ~150 KB a quem não usa mapas — o preço de funcionar sempre.
+ *
+ * As folhas de estilo do Leaflet têm de ser importadas pelo projeto:
+ *   import 'leaflet/dist/leaflet.css'
+ *   import 'leaflet.markercluster/dist/MarkerCluster.css'
+ * @deprecated Legacy — não usar em código novo. Ver Storybook › Legacy.
+ */
+export interface PontoMapa {
+    id: string;
+    lat: number;
+    lng: number;
+}
+/**
+ * Um fundo de mapa: o que o selector mostra e o que o Leaflet carrega.
+ * @deprecated Legacy — não usar em código novo. Ver Storybook › Legacy.
+ */
+export interface FundoMapa {
+    id: string;
+    rotulo: string;
+    url: string;
+    atribuicao?: string;
+    /** Fundos de satélite ficam melhor sem a dessaturação do tema `suave`. */
+    semFiltro?: boolean;
+    /**
+     * Lado do tile em píxeis. 256 por omissão, que é o do OpenStreetMap.
+     *
+     * Importa para quem paga por pedido: um tile de 512 cobre a área de quatro
+     * de 256, e o mesmo ecrã passa a custar um quarto. Com 512 é preciso
+     * `deslocamentoZoom: -1`, senão o mapa desenha um nível de zoom ao lado.
+     */
+    tamanhoTile?: number;
+    deslocamentoZoom?: number;
+}
+/**
+ * Uma fatia do anel de um marcador: uma cor e quantos registos ela representa.
+ * @deprecated Legacy — não usar em código novo. Ver Storybook › Legacy.
+ */
+export interface FatiaMapa {
+    cor: string;
+    n: number;
+    /** Nome legível, para a dica nativa do marcador. */
+    rotulo?: string;
+}
+/** @deprecated Legacy — não usar em código novo. Ver Storybook › Legacy. */
+export interface MapaPontosLabels {
+    semPontos: string;
+    semBiblioteca: string;
+    aCarregar: string;
+    /** {n} é substituído pelo número de pontos fora do limite. */
+    truncado?: string;
+    fecharAviso?: string;
+}
+/** @deprecated Legacy — não usar em código novo. Ver Storybook › Legacy. */
+export interface MapaPontosProps<T extends PontoMapa> {
+    pontos: T[];
+    /** Cor do marcador. Devolver a mesma cor para todos é perfeitamente válido. */
+    cor?: (ponto: T) => string;
+    /** HTML do balão. Sem isto não há balão. */
+    balao?: (ponto: T) => string;
+    /**
+     * Forma do marcador.
+     *
+     * `circulo` para agregados — o tamanho pode variar com a contagem e lê-se
+     * como densidade. `pin` para registos individuais: a ponta assenta na
+     * coordenada exata, e é isso que se quer quando o ponto é um sítio e não um
+     * número.
+     */
+    forma?: 'circulo' | 'pin' | 'anel';
+    /**
+     * Composição do marcador, para a forma `anel`.
+     *
+     * Um agregado pintado de UMA cor — a do caso mais grave, ou a da contagem —
+     * diz "há aqui pelo menos um destes" e esconde tudo o resto: cinquenta
+     * registos misturados liam-se como cinquenta urgentes. As fatias mostram a
+     * composição sem obrigar a abrir o grupo, e deixam a cor dizer SITUAÇÃO
+     * enquanto o tamanho diz VOLUME — duas perguntas diferentes, dois canais.
+     */
+    fatias?: (ponto: T) => FatiaMapa[];
+    /**
+     * Selo por cima do marcador: uma marca que se soma à cor em vez de competir
+     * com ela (ex: "está suspensa"). Null não desenha nada.
+     */
+    selo?: (ponto: T) => {
+        texto: string;
+        cor: string;
+        titulo?: string;
+    } | null;
+    /**
+     * Contorno do marcador, por fora das fatias.
+     *
+     * Para uma segunda dimensão que não é exclusiva da primeira — um prazo
+     * excedido pode acontecer em qualquer estado, e por isso não pode ser uma
+     * fatia: somá-la ao anel faria as fatias deixarem de somar o total.
+     */
+    contorno?: (ponto: T) => string | null;
+    /** Raio do marcador em píxeis. Só se aplica à forma `circulo`. */
+    raio?: (ponto: T) => number;
+    /**
+     * Texto por cima do marcador (ex: a contagem de uma zona).
+     *
+     * Pensado para o modo agregado: em vez de desenhar dezenas de milhares de
+     * pontos, desenha-se um círculo por concelho com o número dentro. O mapa
+     * deixa de precisar de zoom para dizer alguma coisa.
+     */
+    rotulo?: (ponto: T) => string | null;
+    /**
+     * Marca o ponto como aproximado — desenhado a tracejado.
+     * Serve para distinguir uma morada confirmada de uma posição estimada, que
+     * no mapa parecem iguais e não são.
+     */
+    aproximado?: (ponto: T) => boolean;
+    onPontoClick?: (ponto: T) => void;
+    /** Centro inicial. Sem isto, enquadra-se pelos pontos. */
+    centro?: [number, number];
+    zoom?: number;
+    altura?: string;
+    /**
+     * Aspeto do fundo.
+     *
+     * `suave` dessatura os tiles por CSS, deixando os marcadores com cor — num
+     * mapa de dados, o fundo não deve disputar atenção com o que está em cima.
+     * Faz o que o basemap claro do CARTO fazia, sem precisar de chave.
+     */
+    tema?: 'normal' | 'suave';
+    /** Agrupar pontos próximos. Com milhares de pontos, desligar trava o browser. */
+    agrupar?: boolean;
+    /** Tiles. Por omissão, OpenStreetMap — sem necessidade de chave. */
+    urlTiles?: string;
+    atribuicaoTiles?: string;
+    /**
+     * Fundos alternativos, com um selector no canto do mapa.
+     *
+     * Os que precisam de chave ficam de fora por omissão: quem a tiver passa-os
+     * aqui, e a chave fica do lado de quem a tem em vez de vir na biblioteca.
+     */
+    fundos?: FundoMapa[];
+    /** Quantos pontos ficaram de fora, para avisar quem vê. */
+    truncadoEm?: number;
+    /**
+     * Um traçado a unir pontos, em [lat, lng].
+     *
+     * Serve para mostrar um percurso — a ordem por que se visita, e por onde se
+     * passa. Sem ele, uma sequência numerada obriga a segui-la com o olho de
+     * número em número, que é exactamente o trabalho que o mapa devia poupar.
+     *
+     * Quem passa o traçado decide o que ele é: se vier de um serviço de rotas,
+     * são estradas; se forem só as paragens, são linhas rectas. O componente
+     * desenha o que recebe e não opina — mas quem o usa deve dizer ao
+     * utilizador qual dos dois é.
+     */
+    percurso?: [number, number][] | null;
+    /**
+     * Mapa de calor por cima dos pontos.
+     *
+     * Responde a outra pergunta: os marcadores dizem o que cada ordem é, o calor
+     * diz onde há concentração. Com dez mil pontos, contar marcadores não se faz
+     * — e agrupados, o número do grupo diz quantos mas não onde eles se apertam
+     * lá dentro.
+     *
+     * Soma-se aos marcadores em vez de os substituir: quem liga o calor quer ver
+     * a mancha E continuar a poder clicar numa ordem.
+     */
+    calor?: boolean;
+    /**
+     * Quanto cada ponto pesa no calor. Por omissão, um.
+     *
+     * Serve para quando um marcador representa muitos — um concelho com 300
+     * ordens não deve pesar o mesmo que uma ordem solta.
+     */
+    pesoCalor?: (p: T) => number;
+    /**
+     * Selecção por caixa: `Shift` + arrastar devolve os pontos dentro dela.
+     *
+     * Com `Shift` e não só arrastar, porque arrastar já é a forma de deslocar o
+     * mapa — tirar isso ao arrasto simples trocaria o gesto mais usado pelo mais
+     * raro.
+     */
+    onSeleccionarArea?: (pontos: T[]) => void;
+    legenda?: React.ReactNode;
+    labels?: Partial<MapaPontosLabels>;
+    className?: string;
+}
+/** @deprecated Legacy — não usar em código novo. Ver Storybook › Legacy. */
+export default function MapaPontos<T extends PontoMapa>({ pontos, cor, balao, forma, fatias, selo, contorno, raio, rotulo, aproximado, onPontoClick, centro, zoom, altura, agrupar, tema, urlTiles, atribuicaoTiles, truncadoEm, percurso, calor, pesoCalor, fundos, onSeleccionarArea, legenda, labels, className, }: MapaPontosProps<T>): React.JSX.Element;

package/dist/types/legacy/components/organisms/PainelFiltros/PainelFiltros.d.ts

@@ -0,0 +1,69 @@
+import React from 'react';
+/**
+ * Painel lateral de filtros facetados.
+ *
+ * O que o torna útil é a CONTAGEM ao lado de cada opção: diz quantos registos
+ * ficariam se a opção fosse escolhida, com os restantes filtros mantidos. Quem
+ * monta o painel é que calcula essas contagens — o componente não sabe o que
+ * está a contar, e tem de ser assim: a conta certa exige tirar a própria
+ * dimensão do filtro, e isso só o servidor sabe fazer.
+ *
+ * Genérico de propósito: recebe secções e opções, devolve escolhas.
+ * @deprecated Legacy — não usar em código novo. Ver Storybook › Legacy.
+ */
+export interface OpcaoFiltro {
+    valor: string;
+    rotulo: string;
+    /** Quantos registos esta opção daria. `undefined` não desenha contagem. */
+    total?: number;
+}
+/** @deprecated Legacy — não usar em código novo. Ver Storybook › Legacy. */
+export type TipoCampoFiltro = 'opcoes' | 'atalhos' | 'livre';
+/** @deprecated Legacy — não usar em código novo. Ver Storybook › Legacy. */
+export interface CampoFiltro {
+    /** Identifica o campo nos valores devolvidos. */
+    chave: string;
+    rotulo: string;
+    tipo?: TipoCampoFiltro;
+    opcoes?: OpcaoFiltro[];
+    /**
+     * Escolha única. Por omissão o campo é múltiplo — é o que a maioria das
+     * dimensões quer, e forçar única obrigaria a limpar antes de trocar.
+     */
+    unico?: boolean;
+    /** A partir de quantas opções aparece a caixa de pesquisa. */
+    pesquisarACimaDe?: number;
+    /** Conteúdo próprio (datas, interruptores…), quando `tipo` é `livre`. */
+    conteudo?: React.ReactNode;
+}
+/** @deprecated Legacy — não usar em código novo. Ver Storybook › Legacy. */
+export interface SeccaoFiltros {
+    chave: string;
+    titulo: string;
+    campos: CampoFiltro[];
+    /** Aberta na primeira vez. Depois manda o que o utilizador fizer. */
+    aberta?: boolean;
+}
+/** @deprecated Legacy — não usar em código novo. Ver Storybook › Legacy. */
+export interface PainelFiltrosLabels {
+    titulo: string;
+    limpar: string;
+    pesquisar: string;
+    semOpcoes: string;
+    ocultar: string;
+    mostrar: string;
+    verTodas: string;
+    verMenos: string;
+}
+/** @deprecated Legacy — não usar em código novo. Ver Storybook › Legacy. */
+export interface PainelFiltrosProps {
+    seccoes: SeccaoFiltros[];
+    /** Valores actuais: chave do campo → valores escolhidos. */
+    valores: Record<string, string[]>;
+    onChange: (chave: string, valores: string[]) => void;
+    onLimpar?: () => void;
+    labels?: Partial<PainelFiltrosLabels>;
+    className?: string;
+}
+/** @deprecated Legacy — não usar em código novo. Ver Storybook › Legacy. */
+export default function PainelFiltros({ seccoes, valores, onChange, onLimpar, labels, className, }: PainelFiltrosProps): React.JSX.Element;

package/dist/types/legacy/components/organisms/PesquisaRapida/PesquisaRapida.d.ts

@@ -0,0 +1,53 @@
+import React from 'react';
+/**
+ * Pesquisa rápida — a paleta que abre com Ctrl/Cmd + K.
+ *
+ * Genérica: recebe uma função de procura e devolve o que foi escolhido. Não
+ * sabe o que procura nem onde — quem a monta é que sabe.
+ *
+ * O atalho é registado em `window` e não num campo: a utilidade disto é poder
+ * ser chamada de qualquer sítio da aplicação sem ter de lá chegar com o rato.
+ * @deprecated Legacy — não usar em código novo. Ver Storybook › Legacy.
+ */
+export interface ResultadoPesquisa {
+    id: string;
+    titulo: string;
+    /** Segunda linha: o que distingue dois resultados com o mesmo título. */
+    detalhe?: string;
+    /** Agrupador opcional, mostrado como cabeçalho. */
+    grupo?: string;
+}
+/** @deprecated Legacy — não usar em código novo. Ver Storybook › Legacy. */
+export interface PesquisaRapidaLabels {
+    titulo: string;
+    placeholder: string;
+    semResultados: string;
+    aEscrever: string;
+    dica: string;
+}
+/** @deprecated Legacy — não usar em código novo. Ver Storybook › Legacy. */
+export interface PesquisaRapidaProps {
+    aberta: boolean;
+    onFechar: () => void;
+    /** Procura. Pode devolver poucos resultados — a lista não é paginada. */
+    procurar: (termo: string) => Promise<ResultadoPesquisa[]>;
+    onEscolher: (resultado: ResultadoPesquisa) => void;
+    /** Mínimo de caracteres antes de procurar. */
+    minimo?: number;
+    labels?: Partial<PesquisaRapidaLabels>;
+}
+/** @deprecated Legacy — não usar em código novo. Ver Storybook › Legacy. */
+export default function PesquisaRapida({ aberta, onFechar, procurar, onEscolher, minimo, labels, }: PesquisaRapidaProps): React.JSX.Element | null;
+/**
+ * Regista Ctrl/Cmd + K e devolve o estado de abertura.
+ *
+ * Em hook para quem usa a paleta não ter de repetir a escuta do teclado — e
+ * porque o atalho tem de ser removido ao desmontar, que é o passo que se
+ * esquece.
+ * @deprecated Legacy — não usar em código novo. Ver Storybook › Legacy.
+ */
+export declare function usarAtalhoPesquisa(): {
+    aberta: boolean;
+    abrir: () => void;
+    fechar: () => void;
+};

package/dist/types/legacy/components/organisms/Profile/Profile.d.ts

@@ -0,0 +1,12 @@
+import React, { ReactNode } from 'react';
+import { LoggedUser } from '../../../types/LoggedUser';
+import './Profile.scss';
+type Props = {
+    user: LoggedUser;
+    handleLogout: () => void;
+    notifications?: ReactNode;
+    logoutLabel?: string;
+};
+/** @deprecated Legacy — não usar em código novo. Ver Storybook › Legacy. */
+declare const Profile: ({ user, handleLogout, notifications, logoutLabel }: Props) => React.JSX.Element;
+export default Profile;

package/dist/types/legacy/components/organisms/RoleGuard/RoleGuard.d.ts

@@ -0,0 +1,37 @@
+import React, { type ReactNode } from 'react';
+/**
+ * Restringe o acesso ao portal a um conjunto de app roles.
+ *
+ * Não conhece o MSAL da aplicação: recebe funções para obter o token. É
+ * deliberado — quando o bundler duplica o `@azure/msal-react`, um `useMsal`
+ * dentro da biblioteca lê um contexto diferente do da app, a conta vem a null e
+ * o acesso é negado a quem tem a role certa. Passando o token por fora, isso
+ * não pode acontecer.
+ *
+ * As roles vêm no ACCESS token da API, não no id token — é o erro mais comum
+ * nesta integração, e a razão de `obterToken` dever pedir o scope da API.
+ * @deprecated Legacy — não usar em código novo. Ver Storybook › Legacy.
+ */
+export interface RoleGuardProps {
+    /** Roles com acesso. Lista vazia = qualquer autenticado entra. */
+    rolesPermitidas: string[];
+    /** Há sessão iniciada? Enquanto false, mostra-se `semSessao`. */
+    temSessao: boolean;
+    /** Ainda a resolver a autenticação — evita decidir cedo de mais. */
+    aAutenticar?: boolean;
+    /** Token de acesso da API. `forcarRenovacao` ignora a cache. */
+    obterToken: (forcarRenovacao?: boolean) => Promise<string>;
+    /** Chamado quando falta consentimento e é preciso um redirect interactivo. */
+    onPrecisaInteracao?: () => void;
+    semSessao: ReactNode;
+    aCarregar: ReactNode;
+    semPermissao: ReactNode;
+    children: ReactNode;
+}
+/**
+ * Lê a claim `roles` de um JWT, sem validar a assinatura (quem valida é a API).
+ * @deprecated Legacy — não usar em código novo. Ver Storybook › Legacy.
+ */
+export declare function lerRolesDoToken(accessToken: string): string[];
+/** @deprecated Legacy — não usar em código novo. Ver Storybook › Legacy. */
+export default function RoleGuard({ rolesPermitidas, temSessao, aAutenticar, obterToken, onPrecisaInteracao, semSessao, aCarregar, semPermissao, children, }: RoleGuardProps): React.JSX.Element;

package/dist/types/legacy/components/organisms/Selector/Selector.d.ts

@@ -0,0 +1,20 @@
+import React, { ReactNode } from 'react';
+import { IconProp } from '@fortawesome/fontawesome-svg-core';
+import { Fetcher } from '../../../types/Fetcher';
+import './Selector.scss';
+import { SelectableElement } from '../../../types/SelectableElement';
+type SelectorProps<T extends SelectableElement> = {
+    title: string;
+    onClose: () => void;
+    onConfirm: (selected: T[]) => void;
+    onDisabled?: (disabled: T) => ReactNode;
+    initiallySelected: T[];
+    blocked?: string[];
+    single?: boolean;
+    icon: IconProp;
+    fetcher: Fetcher;
+    working?: boolean;
+};
+/** @deprecated Legacy — não usar em código novo. Ver Storybook › Legacy. */
+export declare const Selector: <T extends SelectableElement>({ title, icon, onClose, onConfirm, initiallySelected, blocked, fetcher, single, working, onDisabled, }: SelectorProps<T>) => React.JSX.Element;
+export {};

package/dist/types/legacy/components/organisms/StatusMatrix/StatusMatrix.d.ts

@@ -0,0 +1,54 @@
+import React from 'react';
+/** @deprecated Legacy — não usar em código novo. Ver Storybook › Legacy. */
+export interface StatusMatrixRow {
+    id: string;
+    label: string;
+    /** Cabeçalho de secção mostrado antes da linha quando muda (ex: "Fundações"). */
+    group?: string;
+    /** Texto pequeno à direita do rótulo (ex: "12/40"). */
+    sublabel?: string;
+}
+/** @deprecated Legacy — não usar em código novo. Ver Storybook › Legacy. */
+export interface StatusMatrixColumn {
+    id: string;
+    label: string;
+    /** Faixa por cima das colunas consecutivas com o mesmo grupo (ex: "Ramal 1"). */
+    group?: string;
+}
+/** @deprecated Legacy — não usar em código novo. Ver Storybook › Legacy. */
+export interface StatusMatrixStatus {
+    label: string;
+    /** Cor da célula (CSS). */
+    color: string;
+}
+/** @deprecated Legacy — não usar em código novo. Ver Storybook › Legacy. */
+export interface StatusMatrixCell {
+    /** Chave em `statuses`. Sem estado = célula vazia. */
+    status?: string;
+    /** Texto curto dentro da célula (ex: nº de dias). */
+    text?: string;
+    tooltip?: React.ReactNode;
+    /** Mostra um ponto de aviso no canto da célula. */
+    warning?: boolean;
+}
+/** @deprecated Legacy — não usar em código novo. Ver Storybook › Legacy. */
+export interface StatusMatrixProps {
+    rows: StatusMatrixRow[];
+    columns: StatusMatrixColumn[];
+    statuses: Record<string, StatusMatrixStatus>;
+    /** Conteúdo de cada célula; null/undefined = vazia. */
+    cell: (row: StatusMatrixRow, column: StatusMatrixColumn) => StatusMatrixCell | null | undefined;
+    cellSize?: number;
+    labelWidth?: number;
+    /** Texto do canto superior esquerdo (ex: "Tarefa \ Apoio"). */
+    corner?: string;
+    /** Mostra a legenda dos estados por cima da matriz. */
+    showLegend?: boolean;
+    onCellClick?: (row: StatusMatrixRow, column: StatusMatrixColumn) => void;
+    emptyText?: string;
+    className?: string;
+    /** Altura (px) do cabeçalho das colunas (rótulos verticais). Omisso = automática pelo rótulo mais comprido (64–260). */
+    columnHeaderHeight?: number;
+}
+/** @deprecated Legacy — não usar em código novo. Ver Storybook › Legacy. */
+export default function StatusMatrix({ rows, columns, statuses, cell, cellSize, labelWidth, corner, showLegend, onCellClick, emptyText, className, columnHeaderHeight, }: StatusMatrixProps): React.JSX.Element;

package/dist/types/legacy/components/ui/Avisos.d.ts

@@ -0,0 +1,33 @@
+import React, { type ReactNode } from 'react';
+/** @deprecated Legacy — usar `useToast` do V1. */
+export type TipoAviso = 'sucesso' | 'erro' | 'aviso' | 'info';
+/** @deprecated Legacy — usar `ToastOptions` do V1. */
+export interface OpcoesAviso {
+    /** Botão no aviso (ex: "Tentar de novo", "Desfazer"). */
+    acao?: {
+        rotulo: string;
+        onClick: () => void;
+    };
+    /** Milissegundos até fechar sozinho. 0 = só fecha à mão. */
+    duracao?: number;
+}
+/** @deprecated Legacy — usar `ToastApi` do V1. */
+export interface AvisosApi {
+    sucesso: (mensagem: ReactNode, opcoes?: OpcoesAviso) => number;
+    erro: (mensagem: ReactNode, opcoes?: OpcoesAviso) => number;
+    aviso: (mensagem: ReactNode, opcoes?: OpcoesAviso) => number;
+    info: (mensagem: ReactNode, opcoes?: OpcoesAviso) => number;
+    fechar: (id: number) => void;
+}
+/** @deprecated Legacy — usar `ToastProviderProps` do V1. */
+export interface AvisosProviderProps {
+    children: ReactNode;
+    /** Rótulo do botão de fechar (leitores de ecrã). */
+    rotuloFechar?: string;
+    /** Máximo de avisos visíveis ao mesmo tempo; os mais antigos saem. */
+    maximo?: number;
+}
+/** @deprecated Legacy — usar `ToastProvider` do V1. */
+export declare function AvisosProvider({ children, rotuloFechar, maximo }: AvisosProviderProps): React.JSX.Element;
+/** @deprecated Legacy — usar `useToast` do V1. */
+export declare function useAvisos(): AvisosApi;

package/dist/types/legacy/components/ui/BarraAcoes.d.ts

@@ -0,0 +1,19 @@
+import React, { type ReactNode } from 'react';
+/** @deprecated Legacy — não usar em código novo. Ver Storybook › Legacy. */
+export interface BarraAcoesProps {
+    /** Ações principais, à direita (ex: "Guardar"). A principal vai em último. */
+    children: ReactNode;
+    /** Ações secundárias, à esquerda (ex: "Voltar à lista"). */
+    esquerda?: ReactNode;
+    /** Fica colada ao fundo do ecrã enquanto se desce na página. Por omissão sim. */
+    fixa?: boolean;
+}
+/**
+ * Barra de ações de uma página de detalhe ou formulário.
+ *
+ * Fixa ao fundo para "Guardar" estar sempre à vista: numa página longa o botão
+ * no topo desaparece ao descer, e os botões repetidos em cima e em baixo
+ * acabavam com textos diferentes.
+ * @deprecated Legacy — não usar em código novo. Ver Storybook › Legacy.
+ */
+export default function BarraAcoes({ children, esquerda, fixa }: BarraAcoesProps): React.JSX.Element;

package/dist/types/legacy/components/ui/CabecalhoPagina.d.ts

@@ -0,0 +1,23 @@
+import React, { type ReactNode } from 'react';
+/** @deprecated Legacy — usar `BreadcrumbItem` do V1. */
+export interface NivelCaminho {
+    rotulo: ReactNode;
+    /** Ligação normal. Para o router da app, usar `onClick` (ex: `() => navigate('/x')`). */
+    href?: string;
+    onClick?: () => void;
+}
+/** @deprecated Legacy — usar `PageHeaderProps` do V1. */
+export interface CabecalhoPaginaProps {
+    titulo: ReactNode;
+    descricao?: ReactNode;
+    /** Caminho até à página (área › lista › registo). O último nível é a página atual. */
+    caminho?: NivelCaminho[];
+    /** Botões da página (ex: "Novo", "Editar"). */
+    acoes?: ReactNode;
+    /** Linha extra por baixo da descrição (etiquetas de estado, responsável…). */
+    extra?: ReactNode;
+    /** Rótulo acessível da navegação do caminho. */
+    rotuloCaminho?: string;
+}
+/** @deprecated Legacy — usar `PageHeader` (ou `Page`) do V1. */
+export default function CabecalhoPagina({ titulo, descricao, caminho, acoes, extra, rotuloCaminho }: CabecalhoPaginaProps): React.JSX.Element;

package/dist/types/legacy/components/ui/CaixaPesquisa.d.ts

@@ -0,0 +1,14 @@
+import React from 'react';
+/** @deprecated Legacy — usar `SearchInputProps` do V1. */
+export interface CaixaPesquisaProps {
+    valor: string;
+    onMudar: (valor: string) => void;
+    placeholder?: string;
+    /** Nome acessível (leitores de ecrã). Por omissão, o placeholder. */
+    rotulo?: string;
+    /** Largura (classes tailwind). Por omissão w-56. */
+    className?: string;
+    autoFocus?: boolean;
+}
+/** @deprecated Legacy — usar `SearchInput` do V1. */
+export default function CaixaPesquisa({ valor, onMudar, placeholder, rotulo, className, autoFocus }: CaixaPesquisaProps): React.JSX.Element;

package/dist/types/legacy/components/ui/Confirmacao.d.ts

@@ -0,0 +1,24 @@
+import React, { type ReactNode } from 'react';
+/** @deprecated Legacy — usar `ConfirmDialog` ou `useConfirm` do V1. */
+export interface ConfirmacaoProps {
+    aberto: boolean;
+    titulo: ReactNode;
+    /** Explicação: o que vai acontecer, a que registo, se é reversível. */
+    children?: ReactNode;
+    onConfirmar: () => void;
+    onCancelar: () => void;
+    /** Texto do botão — o verbo da ação ("Eliminar", "Submeter"), não "OK". */
+    textoConfirmar?: string;
+    textoCancelar?: string;
+    /** `perigo` pinta a ação a vermelho e põe o foco em Cancelar. */
+    variante?: 'normal' | 'perigo';
+    /** A ação está a correr: botões desativados. */
+    aConfirmar?: boolean;
+    /** Uma segunda saída (ex: "Desativar" em vez de eliminar, "Eliminar só o contrato"). */
+    acaoSecundaria?: {
+        rotulo: string;
+        onClick: () => void;
+    };
+}
+/** @deprecated Legacy — usar `ConfirmDialog` ou `useConfirm` do V1. */
+export default function Confirmacao({ aberto, titulo, children, onConfirmar, onCancelar, textoConfirmar, textoCancelar, variante, aConfirmar, acaoSecundaria, }: ConfirmacaoProps): React.JSX.Element;