@proef/common-ui 0.0.0-stage → 2.2.0

package/dist/types/legacy/components/molecules/DataTable/DataTable.d.ts

@@ -0,0 +1,344 @@
+import React from 'react';
+/** @deprecated Legacy — não usar em código novo. Ver Storybook › Legacy. */
+export interface DataTableColumn<T> {
+    key: string;
+    label: string;
+    /** Valor usado p/ ordenar, filtrar e exportar. Sem isto usa-se row[key]. */
+    value?: (row: T) => string | number | null | undefined;
+    /** Conteúdo apresentado. Sem isto mostra o value. */
+    render?: (row: T) => React.ReactNode;
+    sortType?: 'text' | 'number' | 'date';
+    /**
+     * Fixa a coluna no scroll horizontal (position: sticky).
+     * `true` ou `'left'` prende à esquerda; `'right'` prende à direita — útil para
+     * a coluna de ações, que de outro modo fica fora de vista (e com os botões
+     * cortados) assim que a tabela e mais larga do que o espaço disponível.
+     */
+    sticky?: boolean | 'left' | 'right';
+    align?: 'left' | 'right' | 'center';
+    /** minWidth em px. */
+    width?: number;
+    /** Largura máxima em px (o conteúdo corta com "…" e mostra o valor completo no tooltip). Sobrepõe-se a `defaultMaxColumnWidth`. */
+    maxWidth?: number;
+    /**
+     * Filtro por coluna (distinct dos valores, multi-seleção; intervalo nas colunas number/date).
+     * Por omissão LIGADO em todas as colunas com dados — `false` desliga. Colunas sem dados (ex.: ações) não o mostram.
+     */
+    filterable?: boolean;
+    /** Desliga a ordenação nesta coluna (default: ordenável). */
+    sortable?: boolean;
+    /**
+     * Agrupar por esta coluna. Por omissão LIGADO nas colunas de texto com dados e DESLIGADO nas de valor contínuo
+     * (`sortType` number/date, ou com `groupAggregate`), onde cada linha daria o seu próprio grupo. `true`/`false` forçam.
+     */
+    groupable?: boolean;
+    /** Chave usada só para ORDENAR os grupos (sobrepõe-se a `value` ao agrupar por esta coluna). */
+    groupSortKey?: (row: T) => string | number | null | undefined;
+    /**
+     * Filtros extra no cabeçalho desta coluna — para filtrar por um campo que não tem coluna
+     * própria (ex: filtrar a coluna "Obra" por concelho). Partilham o funil da coluna: o popup
+     * mostra no topo um seletor (coluna + cada filtro extra) para escolher a lista a filtrar.
+     */
+    extraFilters?: {
+        key: string;
+        label: string;
+        value: (row: T) => string | number | null | undefined;
+    }[];
+    headerClassName?: string;
+    cellClassName?: string;
+    /** Conteúdo extra por baixo do título da coluna (ex: somatório). Recebe as linhas já filtradas. */
+    headerExtra?: (rows: T[]) => React.ReactNode;
+    /**
+     * Valor desta coluna na linha de cada grupo (ex: soma em €), alinhado com a coluna. Recebe as linhas do grupo
+     * (já filtradas). Também é usado na linha de total (`totalRow`), com todas as linhas filtradas.
+     */
+    groupAggregate?: (rows: T[]) => React.ReactNode;
+    /**
+     * Cores por valor para os chips de filtro ativo (valor → classes tailwind). Com isto, cada
+     * valor escolhido ganha o seu chip, removível à parte.
+     */
+    valueChipColors?: Record<string, string>;
+    /**
+     * Vários valores de filtro por linha (ex.: um equipamento com várias aplicações). Alimenta a lista do funil,
+     * o filtro (a linha passa se QUALQUER um dos seus valores estiver escolhido) e os chips. Sem isto, um valor
+     * por linha (`value`). Ao agrupar, usa o `value` da linha (a combinação de valores, ex.: "Hardware, Rede").
+     */
+    filterValues?: (row: T) => ReadonlyArray<string | number | null | undefined>;
+    /**
+     * Escondida à partida no layout de colunas (`useColumnLayout` e o "Repor" do `ColumnPicker`). A tabela em
+     * si desenha as colunas que recebe.
+     */
+    defaultHidden?: boolean;
+}
+/**
+ * Ordenação, filtros e agrupamento do cabeçalho vivem dentro da tabela. Quem está por fora
+ * (ex: exportar para Excel, guardar uma vista) precisa deles — daí este handle, preenchido
+ * em `viewRef`.
+ * @deprecated Legacy — não usar em código novo. Ver Storybook › Legacy.
+ */
+export interface DataTableView<T> {
+    /** Aplica ordenação + filtros de coluna a qualquer lista (ex: ao dataset completo). */
+    apply: (rows: T[]) => T[];
+    /** Linhas à vista, já filtradas e ordenadas (todas as páginas). */
+    rows: T[];
+    hasFilters: boolean;
+    /**
+     * Há filtros, ordenação ou agrupamento ativos — tudo do lado do cliente. Quem alimenta a
+     * tabela usa isto para não largar o dataset completo: sem ele, filtrar sobre a página dá
+     * uma lista vazia com o total nos milhares.
+     */
+    precisaDataset: boolean;
+    /** Estado guardável da vista. */
+    estado: () => DataTableEstado;
+    /** Repõe um estado guardado (ex: ao aplicar uma vista do utilizador). */
+    repor: (e: DataTableEstado | undefined) => void;
+}
+/**
+ * O que uma vista guardada leva da tabela. Sets viram arrays porque isto é serializado
+ * para JSON.
+ * @deprecated Legacy — não usar em código novo. Ver Storybook › Legacy.
+ */
+export interface DataTableEstado {
+    columnFilters?: Record<string, string[]>;
+    rangeFilters?: Record<string, {
+        min?: number;
+        max?: number;
+    }>;
+    sortKey?: string | null;
+    sortDir?: 'asc' | 'desc';
+    /** Colunas por que se agrupa, pela ordem dos níveis. */
+    groupBy?: string[];
+}
+/** @deprecated Legacy — não usar em código novo. Ver Storybook › Legacy. */
+export interface DataTableLabels {
+    /** {count} é substituído pelo total (após filtros). */
+    results: string;
+    /** Tooltip da pega de redimensionar coluna. */
+    resizeColumn?: string;
+    export: string;
+    loading: string;
+    empty: string;
+    error: string;
+    search: string;
+    clear: string;
+    clearAll: string;
+    noOptions: string;
+    /** {count} = nº de valores selecionados (quando > 2, mostra "N sel."). */
+    selected: string;
+    /** {shown}/{total} — aparece quando o distinct da coluna tem mais valores do que os mostrados. */
+    moreOptions: string;
+    /** Aviso no popup enquanto `allData` não chegou — as opções ainda são só as de `data`. */
+    loadingOptions: string;
+    /** Placeholders dos dois campos do filtro por intervalo nas colunas numéricas. */
+    min: string;
+    max: string;
+    /** Rótulos dos dois campos do filtro por intervalo nas colunas de datas (default 'From'/'To'). */
+    from?: string;
+    to?: string;
+    /** {page}/{pages} são substituídos. */
+    page: string;
+    prev: string;
+    next: string;
+    /** Ordenação a partir do popup de filtro, nas colunas de texto (A→Z / Z→A). */
+    sortAsc: string;
+    sortDesc: string;
+    /** Ordenação a partir do popup nas colunas de datas (default 'Oldest first'/'Newest first'). */
+    sortOldest?: string;
+    sortNewest?: string;
+    /** Ordenação a partir do popup nas colunas numéricas (default 'Smallest first'/'Largest first'). */
+    sortSmallest?: string;
+    sortLargest?: string;
+    /** Agrupamento. {label} é o nome da coluna. */
+    groupBy: string;
+    ungroup: string;
+    clearGroups: string;
+    /** Selector de linhas por página (só com `pageSizeOptions`). */
+    perPage: string;
+    /** `filterMode: 'excel'`: primeira linha da lista de valores, o "(Selecionar tudo)" do Excel. */
+    selectAll: string;
+    /** O mesmo, com pesquisa activa — aí só abrange os valores que correspondem. */
+    selectAllResults: string;
+    /** Rótulo da linha de total (`totalRow`). */
+    total: string;
+    /** Nome acessível da zona com scroll horizontal (só com `scrollAffordance`). */
+    scrollRegion?: string;
+}
+interface DataTableProps<T> {
+    columns: DataTableColumn<T>[];
+    data: T[];
+    /**
+     * Dataset completo, para o distinct dos filtros e para filtrar/ordenar/agrupar sobre ele.
+     *
+     * Sem isto a tabela só conhece `data` — e numa app que pagina no servidor isso são as
+     * linhas da página, pelo que o funil de cada coluna listava só esses valores (e filtrar
+     * por um valor que só existe noutra página dava zero linhas).
+     */
+    allData?: T[];
+    /**
+     * Chamado quando a tabela precisa de `allData` e ainda não o tem: ao abrir um funil, ao
+     * ordenar, ao agrupar, ou quando já há filtros ativos. É o sinal para a app ir buscar o
+     * dataset completo — uma vez, e só se alguém mexer.
+     */
+    onDataNeeded?: () => void;
+    /** `allData` a caminho — mostra um aviso no popup em vez de opções silenciosamente incompletas. */
+    isAllDataLoading?: boolean;
+    /** Força o modo cliente mesmo sem interação (desde que `allData` exista). */
+    alwaysClient?: boolean;
+    /**
+     * Total de linhas no servidor (paginação de servidor). Fora do modo cliente, `data` é só a página à
+     * vista — o texto de resultados da toolbar usa então este total em vez do nº de linhas de `data`.
+     * Em modo cliente (ou com filtros ativos) conta-se, como sempre, as linhas filtradas.
+     */
+    totalCount?: number;
+    /**
+     * Avisa quando a tabela passa (ou deixa) de trabalhar sobre `allData`. Quem tem paginação
+     * de servidor por fora usa isto para a esconder: em modo cliente as linhas à vista já não
+     * são a página que esse controlo diz estar a mostrar.
+     */
+    onClientModeChange?: (active: boolean) => void;
+    /** Chave estável por linha. Obrigatória para a seleção; sem ela usa-se o índice. */
+    rowKey?: (row: T, index: number) => string | number;
+    onRowClick?: (row: T) => void;
+    /** Duplo clique — atalho para o detalhe sem roubar o clique simples (seleção, edição inline). */
+    onRowDoubleClick?: (row: T) => void;
+    /**
+     * Classes extra por linha, a partir dos dados — estado de risco, linha desactivada, etc.
+     * Vem depois das classes da tabela, por isso ganha em caso de conflito.
+     */
+    rowClassName?: (row: T) => string | undefined;
+    /**
+     * Chamado quando as linhas à vista mudam (filtros do cabeçalho, ordenação ou dados), com todas as páginas.
+     * Serve para indicadores fora da tabela (ex.: cartões no topo da página) acompanharem os filtros.
+     */
+    onVisibleRowsChange?: (rows: T[]) => void;
+    isLoading?: boolean;
+    isError?: boolean;
+    /** max-height do viewport com scroll (default 70vh). */
+    maxHeight?: string;
+    /**
+     * Linhas por página. Sem isto, mostra tudo (pode ser lento com muitas linhas).
+     *
+     * Com `allData` quem pagina `data` é a app (paginação de servidor): a tabela só pagina em modo cliente
+     * (filtros/ordenação/agrupamento ativos), senão paginava outra vez a página que já recebeu.
+     * Com `storageKey`, o tamanho escolhido no selector fica na sessão (`dt_pagesize_<storageKey>`).
+     */
+    pageSize?: number;
+    /** Mostra um selector de linhas por página com estas opções. */
+    pageSizeOptions?: number[];
+    /** Caixa de seleção por linha + no cabeçalho. */
+    selectable?: boolean;
+    onSelectionChange?: (selectedKeys: Set<string>) => void;
+    /** Linhas que se podem selecionar (default: todas). As outras mostram a caixa desativada e ficam fora do "selecionar todas". */
+    isRowSelectable?: (row: T) => boolean;
+    /**
+     * Seleção inicial (chaves de `rowKey`). Volta a ser aplicada quando muda por valor (não por identidade) —
+     * ex.: uma pré-seleção vinda de outro ecrã. Não chama `onSelectionChange`: quem a passa já a conhece.
+     */
+    initialSelectedKeys?: Iterable<string | number>;
+    /** Mudar este número limpa a seleção (ex: depois de uma ação em massa). */
+    clearSelectionTrigger?: number;
+    /** Guarda filtros e intervalos no sessionStorage com esta chave (e as larguras das colunas no localStorage). */
+    storageKey?: string;
+    /** Largura máxima por defeito das colunas, em px (default 360). `0` desliga o limite. */
+    defaultMaxColumnWidth?: number;
+    /** Colunas redimensionáveis arrastando o limite do cabeçalho; duplo clique repõe (default true). */
+    resizableColumns?: boolean;
+    /**
+     * "Ordenar A→Z / Z→A" no topo do popup de filtro. Ligado por omissão (o cabeçalho é o mesmo em todos os
+     * portais); `false` desliga. Os textos dependem do `sortType`: `labels.sortAsc`/`sortDesc` no texto,
+     * `sortOldest`/`sortNewest` nas datas e `sortSmallest`/`sortLargest` nos números (por omissão em inglês).
+     */
+    sortFromFilter?: boolean;
+    /**
+     * Semântica do filtro por coluna.
+     *
+     * - `'simple'`: abre com tudo **desmarcado** e marcar um valor quer dizer "só este".
+     *   Conjunto vazio = sem filtro.
+     * - `'excel'` (default): abre com tudo **marcado** e desmarca-se o que se quer excluir, com uma linha
+     *   `(Selecionar tudo)` no topo e curingas (`*`, `?`, `~`) na pesquisa. É o que a folha de
+     *   cálculo faz, e o que quem vem de lá espera. Conjunto vazio = **nada seleccionado**, e a
+     *   tabela fica sem linhas.
+     *
+     * No modo Excel o distinto da coluna aberta deixa de respeitar os filtros das outras: o que a
+     * lista mostra tem de ser exactamente o que a selecção materializa, senão marcar "tudo"
+     * apagaria em silêncio os valores que outra coluna escondeu.
+     */
+    filterMode?: 'simple' | 'excel';
+    /** Ordenação inicial. */
+    defaultSortKey?: string;
+    defaultSortDir?: 'asc' | 'desc';
+    /** Recebe o estado da vista (ordenação + filtros + agrupamento) para uso externo. */
+    viewRef?: React.MutableRefObject<DataTableView<T> | null>;
+    /** Mostra o botão de exportar. Sem `onExport`, faz download CSV nativo. */
+    exportFileName?: string;
+    /** Export custom (ex: XLSX na app). Recebe as linhas filtradas + ordenadas. */
+    onExport?: (rows: T[]) => void;
+    /** Conteúdo extra na toolbar (à direita, antes do export). */
+    extraToolbar?: React.ReactNode;
+    /** Texto por baixo do estado vazio. */
+    emptySubLabel?: string;
+    /** Ilustração do estado vazio. */
+    emptyIcon?: React.ReactNode;
+    labels?: Partial<DataTableLabels>;
+    /** Linha de total no fim (fica fixa em baixo), com o `groupAggregate` de cada coluna sobre as linhas filtradas. */
+    totalRow?: boolean;
+    /** Agrupamento inicial (chaves de colunas, por ordem de nível). A pessoa pode mudá-lo depois. */
+    defaultGroupBy?: string[];
+    /**
+     * Agrupamento controlado (chaves de colunas, por ordem de nível). Com isto a tabela usa este valor (ignora
+     * `defaultGroupBy` e a sessão) e as mudanças da pessoa chegam por `onGroupByChange`.
+     */
+    groupBy?: string[];
+    /** Chamado quando a pessoa muda o agrupamento (também sem `groupBy`, só para acompanhar). */
+    onGroupByChange?: (keys: string[]) => void;
+    /** Chamado quando a ordenação muda (`null` = sem ordenação). Também ao montar, se a inicial não for nenhuma. */
+    onSortChange?: (sort: {
+        key: string;
+        dir: 'asc' | 'desc';
+    } | null) => void;
+    /**
+     * Chamado quando os filtros por valor das colunas mudam (chave → valores escolhidos). Também ao montar, se
+     * vierem filtros da sessão. Só os ativos; os intervalos ficam de fora (ver `viewRef`).
+     */
+    onColumnFiltersChange?: (filters: Record<string, string[]>) => void;
+    /**
+     * Torna focável a zona com scroll horizontal (`role="region"`, nome em `labels.scrollRegion`) e deixa
+     * deslizá-la com ←/→/Home/End. Default desligado.
+     */
+    scrollAffordance?: boolean;
+}
+/**
+ * Timestamp de um valor de coluna de data. As apps passam a data já formatada (`value:
+ * dataPt(...)` → "14/08/2026"), e `new Date("14/08/2026")` devolve `Invalid Date` — ou, pior,
+ * lê "06/03/2026" como 3 de junho, à americana. Daí o parse explícito de dd/mm/aaaa antes do
+ * fallback para o `Date` nativo (que trata do ISO).
+ * @deprecated Legacy — não usar em código novo. Ver Storybook › Legacy.
+ */
+export declare function timestampDeData(v: unknown): number;
+/**
+ * Predicado da caixa de pesquisa do filtro por coluna, com os curingas do Excel.
+ *
+ * `*` = qualquer sequência, `?` = exactamente um carácter, `~` escapa qualquer um dos três. Sem
+ * curinga nenhum é "contém"; **com** curinga o padrão passa a ser comparado com o valor **inteiro**,
+ * e é daí que sai o "começa por" (`25VCT*`), o "termina em" (`*.fbo`) e o "tem isto no meio"
+ * (`*RA2*`).
+ *
+ * No Excel esse ancorar vive nos Filtros de Texto (Começa por/Termina em) e não na caixa de
+ * pesquisa, que é sempre "contém" — juntar os dois na caixa evita ter de trazer também o submenu, e
+ * sem curingas o comportamento é o mesmo dos dois lados.
+ *
+ * Tudo em minúsculas: quem chama passa a pesquisa e o valor já em minúsculas.
+ */
+export declare function pesquisaCuringa(q: string): (v: string) => boolean;
+/**
+ * Tabela genérica: ordenação, filtro por coluna com distinct (multi-seleção) e por intervalo,
+ * agrupamento multi-nível, seleção de linhas, colunas fixas (sticky), align/width, export
+ * (CSV nativo ou custom) e estados loading/vazio/erro. Sem dependências de ícones/i18n —
+ * textos via `labels`.
+ *
+ * Com paginação de servidor, passa também `allData`/`onDataNeeded`: sem o dataset completo,
+ * filtrar, ordenar e agrupar só olhariam para a página à vista.
+ * @deprecated Legacy — não usar em código novo. Ver Storybook › Legacy.
+ */
+export default function DataTable<T>({ columns, data, allData, onDataNeeded, isAllDataLoading, alwaysClient, totalCount, onClientModeChange, rowKey, onRowClick, onRowDoubleClick, rowClassName, onVisibleRowsChange, isLoading, isError, maxHeight, pageSize, pageSizeOptions, selectable, onSelectionChange, isRowSelectable, initialSelectedKeys, clearSelectionTrigger, storageKey, defaultMaxColumnWidth, resizableColumns, sortFromFilter, filterMode, defaultSortKey, defaultSortDir, viewRef, exportFileName, onExport, extraToolbar, emptySubLabel, emptyIcon, labels, totalRow, defaultGroupBy, groupBy, onGroupByChange, onSortChange, onColumnFiltersChange, scrollAffordance, }: DataTableProps<T>): React.JSX.Element;
+export {};

package/dist/types/legacy/components/molecules/FileDropzone/FileDropzone.d.ts

@@ -0,0 +1,25 @@
+import React from 'react';
+/** @deprecated Legacy — não usar em código novo. Ver Storybook › Legacy. */
+export interface FileDropzoneLabels {
+    /** Texto principal (ex: "Arraste os ficheiros para aqui ou clique para escolher"). */
+    title: string;
+    /** Texto secundário (ex: "Excel .xlsx, vários ficheiros"). */
+    hint?: string;
+    /** Mostrado enquanto `loading`. */
+    loading?: string;
+    /** Mostrado quando há ficheiros rejeitados pela extensão. {n} = quantidade. */
+    rejected?: string;
+}
+/** @deprecated Legacy — não usar em código novo. Ver Storybook › Legacy. */
+export interface FileDropzoneProps {
+    /** Extensões aceites, ex: ".xlsx" ou ".xlsx,.xls". */
+    accept?: string;
+    multiple?: boolean;
+    disabled?: boolean;
+    loading?: boolean;
+    onFiles: (files: File[]) => void;
+    labels: FileDropzoneLabels;
+    className?: string;
+}
+/** @deprecated Legacy — não usar em código novo. Ver Storybook › Legacy. */
+export default function FileDropzone({ accept, multiple, disabled, loading, onFiles, labels, className }: FileDropzoneProps): React.JSX.Element;

package/dist/types/legacy/components/molecules/LanguageSwitcher/LanguageSwitcher.d.ts

@@ -0,0 +1,33 @@
+import React from 'react';
+import type { SidebarLanguage } from '../../layout/Sidebar/Sidebar';
+/**
+ * Seletor de idioma.
+ *
+ * Não conhece o i18next: recebe os idiomas, o actual e o que fazer na escolha.
+ * É o que permite usá-lo com qualquer gestor de traduções — e testá-lo sem
+ * montar um.
+ */
+/**
+ * Idioma, compatível com o `SidebarLanguage` que o Layout já recebe.
+ *
+ * Estende-o em vez de criar um tipo paralelo: a mesma lista serve a sidebar e
+ * este seletor, e duas formas do mesmo conceito acabariam a divergir.
+ * `name` é o nome por extenso, que só este mostra.
+ * @deprecated Legacy — não usar em código novo. Ver Storybook › Legacy.
+ */
+export interface Idioma extends SidebarLanguage {
+    /** Nome por extenso na lista (ex: 'Português'). Sem isto usa-se o `label`. */
+    name?: string;
+}
+/** @deprecated Legacy — não usar em código novo. Ver Storybook › Legacy. */
+export interface LanguageSwitcherProps {
+    idiomas: Idioma[];
+    /** Código do idioma activo. Aceita 'pt-PT' — compara pelo prefixo. */
+    actual: string;
+    onEscolher: (code: string) => void;
+    /** `dark` para fundos escuros (ecrã de login), `pill` para botões lado a lado. */
+    variant?: 'dark' | 'light' | 'pill';
+    compact?: boolean;
+}
+/** @deprecated Legacy — não usar em código novo. Ver Storybook › Legacy. */
+export default function LanguageSwitcher({ idiomas, actual, onEscolher, variant, compact, }: LanguageSwitcherProps): React.JSX.Element;

package/dist/types/legacy/components/molecules/Modal/Modal.d.ts

@@ -0,0 +1,22 @@
+import React from 'react';
+import './Modal.scss';
+/**
+ * Largura do modal.
+ *
+ * Sem `size` o modal mede-se pelo conteúdo (entre `min-width: 500px` e
+ * `max-width: 90%`), que é o comportamento histórico — não se define um
+ * default para não mexer na aparência dos portais que já o usam.
+ * @deprecated Legacy — não usar em código novo. Ver Storybook › Legacy.
+ */
+export type ModalSize = 'sm' | 'md' | 'lg' | 'xl';
+/** @deprecated Legacy — não usar em código novo. Ver Storybook › Legacy. */
+declare const Modal: React.ForwardRefExoticComponent<{
+    title: string;
+    modalOnly?: boolean;
+    onClose: () => void;
+    /** Largura fixa. Omitir mantém a largura pelo conteúdo. */
+    size?: ModalSize;
+} & {
+    children?: React.ReactNode | undefined;
+} & React.RefAttributes<HTMLDivElement>>;
+export default Modal;

package/dist/types/legacy/components/molecules/MultiTagPicker/MultiTagPicker.d.ts

@@ -0,0 +1,25 @@
+import React from 'react';
+import './MultiTagPicker.scss';
+/** @deprecated Legacy — não usar em código novo. Ver Storybook › Legacy. */
+export interface Option {
+    id: string;
+    label: string;
+}
+export interface MultiTagPickerProps {
+    placeholder?: string;
+    noOptionsLabel?: string;
+    searchInput: string;
+    editable: boolean;
+    loading: boolean;
+    optionsSelected: Option[];
+    options: Option[];
+    hasMoreItems: boolean;
+    handleInputKeyDown?: () => void;
+    handleInputChange?: (input: string) => void;
+    handleRemoveItem: (itemId: string) => void;
+    handleAddItem: (item: Option) => void;
+    loadMore?: () => void;
+}
+/** @deprecated Legacy — não usar em código novo. Ver Storybook › Legacy. */
+declare const MultiTagPicker: React.FC<MultiTagPickerProps>;
+export default MultiTagPicker;

package/dist/types/legacy/components/molecules/PhotoAvatar/PhotoAvatar.d.ts

@@ -0,0 +1,34 @@
+import React from 'react';
+export declare const SCOPE_PROPRIO: string[];
+export declare const SCOPE_OUTROS: string[];
+export interface GraphProfile {
+    name?: string | null;
+    email?: string | null;
+    company?: string | null;
+    department?: string | null;
+    jobTitle?: string | null;
+}
+interface Props {
+    oid?: string | null;
+    name?: string | null;
+    email?: string | null;
+    className?: string;
+    /** Passa para UserAvatar: cartão de detalhes em hover. Default: off. */
+    showCard?: boolean;
+    /**
+     * Fornece um token do Graph (scope `User.Read`) usando o MSAL DA APP.
+     * PREFERIR isto: evita o `useMsal` interno, que pode ler um `MsalContext`
+     * diferente quando o bundler duplica o `@azure/msal-react` (→ account null →
+     * sem foto). Com `getToken`, a foto do próprio (/me) resolve sempre.
+     * Ex.: `getToken={() => msalInstance.acquireTokenSilent({scopes:['User.Read'],account}).then(r=>r.accessToken)}`
+     */
+    getToken?: () => Promise<string>;
+}
+/**
+ * Avatar com a foto real do MS Graph. Fallback: iniciais (UserAvatar).
+ * Token: via `getToken` (recomendado) ou, em alternativa, via `useMsal` interno.
+ * Peers: @azure/msal-react, @azure/msal-browser.
+ * @deprecated Legacy — não usar em código novo. Ver Storybook › Legacy.
+ */
+export default function PhotoAvatar({ oid, name, email, className, showCard, getToken }: Props): React.JSX.Element;
+export {};

package/dist/types/legacy/components/molecules/SeletorPesquisa/SeletorPesquisa.d.ts

@@ -0,0 +1,48 @@
+import React, { type ReactNode } from 'react';
+/**
+ * Seletor com pesquisa, para listas grandes vindas de outro sistema.
+ *
+ * Difere do `SearchSelect` em três coisas que o tornavam inutilizável nesses
+ * casos: cada opção pode ter uma **segunda linha** (contexto — projeto, cliente,
+ * plano), a pesquisa corre sobre esse contexto e não só sobre o título, e pode
+ * aceitar **texto livre** quando o que a pessoa quer não está na lista.
+ *
+ * Fecha ao clicar fora e com Escape. Parece detalhe, mas dentro de um modal uma
+ * lista que não fecha tapa o resto do formulário.
+ * @deprecated Legacy — não usar em código novo. Ver Storybook › Legacy.
+ */
+export interface OpcaoPesquisa {
+    valor: string;
+    titulo: string;
+    /** Segunda linha: contexto que distingue homónimos. Também é pesquisável. */
+    contexto?: string;
+}
+/** @deprecated Legacy — não usar em código novo. Ver Storybook › Legacy. */
+export interface SeletorPesquisaProps {
+    opcoes: OpcaoPesquisa[];
+    /** Opção escolhida (`valor`), ou null. */
+    valor: string | null;
+    onChange: (valor: string | null) => void;
+    /**
+     * Permite escolher o que foi escrito, mesmo sem estar na lista. Recebe o
+     * texto; quem usa decide o que fazer com ele.
+     */
+    onTextoLivre?: (texto: string) => void;
+    aCarregar?: boolean;
+    erro?: boolean;
+    /** Máximo de opções mostradas — listas longas tornam o painel inútil. */
+    maximo?: number;
+    labels: {
+        placeholder: string;
+        semResultados: string;
+        aCarregar: string;
+        erro: string;
+        limpar: string;
+        /** Recebe o texto escrito, ex: `Registar sem tarefa: "{texto}"`. */
+        textoLivre?: (texto: string) => string;
+    };
+    /** Ícone opcional à esquerda do campo. */
+    icone?: ReactNode;
+}
+/** @deprecated Legacy — não usar em código novo. Ver Storybook › Legacy. */
+export default function SeletorPesquisa({ opcoes, valor, onChange, onTextoLivre, aCarregar, erro, maximo, labels, icone, }: SeletorPesquisaProps): React.JSX.Element;

package/dist/types/legacy/components/molecules/Sidebar/Sidebar.d.ts

@@ -0,0 +1,12 @@
+import React, { ReactNode } from 'react';
+import './Sidebar.scss';
+interface SidebarProps {
+    title: string;
+    isHome: boolean;
+    isOpen: boolean;
+    onClose: () => void;
+    children: ReactNode;
+}
+/** @deprecated Legacy — não usar em código novo. Ver Storybook › Legacy. */
+declare const Sidebar: React.FC<SidebarProps>;
+export default Sidebar;

package/dist/types/legacy/components/molecules/UserAvatar/UserAvatar.d.ts

@@ -0,0 +1,19 @@
+import React from 'react';
+interface UserAvatarProps {
+    name?: string | null;
+    photo?: string | null;
+    email?: string | null;
+    company?: string | null;
+    jobTitle?: string | null;
+    department?: string | null;
+    /** Tamanho, forma e cores das iniciais (classes Tailwind), como antes. */
+    className?: string;
+    /** Mostra o cartão de detalhes em hover (foto ampliada + nome/email). Default: off. */
+    showCard?: boolean;
+}
+/**
+ * Migrado para o V1: adaptador do `Avatar` (nomes antigos; o tamanho e as cores vêm do `className`).
+ * @deprecated Legacy — usar o `Avatar` (ou o `Person`, com o nome ao lado) do V1. Ver Storybook › Legacy.
+ */
+export default function UserAvatar({ name, photo, email, company, jobTitle, department, className, showCard }: UserAvatarProps): React.JSX.Element;
+export {};

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

@@ -0,0 +1,62 @@
+import React from 'react';
+/** @deprecated Legacy — não usar em código novo. Ver Storybook › Legacy. */
+export interface GanttRow {
+    id: string;
+    label: string;
+    /** Texto pequeno à direita do rótulo (ex: "12 dias"). */
+    sublabel?: string;
+    /** Mostra ⚠ com este texto no title. */
+    warning?: string;
+    /** Cor dos blocos (CSS). Nas linhas-pai sem cor usa-se a cor de destaque. */
+    color?: string;
+    /** Cor do texto do rótulo (CSS) — ex.: verde para tarefas concluídas. */
+    labelColor?: string;
+    /** Dias com atividade (ISO yyyy-mm-dd). Nas linhas-pai, se omitido, agrega os dias dos filhos. */
+    days?: string[];
+    /** Dias marcados com losango (ex: conclusão). */
+    markers?: string[];
+    /** Cabeçalho de secção mostrado antes da linha quando muda (ex: "Ramal 1"). */
+    section?: string;
+    children?: GanttRow[];
+}
+/** @deprecated Legacy — não usar em código novo. Ver Storybook › Legacy. */
+export interface GanttLegendItem {
+    label: string;
+    color: string;
+    kind?: 'block' | 'marker';
+}
+/** @deprecated Legacy — não usar em código novo. Ver Storybook › Legacy. */
+export interface GanttChartProps {
+    rows: GanttRow[];
+    /** Início e fim do eixo (ISO). */
+    start: string;
+    end: string;
+    /** Largura de cada dia em px (zoom). Default 14. */
+    dayWidth?: number;
+    labelWidth?: number;
+    /** Título da coluna de rótulos. */
+    labelHeader?: string;
+    legend?: GanttLegendItem[];
+    /** Linhas-pai abertas (controlado). Sem isto o componente gere o estado. */
+    expanded?: Set<string>;
+    onExpandedChange?: (ids: Set<string>) => void;
+    /** Conteúdo do tooltip de um dia. `parent` = linha-pai (dia agregado). */
+    renderTooltip?: (info: {
+        row: GanttRow;
+        day: string;
+        kind: 'day' | 'marker';
+        count?: number;
+        parent?: GanttRow;
+    }) => React.ReactNode;
+    /** Nomes dos meses (i18n). Default PT. */
+    monthNames?: string[];
+    emptyText?: string;
+    className?: string;
+}
+/** @deprecated Legacy — não usar em código novo. Ver Storybook › Legacy. */
+export default function GanttChart({ rows, start, end, dayWidth, labelWidth, labelHeader, legend, expanded: expandedProp, onExpandedChange, renderTooltip, monthNames, emptyText, className, }: GanttChartProps): React.JSX.Element;
+/**
+ * Utilitário: ISO de um dia do eixo (para quem precisa de formatar tooltips).
+ * @deprecated Legacy — não usar em código novo. Ver Storybook › Legacy.
+ */
+export declare const ganttDiaIso: (start: string, offset: number) => string;