@trismegisto/spine 3.3.2 → 3.3.4

package/types/trismegisto-spine-layout.d.ts

@@ -1,13 +1,13 @@
 import * as _angular_core from '@angular/core';
-import { OnDestroy, OnInit, InjectionToken, Type, Provider, TemplateRef } from '@angular/core';
+import { OnDestroy, InjectionToken, Signal, OnInit, Type, Provider, TemplateRef, DestroyRef, EnvironmentProviders } from '@angular/core';
 import { Router } from '@angular/router';
 import * as _trismegisto_spine from '@trismegisto/spine';
 import { Route, ThemeService, ThemePresetService, DensityService, SpineConfig, SpinePreferencesService, SpineHourCyclePreference, SpineStartPagePreference, SpineNoticeType, SpineMcpServer, SpineFeatures } from '@trismegisto/spine';
-import { Subject } from 'rxjs';
+import { Subject, Observable } from 'rxjs';
 import * as _trismegisto_angular from '@trismegisto/angular';
-import { HermesShortcutItem, WorkspaceStore, TabItem, MenuItem, HermesCommand, SidebarNode, HermesThemeMode, HermesDensity, SegmentedOption, HermesSidebarService, ComboboxOption, BreadcrumbItem, TagColor } from '@trismegisto/angular';
+import { HermesShortcutItem, WorkspaceGridLimits, WorkspaceStore, TabItem, MenuItem, HermesCommand, SidebarNode, ContextMenuDirective, HermesThemeMode, HermesDensity, SegmentedOption, HermesSidebarService, ComboboxOption, BreadcrumbItem, TagColor } from '@trismegisto/angular';
 import * as _trismegisto_primitives from '@trismegisto/primitives';
-import { formatMessage, ShortcutDisplay, HermesMotionPreference, Weekday, AlertVariant, PaginationState } from '@trismegisto/primitives';
+import { WorkspaceStore as WorkspaceStore$1, formatMessage, MenuItem as MenuItem$1, ShortcutDisplay, HermesMotionPreference, Weekday, AlertVariant, PaginationState } from '@trismegisto/primitives';
 import * as _orfeu_angular_core from '@orfeu/angular/core';
 import { AuthorizationService, ViewService, UserProfile, AppDef, RealmAppsService } from '@orfeu/angular/core';
 import * as _trismegisto_tokens from '@trismegisto/tokens';
@@ -190,22 +190,24 @@ declare class SpineNewsService {
 interface ShortcutActions {
     navigate?: (url: string) => void;
     toggleTheme?: () => void;
-    toggleFullscreen?: () => void;
-    logout?: () => void;
     openSettings?: () => void;
+    toggleSidebar?: () => void;
 }
 /**
  * Atalhos de teclado globais do sistema, sobre o `HermesShortcutService` da lib (um listener só,
  * sequência `G H`, conflito, campo editável, interruptor de tecla única da WCAG 2.1.4).
  *
- * `setActions` registra os atalhos do shell: `G H` (Home), `G 1`…`G 9` (favoritos), `Mod+,`
- * (configurações), `Mod+.` (tema), `Mod+Shift+F` (tela cheia), `Mod+Shift+L` (sair) e `?` (painel
- * de atalhos, via `help$`). Os combos com `Mod` valem também com o foco num campo; `G …` e `?`, não.
+ * `setActions` registra os atalhos do shell: `G H` (Home), `G 1`…`G 9` (favoritos), `G T` (tema), `Mod+B` (menu
+ * lateral), `Mod+,` (configurações) e `?` (painel de atalhos, via `help$`). `Mod+,` vale também com o foco num campo;
+ * os demais, não (`Mod+B` num editor continua sendo negrito).
+ *
+ * Sem atalho de propósito: sair (um deslize perderia o que estava sendo digitado; fica no menu do perfil) e tela cheia
+ * (o navegador já tem `F11`, e o botão fica no cabeçalho).
  *
  * O painel (`spine-shortcuts-cheatsheet` e a seção Atalhos das configurações) usa o
  * `hm-shortcut-list` com `panelItems()`: tudo o que está registrado no `HermesShortcutService`
  * (inclusive o que o app liga com `[hmShortcut]`) mais o que o spine só exibe e outra peça dispara
- * (`Mod+K` do `hm-header`, `Alt+←/→` do navegador, `Esc` dos diálogos).
+ * (`Mod+K` e `/` do `hm-header`, voltar/avançar do navegador, `Esc` dos diálogos).
  */
 declare class ShortcutService implements OnDestroy {
     private actions;
@@ -239,16 +241,105 @@ declare class ShortcutService implements OnDestroy {
     static ɵprov: _angular_core.ɵɵInjectableDeclaration<ShortcutService>;
 }
 
+/** Query de uma aba, como objeto (o último valor de cada nome). */
+type SpineTabParams = Readonly<Record<string, string>>;
+/**
+ * A aba do workspace em que a tela está montada (`inject(SPINE_TAB)` na tela). Com o keepAlive, várias abas da MESMA
+ * tela ficam vivas ao mesmo tempo (um registro por aba); `window.location`/`ActivatedRoute` só refletem a aba do
+ * painel focado. Aqui cada tela lê e escreve a SUA.
+ *
+ * ```ts
+ * private readonly tab = inject(SPINE_TAB, { optional: true });
+ * readonly pedido = computed(() => this.tab?.params()['pedido'] ?? null);
+ * // trocar a seção: a mesma aba, sem recriar a tela (e o endereço do navegador acompanha, se a aba está à vista)
+ * this.tab?.navigate({ queryParams: { secao: 'itens' } });
+ * // o nome do registro no lugar do nome da rota
+ * this.tab?.setLabel('Pedido 123');
+ * ```
+ */
+interface SpineTab {
+    /** Identidade estável da aba (o caminho, ou o caminho com os parâmetros que a identificam). */
+    readonly id: Signal<string>;
+    /** O painel em que a aba está agora. */
+    readonly panelId: Signal<string>;
+    /** O endereço atual da aba, com a query. */
+    readonly url: Signal<string>;
+    /** A query da aba. */
+    readonly params: Signal<SpineTabParams>;
+    /** A aba é a visível do painel focado (é a que o endereço do navegador mostra). */
+    readonly focused: Signal<boolean>;
+    /** Troca o nome (e, se vier, o ícone) da aba; persiste no F5 nas abas com parâmetros. */
+    setLabel(label: string, icon?: string): void;
+    /**
+     * Muda o endereço da própria aba. Com `queryParams`, mescla na query atual (`merge`, padrão) ou troca a query
+     * inteira (`merge: false`); `null`/`undefined` tira o parâmetro. Mesma tela: só a query muda, a tela não é recriada.
+     * Outra tela (um caminho diferente): é a navegação no lugar da aba, como um link dentro do painel.
+     */
+    navigate(target: string | {
+        queryParams: Readonly<Record<string, string | number | boolean | null | undefined>>;
+        merge?: boolean;
+    }): void;
+}
+declare const SPINE_TAB: InjectionToken<SpineTab>;
+
+/** Limite da grade de painéis do shell: no máximo 2 lado a lado e 2 empilhados (os quatro cantos da tela). */
+declare const SPINE_WORKSPACE_LIMITS: WorkspaceGridLimits;
+/** O caminho de um endereço (sem query nem fragmento). */
+declare function spinePathOf(url: string): string;
+/** A query de um endereço, como objeto. */
+declare function spineParamsOf(url: string): SpineTabParams;
+/** Caminho + query com os nomes em ordem: o mesmo endereço escrito de dois jeitos vira um só (sem o fragmento). */
+declare function spineNormalizeUrl(url: string): string;
+/** Como abrir uma aba pelo app (`openTab`). */
+interface SpineOpenTabOptions {
+    /** Nome da aba (senão, o da rota). A tela pode trocar depois (`SPINE_TAB.setLabel`). */
+    label?: string;
+    icon?: string;
+    /**
+     * Os parâmetros que IDENTIFICAM a aba: com `['dispositivo']`, o mesmo dispositivo em outra seção reaproveita a aba
+     * aberta, e trocar a seção dentro dela não abre outra. Sem `match`, todos os parâmetros do endereço identificam.
+     */
+    match?: readonly string[];
+    /**
+     * Abre num painel novo ao lado do focado (para comparar), em vez de no próprio painel focado. Só vale com a
+     * preferência "Dividir abas" ligada (`SpinePreferencesService.splitTabs`); desligada (o padrão), a aba abre no painel
+     * focado, como sem `beside`. No limite da grade (`SPINE_WORKSPACE_LIMITS`, 2 colunas), abre no painel que já está
+     * ao lado, sem dividir.
+     */
+    beside?: boolean;
+}
 /**
  * Dono do `WorkspaceStore` do shell — mesmo padrão do `WorkspaceNavService` do docs/website
  * (`packages/hermes-ui/docs/website/src/app/workspace-nav.service.ts`), adaptado pra ler a
  * árvore de rotas do BACKEND (`ViewService.currentView`) em vez de um `page-registry.ts`
  * estático. Cada página visitada vira uma aba, pertencente a um painel; a navegação real do
  * `Router` (routerLink, busca, sidebar) sempre atualiza a aba ativa do painel FOCADO.
+ *
+ * **Dois jeitos de ter aba, que convivem.** A navegação de sempre (menu, links, busca) mantém UMA aba por tela, com o
+ * caminho como `id` — como antes; a query que a tela usa fica guardada no `url` da aba e volta junto quando a pessoa
+ * retorna a ela. E o app pode abrir **abas com parâmetros** (`openTab`): a mesma tela várias vezes, uma por registro
+ * (um pedido, um dispositivo...). Nelas o `id` é a identidade (o caminho com os parâmetros que a identificam) e o `url`
+ * é o endereço atual (com a query que a tela vai mudando).
+ * O keepAlive do workspace acompanha o `id`, então mudar a query da aba não recria a tela. Uma navegação real cai
+ * numa destas, em ordem:
+ * 1. o endereço já é o da aba ativa → nada;
+ * 2. a mesma tela da aba ativa, mantendo os parâmetros que a identificam → só o `url` da aba muda (mesma aba);
+ * 3. outra aba do painel já está nesse endereço → ela é ativada;
+ * 4. senão → a aba ativa passa a ser a da tela nova (o comportamento de sempre).
+ * `openTab` abre (ou foca, em qualquer painel) a aba de um endereço com parâmetros.
+ *
+ * **Dividir abas é preferência da pessoa** (`SpinePreferencesService.splitTabs`, desligada por padrão): o shell só
+ * deixa dividir a área em painéis com ela ligada (`split`). Desligada — ao carregar ou ao desligar —, um arranjo com
+ * vários painéis (salvo no navegador ou feito antes) é fundido num painel só, sem perder aba (`mergePanels`).
  */
 declare class SpineWorkspaceNavService {
     private readonly router;
     private readonly viewService;
+    private readonly preferences;
+    /** A pessoa pode dividir a área de abas em painéis (a preferência "Dividir abas"). */
+    readonly split: _angular_core.Signal<boolean>;
+    /** Até onde dá para dividir (o shell passa para o `hm-workspace`; `openTab` com `beside` respeita). */
+    readonly limits: WorkspaceGridLimits;
     readonly store: WorkspaceStore;
     private readonly state;
     readonly root: _angular_core.Signal<_trismegisto_primitives.PanelNode>;
@@ -258,22 +349,57 @@ declare class SpineWorkspaceNavService {
      *  `viewService.logControl$`/`breadCrumb$` globais (que só existiam porque havia uma página
      *  "atual" só; agora cada painel tem a sua). */
     readonly focusedChain: _angular_core.Signal<Route[] | null>;
-    private lastKnownPath;
+    /** O último endereço que o `Router` mostrou (normalizado, com a query): o `effect` abaixo não navega para ele de novo. */
+    private lastKnownUrl;
     constructor();
+    private activeTab;
+    /** Uma navegação real no painel focado: as quatro regras do comentário da classe. */
+    private followNavigation;
     /**
      * As abas abertas passam a obedecer à view atual: aba de tela que a pessoa não pode mais abrir fecha (e o
      * conteúdo dela é destruído junto); painel que ficaria sem aba nenhuma mostra o Início no lugar; a aba ativa
-     * de cada painel recebe o nome e o ícone da view nova. View vazia (ainda carregando) não fecha nada.
+     * de cada painel recebe o nome e o ícone da view nova (a aba com parâmetros guarda o nome que a tela deu). View
+     * vazia (ainda carregando) não fecha nada.
      */
     reconcileWithView(): void;
     /** Resolve a cadeia de rotas pra uma URL, direto na view atual — sem `Router`, sem `async`
      *  (o componente da folha só é carregado por quem for de fato desenhar o painel). Desce sozinho
      *  por nós organizacionais (com filhos, sem conteúdo próprio) — o rótulo/ícone da aba e o que a
-     *  sidebar/breadcrumb mostram refletem o destino DE VERDADE, não a rota-container clicada. */
+     *  sidebar/breadcrumb mostram refletem o destino DE VERDADE, não a rota-container clicada. A query não
+     *  conta: `ViewService.routePath` a tira. */
     private chainFor;
+    /** A aba de uma tela pelo endereço: o `id` é o caminho; com query, o endereço vai no `url` (a mesma aba da tela). */
     tabFor(url: string): TabItem;
+    /**
+     * Restaura uma aba salva (F5): a rota precisa continuar valendo para a pessoa. A aba com parâmetros volta com o
+     * endereço e o nome que tinha (o nome é o que a tela deu — "RT-MPLS-3046-0001" —, a rota não sabe); as outras
+     * voltam com o nome da rota (que acompanha o idioma).
+     */
+    private restoreTab;
+    /**
+     * Junta todos os painéis no focado, sem perder aba: as abas ficam na ordem dos painéis (da esquerda para a direita,
+     * de cima para baixo), uma aba repetida em dois painéis vira uma só (vale a do focado), e a aba ativa do painel focado
+     * continua a ativa (`WorkspaceStore.mergePanels`). Com um painel só, não faz nada.
+     */
+    mergePanels(): void;
     /** O `+` de um painel: abre a home ali, como um navegador. */
     openNewTab(panelId: string): void;
+    /**
+     * Abre (ou foca) a aba de um endereço com parâmetros — um registro por aba na mesma tela:
+     * `openTab('/vendas/pedidos?pedido=123&secao=itens', { label: 'Pedido 123', match: ['pedido'] })`.
+     * Se alguma aba (em qualquer painel) já tem essa identidade, ela é focada e passa a esse endereço; senão abre uma
+     * no painel focado (ou num painel novo ao lado, com `beside` e a divisão ligada). Só abre o que a view da pessoa permite (a mesma
+     * regra do menu e do `ViewGuard`); fora dela, não faz nada.
+     */
+    openTab(url: string, options?: SpineOpenTabOptions): void;
+    /** O nome (e o ícone) de uma aba, dado pela tela (`SPINE_TAB.setLabel`). */
+    setTabLabel(panelId: string, tabId: string, label: string, icon?: string): void;
+    /**
+     * A tela muda o endereço da própria aba (`SPINE_TAB.navigate`). A mesma tela, mantendo a identidade: só o `url` da
+     * aba muda (sem recriar a tela) e, se ela é a visível do painel focado, o endereço do navegador acompanha (sem
+     * empilhar histórico). Outra tela: navegação local no painel, como um link dentro dele.
+     */
+    navigateTab(panelId: string, tabId: string, url: string): void;
     /** Navegação LOCAL a um painel específico (usada pelo `PanelLocalLinkDirective`) — troca o
      *  ASSUNTO da aba ativa daquele painel, não empilha uma aba nova. */
     navigateLocally(panelId: string, href: string): void;
@@ -281,6 +407,79 @@ declare class SpineWorkspaceNavService {
     static ɵprov: _angular_core.ɵɵInjectableDeclaration<SpineWorkspaceNavService>;
 }
 
+/**
+ * Saída da sessão pelo shell: todo botão/atalho de sair do spine passa por aqui (menu do perfil, painel de
+ * configurações, tela `/blocked`).
+ *
+ * - Assina `logoutFailed$` do `@orfeu/angular` (1.3.x) uma vez só: quando o logout no Argos falha (a lib repete uma
+ *   vez e mantém a sessão), mostra o aviso de erro `session.logoutFailed` (`hm-alert` de erro, `role="alert"`). Vale
+ *   também para um `logout()` chamado direto pelo app.
+ * - `logout()` aguarda o resultado: só apaga os históricos do usuário (`SpineUserStorage.clearHistory()`) quando a
+ *   saída deu certo. Com falha, nada muda: a pessoa continua na tela, com a sessão e os recentes.
+ * - `pending` fica `true` enquanto a saída está em andamento e sempre volta a `false` (os botões não travam).
+ *
+ * Com `@orfeu/angular` 1.0.x (sem `logoutFailed$`, `logout()` sem retorno) a saída conta como concluída, como antes.
+ */
+declare class SpineLogoutService {
+    private readonly auth;
+    private readonly userStorage;
+    private readonly notifications;
+    private readonly messages;
+    /** `true` quando a lib avisa a falha por `logoutFailed$` (então o aviso sai por lá, uma vez). */
+    private readonly failureStream;
+    private inFlight;
+    /** Saída em andamento (o botão mostra "saindo…" / fica desabilitado). */
+    readonly pending: _angular_core.WritableSignal<boolean>;
+    constructor();
+    /**
+     * Sai da sessão. Resolve `true` quando saiu (o `@orfeu/angular` já navega para o `/logoff`) e `false` quando o
+     * Argos não confirmou: a sessão continua e o aviso de erro aparece. Nunca rejeita. Cliques repetidos durante a
+     * saída reaproveitam a mesma tentativa.
+     */
+    logout(): Promise<boolean>;
+    private run;
+    private notifyFailure;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SpineLogoutService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<SpineLogoutService>;
+}
+
+/**
+ * Registra a verificação de alterações da tela, presa à aba do workspace em que ela está (`SPINE_TAB`):
+ * com `SpineFeatures.unsavedChanges` ligado, fechar ESSA aba (ou o painel dela, ou "fechar as outras") e
+ * trocar de tela dentro dela pergunta antes. Chame num contexto de injeção (campo da tela); a verificação
+ * sai sozinha quando a tela é destruída.
+ *
+ * ```ts
+ * readonly #unsaved = registerSpineUnsavedChanges(() => this.form.dirty);
+ * ```
+ *
+ * Sem o recurso ligado, continua registrando no `HermesUnsavedChangesService` (o `hermesUnsavedChangesGuard`
+ * de uma rota do app enxerga), mas o shell não pergunta nada.
+ */
+declare function registerSpineUnsavedChanges(check: () => boolean): () => void;
+/**
+ * O lado do shell do aviso de alterações não salvas (`SpineFeatures.unsavedChanges`, desligado por padrão).
+ * Ligado: o `hm-workspace` recebe um store que pergunta antes de fechar aba com alteração; trocar de tela
+ * dentro da aba pergunta também; e o navegador avisa ao recarregar/fechar a página. Desligado: `store` é o
+ * mesmo do `SpineWorkspaceNavService` e nada muda.
+ */
+declare class SpineUnsavedChangesService {
+    private readonly config;
+    private readonly unsaved;
+    private readonly nav;
+    /** O recurso está ligado no app. */
+    readonly enabled: boolean;
+    /** O store que o shell passa para o `hm-workspace`. */
+    readonly store: WorkspaceStore$1;
+    /** Liga o aviso do navegador (só com o recurso ligado). Devolve a função que desliga. */
+    start(): () => void;
+    /** Pode trocar a tela da aba ativa do painel? Sem o recurso ou sem alteração nela, `true` na hora. */
+    canReplaceActive(panelId: string): boolean | Promise<boolean>;
+    private guard;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SpineUnsavedChangesService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<SpineUnsavedChangesService>;
+}
+
 /**
  * Shell do spine — MESMA estrutura do `docs/website`'s `app.component.html`/`.scss` (decisão de
  * 2026-09-28, ver `hefesto-migration-plan.md`): `.shell` com altura de viewport de verdade
@@ -310,13 +509,19 @@ declare class LayoutComponent implements OnInit {
     private readonly preferences;
     protected readonly workspace: SpineWorkspaceNavService;
     private readonly settings;
+    private readonly sidebar;
     /** Também liga, uma vez, o aviso de falha do logout (`logoutFailed$` do `@orfeu/angular`). */
-    private readonly logoutService;
+    protected readonly logoutNotice: SpineLogoutService;
     /** Recursos opcionais (`SpineConfig.features`): cada serviço não faz nada com o seu recurso desligado. */
     private readonly idle;
     private readonly startPage;
     private readonly accountPreferences;
     protected readonly setup: SpineInitialSetupService;
+    /** Aviso de alterações não salvas (SpineFeatures.unsavedChanges): sem o recurso, `unsaved.store` é o próprio `workspace.store`. */
+    protected readonly unsaved: SpineUnsavedChangesService;
+    /** SpineFeatures.skipLink. */
+    protected readonly skipLink: boolean;
+    private readonly destroyRef;
     /** Esconde sidebar e área de trabalho quando a rota ATIVA (do Router real, ver
      *  `router.events` abaixo) é a de sem-permissão — nesse caso não existe menu/página válido
      *  como contexto. Note que isto reflete só a URL do painel FOCADO (dona do Router real); um
@@ -327,8 +532,12 @@ declare class LayoutComponent implements OnInit {
     constructor(router: Router, theme: ThemeService, shortcuts: ShortcutService, news: SpineNewsService);
     private matchesNoPermission;
     ngOnInit(): void;
+    /**
+     * `Mod+B`. Tela estreita: a gaveta. Fixo e compacto: troca um pelo outro (é a preferência da pessoa, fica gravada).
+     * Automático: a coluna abre por cima e fica até o próximo `Mod+B`, sem mudar a preferência.
+     */
+    private toggleSidebar;
     protected onLocalNavigate(panelId: string, href: string): void;
-    private toggleFullscreen;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<LayoutComponent, never>;
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<LayoutComponent, "spine-layout", never, {}, {}, never, never, true, never>;
 }
@@ -432,7 +641,7 @@ declare class HeaderComponent implements OnInit {
     protected readonly searchIcons: Readonly<Record<string, string>>;
     /** Achata a árvore de rotas em itens navegáveis (com trilha de ancestrais). */
     private flattenRoutes;
-    /** Chamado pelo `(searchRequested)` do `hm-header` (clique no campo ou `Ctrl K`, já tratado por ele): abre a paleta. */
+    /** Chamado pelo `(searchRequested)` do `hm-header` (clique no campo, `Ctrl K` ou `/`, já tratados por ele): abre a paleta. */
     onSearchRequested(): void;
     /**
      * Comandos da paleta. Cada tela aparece uma vez: favoritos primeiro, depois os abertos há pouco que não são
@@ -556,12 +765,18 @@ declare class SidebarComponent {
         modules: string;
         moduleNavigation: string;
         apps: string;
+        openInNewTab: string;
     };
     protected readonly fmt: typeof formatMessage;
     private readonly workspace;
     private readonly viewService;
     private readonly authService;
     private readonly realmApps;
+    private readonly location;
+    private readonly column;
+    protected readonly pageMenu: readonly MenuItem$1[];
+    /** Endereço da página em que o menu de contexto foi aberto. */
+    private menuPage;
     /** Aplicações do realm (o app atual já vem excluído pelo backend) — exibidas só no mobile. */
     protected readonly apps: _angular_core.WritableSignal<AppDef[]>;
     private readonly currentView;
@@ -583,6 +798,11 @@ declare class SidebarComponent {
      *  do módulo" pra mostrar. */
     private readonly wantsModules;
     protected readonly viewingModules: _angular_core.Signal<boolean>;
+    /** Botão direito (ou Shift+F10/tecla Menu, que o navegador traduz em `contextmenu`) numa página do menu. Grupo e
+     *  entrada de módulo não são páginas: ali o menu nativo continua valendo. */
+    protected onContextMenu(event: MouseEvent, menu: ContextMenuDirective): void;
+    protected onPageMenuClosed(): void;
+    protected openPageInNewTab(): void;
     /** Sem teto artificial de nível de grupo — o template não enxerga o global `Infinity`, só
      *  membros da classe. Ver comentário no `.html`: o backend já limita a árvore sozinho. */
     protected readonly maxDepth: number;
@@ -628,42 +848,6 @@ declare class SpineConnectionBannerComponent {
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<SpineConnectionBannerComponent, "spine-connection-banner", never, {}, {}, never, never, true, never>;
 }
 
-/**
- * Saída da sessão pelo shell: todo botão/atalho de sair do spine passa por aqui (menu do perfil, painel de
- * configurações, `Mod+Shift+L`, tela `/blocked`).
- *
- * - Assina `logoutFailed$` do `@orfeu/angular` (1.3.x) uma vez só: quando o logout no Argos falha (a lib repete uma
- *   vez e mantém a sessão), mostra o aviso de erro `session.logoutFailed` (`hm-alert` de erro, `role="alert"`). Vale
- *   também para um `logout()` chamado direto pelo app.
- * - `logout()` aguarda o resultado: só apaga os históricos do usuário (`SpineUserStorage.clearHistory()`) quando a
- *   saída deu certo. Com falha, nada muda: a pessoa continua na tela, com a sessão e os recentes.
- * - `pending` fica `true` enquanto a saída está em andamento e sempre volta a `false` (os botões não travam).
- *
- * Com `@orfeu/angular` 1.0.x (sem `logoutFailed$`, `logout()` sem retorno) a saída conta como concluída, como antes.
- */
-declare class SpineLogoutService {
-    private readonly auth;
-    private readonly userStorage;
-    private readonly notifications;
-    private readonly messages;
-    /** `true` quando a lib avisa a falha por `logoutFailed$` (então o aviso sai por lá, uma vez). */
-    private readonly failureStream;
-    private inFlight;
-    /** Saída em andamento (o botão mostra "saindo…" / fica desabilitado). */
-    readonly pending: _angular_core.WritableSignal<boolean>;
-    constructor();
-    /**
-     * Sai da sessão. Resolve `true` quando saiu (o `@orfeu/angular` já navega para o `/logoff`) e `false` quando o
-     * Argos não confirmou: a sessão continua e o aviso de erro aparece. Nunca rejeita. Cliques repetidos durante a
-     * saída reaproveitam a mesma tentativa.
-     */
-    logout(): Promise<boolean>;
-    private run;
-    private notifyFailure;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SpineLogoutService, never>;
-    static ɵprov: _angular_core.ɵɵInjectableDeclaration<SpineLogoutService>;
-}
-
 /** Um cartão do essencial: o texto tem `{key}` onde entra a tecla (desenhada como `<kbd>`). */
 interface EssentialCard {
     readonly id: string;
@@ -733,6 +917,9 @@ declare class SpineInitialSetupComponent {
         sidebarAuto: string;
         sidebarFixed: string;
         sidebarCompact: string;
+        splitTabs: string;
+        splitTabsDescription: string;
+        splitTabsKeywords: string;
         region: string;
         regionKeywords: string;
         language: string;
@@ -932,6 +1119,7 @@ declare class ShortcutsCheatsheetComponent implements OnInit, OnDestroy {
         goFavorite: string;
         history: string;
         openSettings: string;
+        toggleSidebar: string;
         toggleTheme: string;
         fullscreen: string;
         logout: string;
@@ -1034,12 +1222,14 @@ interface SpineAccountPreferencesDoc {
     startPage?: SpineStartPagePreference;
     notices?: Record<string, boolean>;
     browserNotices?: boolean;
+    /** Dividir a área de abas em painéis (`SpinePreferencesService.splitTabs`). */
+    splitTabs?: boolean;
     favorites?: unknown[];
 }
 /**
  * Chaves que são da pessoa, não do app: com o Argos que tem `{api}/preferences/global`, vão no documento global e
- * valem em todos os apps (escolhidas uma vez). O resto (menu lateral, atalhos, inatividade, tela inicial, avisos,
- * favoritos) continua no documento do app.
+ * valem em todos os apps (escolhidas uma vez). O resto (menu lateral, dividir abas, atalhos, inatividade, tela inicial,
+ * avisos, favoritos) continua no documento do app.
  */
 declare const SPINE_GLOBAL_PREFERENCE_KEYS: readonly ["themeMode", "family", "density", "font", "textScale", "motion", "language", "timeZone", "hourCycle", "weekStart"];
 /** Documento global (`PUT {api}/preferences/global`): aparência e região, mais a configuração inicial feita. */
@@ -1052,8 +1242,8 @@ type SpineAccountPreferencesStatus = 'idle' | 'local' | 'loading' | 'saving' | '
 /**
  * Preferências na conta (`SpineFeatures.accountPreferences`): espelha no Argos (`GET/PUT {api}/preferences`, por
  * usuário e aplicação) o que o painel de configurações guarda no navegador — tema, cor, densidade, fonte, menu
- * lateral, idioma, fuso, relógio, primeiro dia da semana, tamanho do texto, animações, atalhos de tecla única,
- * inatividade, tela inicial, tipos de aviso e favoritos. As telas Aparência, Região etc. não mudam: o
+ * lateral, dividir abas, idioma, fuso, relógio, primeiro dia da semana, tamanho do texto, animações, atalhos de tecla
+ * única, inatividade, tela inicial, tipos de aviso e favoritos. As telas Aparência, Região etc. não mudam: o
  * armazenamento local continua sendo a fonte de cada tela, e este serviço só sincroniza.
  *
  * - No início da sessão (`start()`, chamado pelo layout e pelo `/callback`), lê a conta e aplica o que estiver lá
@@ -1232,6 +1422,9 @@ declare class SettingsPanelComponent {
         sidebarAuto: string;
         sidebarFixed: string;
         sidebarCompact: string;
+        splitTabs: string;
+        splitTabsDescription: string;
+        splitTabsKeywords: string;
         region: string;
         regionKeywords: string;
         language: string;
@@ -1684,8 +1877,8 @@ declare class SettingsPanelComponent {
     protected clearList(list: BrowserList): void;
     /**
      * Restaurar preferências (com confirmação): tema (sistema), cor principal (a padrão do app), densidade
-     * (confortável), fonte (a padrão do app), menu lateral (o modo padrão do app), tamanho do texto (100%),
-     * animações (sistema), formato de hora e primeiro dia da semana (automáticos). Idioma, fuso horário e
+     * (confortável), fonte (a padrão do app), menu lateral (o modo padrão do app), dividir abas (desligado), tamanho do
+     * texto (100%), animações (sistema), formato de hora e primeiro dia da semana (automáticos). Idioma, fuso horário e
      * atalhos de tecla única ficam: mudam como a pessoa lê e digita, e não são "aparência".
      */
     protected restorePreferences(): void;
@@ -1866,12 +2059,33 @@ interface GroupMember {
     joined_at: string | null;
     added_by_username: string | null;
 }
+/** Página e filtros da lista de membros (o servidor pagina: padrão 50, até 200 por página). */
+interface GroupMembersQuery {
+    page?: number;
+    limit?: number;
+    /** Trecho do nome, do login ou do e-mail. */
+    search?: string;
+}
+/** Uma página de membros, com a função de quem pede e o que ela permite (como em `ManagedGroup`). */
+interface GroupMembersPage {
+    my_role: GroupRole | null;
+    can_add: boolean;
+    assignable_roles: GroupRole[];
+    can_change_roles: boolean;
+    members: GroupMember[];
+    /** Quantos passam pela busca (sem busca, o grupo inteiro). */
+    total: number;
+    page: number;
+    limit: number;
+}
 interface RealmUser {
     id: string;
     username: string;
     email: string | null;
     name: string | null;
     enabled: boolean;
+    /** Foto (o argos-admin já manda com a busca): a pessoa incluída entra na lista com ela. */
+    picture?: string | null;
 }
 /**
  * Grupos de que a pessoa é membro e o que a função dela permite — `argos-admin /me/groups`. Sempre da aplicação LOGADA (o
@@ -1892,9 +2106,11 @@ declare class SpineMyGroupsService {
     private get headers();
     /** Relê os grupos; qualquer falha deixa a lista vazia (a seção some em vez de mostrar um erro sem contexto). */
     refresh(): Promise<void>;
-    members(groupId: string): Promise<{
-        members: GroupMember[];
-    }>;
+    /**
+     * Uma página dos membros, pela ordem do login. Observable (não Promise): a tela pede as páginas até o fim e cancela a
+     * pendente ao sair.
+     */
+    members(groupId: string, query?: GroupMembersQuery): Observable<GroupMembersPage>;
     searchUsers(search: string, limit?: number): Promise<{
         users: RealmUser[];
     }>;
@@ -2779,6 +2995,132 @@ declare class SpinePageActionsDirective implements OnDestroy {
     static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SpinePageActionsDirective, "ng-template[spinePageActions]", never, {}, {}, never, never, true, never>;
 }
 
+/** Uma novidade na central de notificações (o sino do cabeçalho). */
+interface SpineInboxItem {
+    /** Único dentro da fonte. */
+    readonly id: string;
+    readonly title: string;
+    /** A novidade em uma linha ("Ana: pode mandar um exemplo?"). */
+    readonly body?: string;
+    /** Quando aconteceu (a novidade mais recente do item): ordena a lista e vira "há 5 min". */
+    readonly at: string | Date;
+    /** Quantas novidades o item junta (mostra "+N" a partir de 2). */
+    readonly count?: number;
+    /** Quem fez: a foto (ou as iniciais) na linha; sem pessoa, o ícone da fonte. */
+    readonly person?: {
+        readonly name: string;
+        readonly picture?: string | null;
+    } | null;
+}
+/**
+ * Uma fonte da central de notificações: o que há de novo PARA a pessoa num recurso (sugestões, aprovações, chamados…).
+ * Não são os toasts (`HermesToastService`/`NotificationService`), que passam: aqui fica até a pessoa ver. Registre com
+ * `provideSpineInboxSource`; o sino só aparece com alguma fonte.
+ */
+interface SpineInboxSource {
+    readonly id: string;
+    /** O nome da fonte ("Sugestões"), acima dos itens dela. */
+    readonly label: string;
+    /** Ícone da fonte (@trismegisto/icons), nos itens sem pessoa. */
+    readonly icon?: string;
+    /** As novidades (as mais recentes, até umas 20) e o total de itens com novidade (o número do sino). */
+    load(): Promise<{
+        readonly items: readonly SpineInboxItem[];
+        readonly total: number;
+    }>;
+    /** A pessoa escolheu o item: marque como visto e abra onde ele está. A central relê depois. */
+    open(item: SpineInboxItem): void | Promise<void>;
+}
+/** As fontes registradas (multi). Uma fábrica pode devolver `null` (recurso desligado): fica de fora. */
+declare const SPINE_INBOX_SOURCES: InjectionToken<readonly (SpineInboxSource | null)[]>;
+/**
+ * Registra uma fonte na central de notificações. A fábrica roda num contexto de injeção (`inject()` vale) e pode
+ * devolver `null` para não registrar nada.
+ *
+ * ```ts
+ * provideSpineInboxSource(() => {
+ *   const api = inject(AprovacoesApi);
+ *   const router = inject(Router);
+ *   return {
+ *     id: 'aprovacoes', label: 'Aprovações', icon: 'check-circle',
+ *     load: async () => { const r = await api.pendentes(); return { total: r.total, items: r.itens.map(toItem) }; },
+ *     open: (item) => void router.navigateByUrl(`/aprovacoes/${item.id}`),
+ *   };
+ * })
+ * ```
+ */
+declare function provideSpineInboxSource(factory: () => SpineInboxSource | null): Provider;
+
+/** Um item na lista do sino, com a fonte dele. */
+interface SpineInboxEntry {
+    /** `fonte:item`, único na lista. */
+    readonly key: string;
+    readonly source: SpineInboxSource;
+    readonly item: SpineInboxItem;
+}
+/** De quanto em quanto tempo a central relê, com a aba do navegador à vista. */
+declare const SPINE_INBOX_POLL_MS = 60000;
+/**
+ * A central de notificações (o sino do cabeçalho): junta as novidades das fontes registradas
+ * (`provideSpineInboxSource`), a mais recente primeiro. Relê enquanto alguém acompanha (`watch`): de minuto em minuto
+ * com a aba à vista e ao voltar para ela. Quem muda o que conta como novidade (ler uma conversa, por exemplo) chama
+ * `refresh()`.
+ */
+declare class SpineInboxService {
+    private readonly browser;
+    private readonly sources;
+    /** Alguma fonte registrada: sem nenhuma, o sino não aparece. */
+    readonly enabled: boolean;
+    readonly entries: _angular_core.WritableSignal<readonly SpineInboxEntry[]>;
+    /** Itens com novidade, somando as fontes (o número do sino). */
+    readonly total: _angular_core.WritableSignal<number>;
+    readonly loading: _angular_core.WritableSignal<boolean>;
+    /** Nenhuma fonte respondeu na última leitura. */
+    readonly failed: _angular_core.WritableSignal<boolean>;
+    private request;
+    private watchers;
+    private timer;
+    private readonly onVisible;
+    /** Relê todas as fontes. Uma fonte que falha não derruba as outras. */
+    refresh(): Promise<void>;
+    /** A pessoa escolheu um item: a fonte abre (e marca como visto); depois a central relê. */
+    open(entry: SpineInboxEntry): Promise<void>;
+    /**
+     * Passa a reler sozinha enquanto `destroyRef` viver (o sino no cabeçalho): lê agora, de minuto em minuto com a aba à
+     * vista e ao voltar para a aba. Vários acompanhando dividem o mesmo relógio.
+     */
+    watch(destroyRef: DestroyRef): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SpineInboxService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<SpineInboxService>;
+}
+
+/**
+ * O sino do cabeçalho: a central de notificações (`SpineInboxService`). O número é quantos itens têm novidade; o
+ * painel lista as novidades das fontes, a mais recente primeiro, e escolher uma abre onde ela está. Sem fonte
+ * registrada, não desenha nada.
+ */
+declare class SpineInboxButtonComponent {
+    protected readonly inbox: SpineInboxService;
+    private readonly messages;
+    protected readonly text: {
+        title: string;
+        button: _trismegisto_primitives.PluralMessage;
+        empty: string;
+        error: string;
+        retry: string;
+        news: _trismegisto_primitives.PluralMessage;
+    };
+    protected readonly buttonLabel: _angular_core.Signal<string>;
+    constructor();
+    protected choose(entry: SpineInboxEntry): void;
+    protected newsText(count: number): string;
+    protected iso(entry: SpineInboxEntry): string;
+    /** "há 5 min", "ontem", "há 3 dias" (Intl, no idioma do catálogo). */
+    protected ago(entry: SpineInboxEntry): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SpineInboxButtonComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SpineInboxButtonComponent, "spine-inbox-button", never, {}, {}, never, never, true, never>;
+}
+
 /** Tipos de sugestão, como o Argos guarda (`web.app_suggestions.kind`). */
 declare const SPINE_SUGGESTION_KINDS: readonly ["melhoria", "nova_funcionalidade", "problema", "outro"];
 type SpineSuggestionKind = (typeof SPINE_SUGGESTION_KINDS)[number];
@@ -2822,10 +3164,7 @@ interface SpineSuggestion {
     kind: SpineSuggestionKind;
     title: string;
     description: string;
-    screen: {
-        path: string | null;
-        label: string | null;
-    };
+    screen: SpineSuggestionScreen;
     status: SpineSuggestionStatus;
     position: number;
     votes: number;
@@ -2838,6 +3177,9 @@ interface SpineSuggestion {
     } | null;
     /** Desde quando está no status atual (o último evento para ele; sem evento, a criação). */
     status_at?: string;
+    /** Com quem está a vez na conversa (null = em dia). */
+    waiting_on?: SpineSuggestionWaiting | null;
+    waiting_since?: string | null;
     created_at: string;
     updated_at: string;
     /** Só no auto-serviço: quem pediu, com a foto (null = pessoa removida). */
@@ -2864,10 +3206,7 @@ interface SpineAppSuggestion {
     title: string;
     /** Texto puro (a descrição inteira, até 4000). */
     description: string;
-    screen: {
-        path: string | null;
-        label: string | null;
-    };
+    screen: SpineSuggestionScreen;
     status: SpineSuggestionStatus;
     votes: number;
     /** Quem consulta apoia. */
@@ -2904,17 +3243,124 @@ interface SpineAppSuggestionsQuery {
 interface SpineSuggestionDraft {
     kind: SpineSuggestionKind;
     title: string;
-    description: string;
+    /** Texto puro (o formato antigo; o servidor ainda aceita). */
+    description?: string;
+    /** A descrição em rich text (o editor do modal); o servidor saneia e deriva o texto puro. */
+    description_html?: string;
+    /** Tela do menu (`router_id` e a rota) ou `new: true` com o nome da tela que ainda não existe em `label`. */
     screen: {
         path: string | null;
         label: string | null;
+        router_id?: string | null;
+        new?: boolean;
     };
 }
+/** Por que a pessoa vê a sugestão (o servidor decide; uma sugestão pode ter vários). */
+declare const SPINE_SUGGESTION_REASONS: readonly ["autor", "relator", "envolvido", "responsavel", "grupo"];
+type SpineSuggestionReason = (typeof SPINE_SUGGESTION_REASONS)[number];
+/** Com quem está a vez na conversa: quem pediu (a equipe respondeu) ou a equipe (quem pediu escreveu). */
+declare const SPINE_SUGGESTION_WAITING: readonly ["solicitante", "responsaveis"];
+type SpineSuggestionWaiting = (typeof SPINE_SUGGESTION_WAITING)[number];
+/** Cor do selo "Aguardando…": a vez de quem pede chama atenção; a da equipe, não. */
+declare const SPINE_SUGGESTION_WAITING_COLORS: Record<SpineSuggestionWaiting, TagColor>;
+declare const SPINE_SUGGESTION_VISIBLE_SORTS: readonly ["activity", "recent", "votes"];
+type SpineSuggestionVisibleSort = (typeof SPINE_SUGGESTION_VISIBLE_SORTS)[number];
+/** A tela de uma sugestão: a do menu (`router_id`, rota e o caminho legível) ou uma nova (`new`, o nome no `label`). */
+interface SpineSuggestionScreen {
+    path: string | null;
+    label: string | null;
+    router_id?: string | null;
+    new?: boolean;
+}
+/**
+ * Uma sugestão que a pessoa VÊ (`/me/suggestions/visible` e o detalhe): as dela, as do grupo dela e as em que ela está
+ * envolvida, com os motivos (`reasons`), se ela pode conversar (`can_comment`, quem tem motivo pessoal) e com quem está
+ * a vez (`waiting_on`).
+ */
+interface SpineVisibleSuggestion {
+    id: string;
+    key: string;
+    kind: SpineSuggestionKind;
+    title: string;
+    description: string;
+    /** A descrição em rich text (saneada pelo servidor); vazia sem descrição. */
+    description_html?: string;
+    screen: SpineSuggestionScreen;
+    status: SpineSuggestionStatus;
+    status_at?: string;
+    votes: number;
+    voted: boolean;
+    mine: boolean;
+    reasons: SpineSuggestionReason[];
+    can_comment: boolean;
+    waiting_on: SpineSuggestionWaiting | null;
+    waiting_since: string | null;
+    comments_count: number;
+    last_comment: {
+        comment: string;
+        created_at: string;
+    } | null;
+    /** Mensagens de outras pessoas que quem consulta ainda não leu. */
+    unread: number;
+    archived: boolean;
+    merged_from: Array<{
+        id: string;
+        key: string;
+        title: string;
+    }>;
+    groups: Array<{
+        id: string;
+        name: string;
+    }>;
+    author: SpineSuggestionPerson | null;
+    assignees: SpineSuggestionPerson[];
+    created_at: string;
+    updated_at: string;
+    last_activity_at?: string;
+}
+/** Contagens do conjunto visível inteiro (sem os filtros), para os filtros rápidos da página. */
+type SpineVisibleCounts = Record<SpineSuggestionReason, number> & {
+    waiting_me: number;
+    unread: number;
+};
+interface SpineVisibleQuery {
+    limit: number;
+    offset: number;
+    reason?: SpineSuggestionReason | '';
+    status?: SpineSuggestionStatus | '';
+    kind?: SpineSuggestionKind | '';
+    waiting?: SpineSuggestionWaiting | '';
+    screen?: string;
+    newScreen?: boolean;
+    q?: string;
+    sort?: SpineSuggestionVisibleSort;
+}
+/** Mensagem da conversa (comentário público): `from_requester` = escrita por quem pediu ou um envolvido. */
+interface SpineSuggestionMessage extends SpineSuggestionComment {
+    from_requester?: boolean;
+}
 /**
  * Sugestões de melhoria da pessoa — `argos-admin /me/suggestions`. Sempre da aplicação LOGADA (o servidor tira o client
  * do access-token da sessão) e com o token da sessão (o servidor recusa x-app-token). Sem `SPINE_ADMIN_API` não há
  * para onde mandar: o botão da barra da página nem aparece (`SpineSuggestButtonComponent`).
  */
+/** Uma sugestão acompanhada com novidade (`/me/suggestions/updates`): a central de notificações. */
+interface SpineSuggestionUpdate {
+    id: string;
+    key: string;
+    title: string;
+    status: SpineSuggestionStatus;
+    /** Quantas novidades desde a última leitura (comentários públicos e mudanças de status de outras pessoas). */
+    count: number;
+    /** A mais recente: o comentário (até 200) ou o status novo, e quem fez. */
+    last: {
+        kind: 'comment' | 'status';
+        status: SpineSuggestionStatus | null;
+        comment: string | null;
+        at: string;
+        author: SpineSuggestionPerson | null;
+    };
+}
 declare class SpineSuggestionsService {
     private readonly http;
     private readonly auth;
@@ -2935,14 +3381,36 @@ declare class SpineSuggestionsService {
         suggestions: SpineAppSuggestion[];
         total: number;
     }>;
-    /** Os comentários públicos de uma sugestão (o detalhe só de leitura), do mais novo. */
+    /** Os comentários públicos de uma sugestão (a conversa), do mais novo. */
     comments(id: string, page: {
         limit: number;
         offset: number;
     }): Promise<{
-        comments: SpineSuggestionComment[];
+        comments: SpineSuggestionMessage[];
+        total: number;
+    }>;
+    /**
+     * As que a pessoa vê (página "Sugestões do app"): as dela, as agrupadas, as em que está envolvida e as do grupo dela,
+     * com filtros e paginação no servidor; `counts` é do conjunto inteiro (os números dos filtros rápidos).
+     */
+    visible(query: SpineVisibleQuery): Promise<{
+        suggestions: SpineVisibleSuggestion[];
         total: number;
+        counts: SpineVisibleCounts | null;
     }>;
+    /** Uma que a pessoa vê, pelo id (404 se não vê). */
+    get(id: string): Promise<SpineVisibleSuggestion>;
+    /** Pela chave ("SUG-12"): o link "?sugestao=SUG-12" abre a sugestão na página. */
+    lookup(key: string): Promise<SpineVisibleSuggestion>;
+    /** Escreve na conversa (quem pediu ou um envolvido): a vez passa para os responsáveis. */
+    reply(id: string, comment: string): Promise<SpineSuggestionMessage>;
+    /** As que a pessoa acompanha com novidade, a mais recente primeiro; `total` = quantas têm novidade. */
+    updates(limit?: number): Promise<{
+        updates: SpineSuggestionUpdate[];
+        total: number;
+    }>;
+    /** Marca a conversa como lida por quem consulta (zera o `unread`). */
+    markRead(id: string): Promise<void>;
     /** As ainda abertas da tela, de qualquer pessoa: o modal oferece apoiar em vez de repetir. */
     byScreen(path: string): Promise<SpineSuggestion[]>;
     vote(id: string): Promise<void>;
@@ -2951,6 +3419,664 @@ declare class SpineSuggestionsService {
     static ɵprov: _angular_core.ɵɵInjectableDeclaration<SpineSuggestionsService>;
 }
 
+/**
+ * A página "Sugestões do app" de quem pede: uma página do PRÓPRIO spine (ver `registerSpineBuiltinPage`), em todo app
+ * com sugestões ligadas, sem cadastro de rota por client. Abre como qualquer tela do workspace (aba, painel, F5, link).
+ */
+declare const SPINE_SUGGESTIONS_PAGE_PATH = "/sugestoes";
+/** Chave sintética da página no distribuidor de telas (não é UUID: não colide com router do banco). */
+declare const SPINE_SUGGESTIONS_PAGE_ID = "spine:sugestoes";
+/** "?sugestao=SUG-12": abrir a página com ela abre a sugestão no painel (o mesmo parâmetro do quadro da equipe). */
+declare const SPINE_SUGGESTION_PAGE_PARAM = "sugestao";
+/** "&aba=conversa": junto com `sugestao`, abre a gaveta na Conversa (sem ele, em Detalhes). */
+declare const SPINE_SUGGESTION_TAB_PARAM = "aba";
+declare const SPINE_SUGGESTION_TAB_CONVERSATION = "conversa";
+/** Sugestões ligadas: o recurso não foi desligado (`SpineFeatures.suggestions`) e há para onde mandar (`SPINE_ADMIN_API`). */
+declare function spineSuggestionsEnabled(): boolean;
+/**
+ * Registra a página no bootstrap (antes da primeira navegação: o F5 em /sugestoes passa pelo `ViewGuard`). Vai no
+ * `provideShell`; com as sugestões desligadas, não registra nada e o endereço cai no fallback de sempre.
+ */
+declare function provideSpineSuggestionsPage(): EnvironmentProviders;
+
+/** Uma tela que dá para escolher no "Sugerir melhoria": a rota, o `router_id` e o caminho legível ("Módulo › Tela"). */
+interface SuggestionScreenOption {
+    path: string;
+    routerId: string | null;
+    /** O nome da tela (o último nível). */
+    name: string;
+    /** O caminho inteiro, como a barra da página mostra ("Vendas › Pedidos › Consulta"): é o que vai para o `screen.label`. */
+    label: string;
+    icon: string;
+}
+/** Valor da opção "Nova tela" no seletor (não é rota: nenhuma rota começa sem "/"). */
+declare const NEW_SCREEN_VALUE = "nova-tela";
+/**
+ * As telas que a pessoa alcança, da árvore de rotas que ela já recebe (`spineRoutesOf(view)`), na ordem do menu: cada
+ * nó com endereço e nome, com o caminho dos ancestrais com endereço (o mesmo "Módulo › … › Tela" da barra da página).
+ * Um endereço aparece uma vez só (o primeiro). Nó com endereço e filhos (módulo que também é página) entra.
+ */
+declare function suggestionScreens(routes: readonly Route[] | null | undefined): SuggestionScreenOption[];
+/** O módulo (primeiro nível) de um caminho legível: "Vendas › Pedidos" → "Vendas". */
+declare function screenModule(label: string | null | undefined): string;
+/** O nome da tela (último nível) de um caminho legível: "Vendas › Pedidos › Consulta" → "Consulta". */
+declare function screenName(label: string | null | undefined): string;
+
+/** De que lado da conversa a tela está: a de quem pede (página) ou a da equipe (detalhe da tarefa). */
+type SpineChatSide = 'solicitante' | 'equipe';
+/** Uma mensagem da conversa de uma sugestão, do jeito que o chat desenha (a página e o detalhe convertem para isto). */
+interface SpineChatMessage {
+    id: string;
+    text: string;
+    created_at: string;
+    author: SpineSuggestionPerson | null;
+    /** Escrita como quem pede (pela página); `false` = como equipe (pelo detalhe da tarefa). */
+    from_requester: boolean;
+    /** Comentário interno da equipe (só aparece do lado da equipe). */
+    internal?: boolean;
+    /** A mudança de status que o comentário acompanha. */
+    status?: SpineSuggestionStatus | null;
+}
+/** Uma linha do chat já resolvida: lado, cabeçalho, agrupamento e o divisor de dia antes dela. */
+interface ChatRow {
+    message: SpineChatMessage;
+    mine: boolean;
+    author: string;
+    grouped: boolean;
+    day: string | null;
+}
+/**
+ * A conversa de uma sugestão como chat (`hm-message-scroller` + `hm-message` + `hm-bubble`), com o campo de resposta
+ * embaixo. Usado nos dois lados: a página de quem pede (`side="solicitante"`) e o detalhe da tarefa da equipe
+ * (`side="equipe"`).
+ *
+ * **Quem fica à direita** é quem está com a tela aberta, no papel desta tela: a mensagem é da pessoa (`me`) E foi
+ * escrita do mesmo lado (`from_requester` casa com `side`). A mesma pessoa no outro papel (quem administra e também
+ * pediu, por exemplo) aparece à esquerda, como qualquer outro participante, com o papel no cabeçalho — a conversa
+ * mostra de que lado cada mensagem foi escrita, não só quem a escreveu.
+ *
+ * - Mensagens do mais ANTIGO ao mais novo; o histórico mais antigo carrega pelo topo (`loadHistory`) sem tirar a
+ *   pessoa do lugar. Divisor de dia ("Hoje", "Ontem", a data) antes da primeira de cada dia.
+ * - Mensagens seguidas da mesma pessoa, no mesmo papel e em poucos minutos se agrupam (sem repetir o cabeçalho).
+ * - Comentário interno (só a equipe vê) em balão de destaque, com um cadeado pequeno no começo (sem selo embaixo: não
+ *   gasta uma linha); a mudança de status que o comentário acompanha, com o selo do status.
+ * - O campo, numa linha só: Enter envia, Shift+Enter quebra a linha. Conteúdo extra do campo (o "Só para a equipe" do detalhe) entra
+ *   por projeção com o atributo `spineChatComposer`. Sem `canWrite`, no lugar do campo vai o conteúdo projetado com
+ *   `spineChatReadOnly`.
+ */
+declare class SpineSuggestionChatComponent {
+    private readonly messages;
+    protected readonly text: {
+        button: string;
+        buttonHint: string;
+        modalTitle: string;
+        intro: string;
+        kind: string;
+        kinds: Record<"melhoria" | "nova_funcionalidade" | "problema" | "outro", string>;
+        statuses: Record<"em_analise" | "planejada" | "em_desenvolvimento" | "concluida" | "recusada", string>;
+        legacyStatuses: Record<"nova", string>;
+        title: string;
+        titlePlaceholder: string;
+        titleRequired: string;
+        description: string;
+        descriptionHint: string;
+        screen: string;
+        screenHint: string;
+        send: string;
+        cancel: string;
+        sent: string;
+        sendError: string;
+        similarHeading: string;
+        similarHint: string;
+        vote: string;
+        voted: string;
+        votes: _trismegisto_primitives.PluralMessage;
+        voteError: string;
+        yours: string;
+        mine: string;
+        mineEmpty: string;
+        mineError: string;
+        loadMore: string;
+        statusFilter: string;
+        allStatuses: string;
+        adminReply: string;
+        sentAt: string;
+        boardLabel: string;
+        search: string;
+        kindFilter: string;
+        allKinds: string;
+        refresh: string;
+        boardFiltered: string;
+        loadError: string;
+        moveError: string;
+        removedAuthor: string;
+        noScreen: string;
+        noDescription: string;
+        requestedBy: string;
+        requestedAt: string;
+        status: string;
+        statusSaved: string;
+        statusError: string;
+        history: string;
+        historyEmpty: string;
+        eventStatus: string;
+        eventComment: string;
+        someone: string;
+        comment: string;
+        commentHint: string;
+        commentSend: string;
+        commentSent: string;
+        commentError: string;
+        commentRequired: string;
+        viewLabel: string;
+        viewBoard: string;
+        viewArchive: string;
+        kpis: string;
+        kpiOpen: string;
+        kpiStatusCount: string;
+        kpiDone: string;
+        kpiDoneToday: string;
+        kpiDoneNoneToday: string;
+        kpiOverdueTrend: string;
+        kpiOverdueSteady: string;
+        kpiSoon: string;
+        kpiMineHint: string;
+        kpiPriority: string;
+        kpiPriorityNone: string;
+        kpiPriorityPart: string;
+        filters: string;
+        moreFilters: string;
+        moreFiltersActive: string;
+        allBoardStatuses: string;
+        newTaskIn: string;
+        newTaskOptions: string;
+        columnOldest: string;
+        columnOverdue: _trismegisto_primitives.PluralMessage;
+        columnEmpty: string;
+        columnEmptyFiltered: string;
+        columnEmptyHints: Record<"em_analise" | "planejada" | "em_desenvolvimento" | "concluida", string>;
+        duration: Record<"days" | "hours" | "minutes", string>;
+        createdOn: string;
+        dueWithin: string;
+        dueLateDays: _trismegisto_primitives.PluralMessage;
+        screenFilter: string;
+        allScreens: string;
+        authorFilter: string;
+        allAuthors: string;
+        sort: string;
+        sorts: Record<"position" | "votes" | "recent", string>;
+        sortHint: string;
+        clearFilters: string;
+        topVoted: string;
+        comments: _trismegisto_primitives.PluralMessage;
+        statusSince: string;
+        openScreen: string;
+        statusChange: string;
+        statusComment: string;
+        statusCommentHint: string;
+        statusApply: string;
+        archiveLabel: string;
+        archiveSearch: string;
+        archiveEmpty: string;
+        archiveEmptyHint: string;
+        archiveCount: _trismegisto_primitives.PluralMessage;
+        closedOn: Record<"concluida" | "recusada", string>;
+        pagination: string;
+        reopen: string;
+        reopened: string;
+        reopenError: string;
+        newTask: string;
+        addTaskPlaceholder: string;
+        taskCreated: string;
+        createError: string;
+        saveError: string;
+        kpiMine: string;
+        kpiOverdue: string;
+        assigneeFilter: string;
+        allAssignees: string;
+        assigneeMine: string;
+        assigneeNone: string;
+        labelFilter: string;
+        allLabels: string;
+        priorityFilter: string;
+        allPriorities: string;
+        dueFilter: string;
+        dueAny: string;
+        dueOverdueFilter: string;
+        dueSoonFilter: string;
+        priority: string;
+        priorities: Record<"urgente" | "alta" | "media" | "baixa", string>;
+        dueOn: string;
+        dueToday: string;
+        dueTomorrow: string;
+        dueLate: string;
+        checklistSpoken: string;
+        moreAssignees: string;
+        cardMenu: string;
+        menuStatus: string;
+        menuAssignMe: string;
+        menuCopyLink: string;
+        menuCopyKey: string;
+        menuLabel: string;
+        menuNoLabels: string;
+        menuPriority: string;
+        menuArchive: string;
+        menuRestore: string;
+        menuDelete: string;
+        labelColorName: string;
+        linkCopied: string;
+        keyCopied: string;
+        copyError: string;
+        deleteHeading: string;
+        deleteMessage: string;
+        deleteConfirm: string;
+        deleted: string;
+        archivedToast: string;
+        restoredToast: string;
+        assignedToMe: string;
+        archivedTag: string;
+        taskLabel: string;
+        close: string;
+        editTitle: string;
+        editDescription: string;
+        save: string;
+        checklist: string;
+        checklistAdd: string;
+        checklistPlaceholder: string;
+        checklistOnCard: string;
+        checklistEmpty: string;
+        checklistRemove: string;
+        checklistUp: string;
+        checklistDown: string;
+        tabComments: string;
+        tabActivity: string;
+        commentsEmpty: string;
+        activityEmpty: string;
+        commentInternal: string;
+        internalTag: string;
+        activity: Record<"created" | "title" | "description" | "kind" | "priority" | "start_date" | "start_date_removed" | "due_date" | "due_date_removed" | "cover" | "cover_removed" | "checklist_on_card" | "screen" | "assignee_added" | "assignee_removed" | "watcher_added" | "watcher_removed" | "label_added" | "label_removed" | "checklist_added" | "checklist_done" | "checklist_undone" | "checklist_renamed" | "checklist_removed" | "archived" | "restored" | "merged" | "merged_here" | "unmerged" | "unmerged_here" | "other", string>;
+        assignees: string;
+        assignMe: string;
+        addAssignee: string;
+        watchers: string;
+        addWatcher: string;
+        removePerson: string;
+        peopleSearch: string;
+        peopleEmpty: string;
+        nobody: string;
+        reporter: string;
+        originUser: string;
+        originTeam: string;
+        startDate: string;
+        dueDate: string;
+        labels: string;
+        addLabel: string;
+        createLabel: string;
+        labelColor: string;
+        noLabels: string;
+        screenOrigin: string;
+        votesField: string;
+        createdAt: string;
+        updatedAt: string;
+        lastChange: string;
+        lastChangeNoActor: string;
+        key: string;
+        copyKey: string;
+        newTaskHeading: string;
+        createTask: string;
+        draftHint: string;
+        assignMeOnCreate: string;
+        appSuggestions: string;
+        listView: string;
+        tabAll: string;
+        tabMine: string;
+        appSearch: string;
+        thisScreen: string;
+        appSorts: Record<"votes" | "recent", string>;
+        appEmpty: string;
+        appEmptyHint: string;
+        appEmptyFiltered: string;
+        appError: string;
+        support: string;
+        supported: string;
+        ownSupportHint: string;
+        publicComments: string;
+        publicCommentsEmpty: string;
+        commentsError: string;
+        moreComments: string;
+        appPagination: string;
+        menuMerge: string;
+        mergeHeading: string;
+        mergeIntro: string;
+        mergeSearch: string;
+        mergeNone: string;
+        mergeHasMerged: string;
+        mergePreview: string;
+        mergeCalculating: string;
+        mergePreviewError: string;
+        reportersCount: _trismegisto_primitives.PluralMessage;
+        mergeConfirmHeading: string;
+        mergeConfirmMessage: string;
+        mergeConfirm: string;
+        mergedToast: string;
+        mergeError: string;
+        mergedTag: string;
+        mergedInto: string;
+        mergedIntoHint: string;
+        openMerged: string;
+        unmerge: string;
+        unmergeLabel: string;
+        unmergedToast: string;
+        reporters: string;
+        reporterAuthor: string;
+        reporterVia: string;
+        mergedHere: string;
+        mergedFrom: string;
+        mergedFromHint: string;
+        buttonMenu: string;
+        openPage: string;
+        screenPick: string;
+        screenPickHint: string;
+        screenPickPlaceholder: string;
+        newScreenOption: string;
+        newScreenName: string;
+        newScreenHint: string;
+        newScreenRequired: string;
+        newScreenTag: string;
+        waiting: Record<"solicitante" | "responsaveis", string>;
+        waitingFilter: string;
+        waitingAny: string;
+        waitingClear: string;
+        waitingSaved: string;
+        menuWaiting: string;
+        groupFilter: string;
+        allGroups: string;
+        requestingGroups: string;
+        noGroups: string;
+        unread: _trismegisto_primitives.PluralMessage;
+        fromRequester: string;
+        cardChecklist: _trismegisto_primitives.PluralMessage;
+        requestedByName: string;
+        tabSummary: string;
+        chatAuthor: string;
+        chatSendHint: string;
+        inbox: {
+            label: string;
+            comment: string;
+            status: string;
+        };
+        page: {
+            title: string;
+            description: string;
+            allTitle: string;
+            statusPart: string;
+            reasons: Record<"autor" | "relator" | "envolvido" | "responsavel" | "grupo", string>;
+            reasonHints: Record<"autor" | "relator" | "envolvido" | "responsavel" | "grupo", string>;
+            reasonFilter: string;
+            allReasons: string;
+            needsYou: string;
+            sorts: Record<"activity" | "recent" | "votes", string>;
+            empty: string;
+            emptyHint: string;
+            emptyFiltered: string;
+            error: string;
+            count: _trismegisto_primitives.PluralMessage;
+            pickOne: string;
+            notFound: string;
+            conversation: string;
+            conversationEmpty: string;
+            conversationError: string;
+            olderMessages: string;
+            reply: string;
+            replyPlaceholder: string;
+            replySend: string;
+            replyError: string;
+            readOnly: string;
+            team: string;
+            you: string;
+            groups: string;
+            details: string;
+            listLabel: string;
+            filtersLabel: string;
+            waitingYou: string;
+            waitingTeam: string;
+        };
+        planning: {
+            viewSummary: string;
+            viewTasks: string;
+            viewPlanning: string;
+            viewSchedule: string;
+            viewRisks: string;
+            viewWorkflow: string;
+            loadError: string;
+            saveError: string;
+            retry: string;
+            save: string;
+            cancel: string;
+            delete: string;
+            edit: string;
+            points: string;
+            pointsValue: _trismegisto_primitives.PluralMessage;
+            noEstimate: string;
+            backlog: string;
+            noSprint: string;
+            unassigned: string;
+            dateRange: string;
+            summary: {
+                activeSprint: string;
+                sprintPoints: string;
+                sprintCapacity: string;
+                openTasks: string;
+                overdue: string;
+                mine: string;
+                mineEmpty: string;
+                deadlines: string;
+                deadlinesEmpty: string;
+                topRisks: string;
+                topRisksEmpty: string;
+                riskScore: string;
+                nextMilestone: string;
+                nextMilestoneEmpty: string;
+            };
+            tasks: {
+                viewLabel: string;
+                viewList: string;
+                viewTable: string;
+                listLabel: string;
+                gridCaption: string;
+                count: _trismegisto_primitives.PluralMessage;
+                open: string;
+                emptyHeading: string;
+                emptyBody: string;
+                key: string;
+                title: string;
+                status: string;
+                priority: string;
+                assignee: string;
+                sprint: string;
+                due: string;
+            };
+            sprints: {
+                heading: string;
+                hint: string;
+                readOnlyClosed: string;
+                new: string;
+                start: string;
+                close: string;
+                state: Record<"planned" | "active" | "closed", string>;
+                closeHeading: string;
+                closeMessage: string;
+                deleteHeading: string;
+                deleteMessage: string;
+                newHeading: string;
+                editHeading: string;
+                name: string;
+                nameRequired: string;
+                goal: string;
+                start_date: string;
+                end_date: string;
+                datesRequired: string;
+                datesOrder: string;
+                capacity: string;
+                activeExists: string;
+                moved: string;
+                progressHeading: string;
+                done: string;
+                committed: string;
+                capacityUse: string;
+                burndownCaption: string;
+                day: string;
+                ideal: string;
+                remaining: string;
+                closed: string;
+            };
+            schedule: {
+                heading: string;
+                label: string;
+                hint: string;
+                milestones: string;
+                newMilestone: string;
+                milestoneTitle: string;
+                milestoneDate: string;
+                milestoneRequired: string;
+                removeMilestone: string;
+                rescheduled: string;
+                conflicts: string;
+                workloadHeading: string;
+                workloadLabel: string;
+                workloadHint: string;
+                week: string;
+                noPeople: string;
+            };
+            risks: {
+                heading: string;
+                label: string;
+                hint: string;
+                new: string;
+                newHeading: string;
+                editHeading: string;
+                title: string;
+                titleRequired: string;
+                owner: string;
+                status: string;
+                mitigation: string;
+                deleteHeading: string;
+                statuses: Record<"identified" | "mitigating" | "closed", string>;
+                task: string;
+                taskPlaceholder: string;
+                taskRequired: string;
+                noTask: string;
+                level: string;
+                levels: Record<"low" | "medium" | "high" | "critical", string>;
+                ofTask: string;
+                add: string;
+                empty: string;
+            };
+            workflow: {
+                heading: string;
+                hint: string;
+                label: string;
+                count: _trismegisto_primitives.PluralMessage;
+                plan: string;
+                start: string;
+                finish: string;
+                refuse: string;
+                reopen: string;
+            };
+            detail: {
+                estimate: string;
+                sprint: string;
+                backlogOption: string;
+                dependsOn: string;
+                dependsOnPlaceholder: string;
+                dependencyCycle: string;
+                blockedBy: string;
+            };
+        };
+    };
+    private readonly preferences;
+    private readonly scroller;
+    /** As mensagens, do mais antigo ao mais novo. */
+    readonly items: _angular_core.InputSignal<readonly SpineChatMessage[]>;
+    /** O papel desta tela: as mensagens da pessoa escritas deste lado ficam à direita. */
+    readonly side: _angular_core.InputSignal<SpineChatSide>;
+    /** O `user_id` de quem está com a tela aberta. */
+    readonly me: _angular_core.InputSignal<string>;
+    readonly label: _angular_core.InputSignal<string>;
+    readonly empty: _angular_core.InputSignal<string>;
+    readonly hasMore: _angular_core.InputSignal<boolean>;
+    readonly loading: _angular_core.InputSignal<boolean>;
+    readonly canWrite: _angular_core.InputSignal<boolean>;
+    readonly composerLabel: _angular_core.InputSignal<string>;
+    readonly placeholder: _angular_core.InputSignal<string>;
+    readonly sendLabel: _angular_core.InputSignal<string>;
+    readonly sending: _angular_core.InputSignal<boolean>;
+    readonly error: _angular_core.InputSignal<string>;
+    /** O texto do campo (em mão dupla: quem usa limpa depois de enviar). */
+    readonly draft: _angular_core.ModelSignal<string>;
+    readonly loadHistory: _angular_core.OutputEmitterRef<void>;
+    /** Enviar: o texto aparado (nunca vazio). */
+    readonly send: _angular_core.OutputEmitterRef<string>;
+    protected readonly statusColors: Record<"em_analise" | "planejada" | "em_desenvolvimento" | "concluida" | "recusada", _trismegisto_angular.TagColor>;
+    protected readonly timeFormat: Intl.DateTimeFormatOptions;
+    protected readonly rows: _angular_core.Signal<ChatRow[]>;
+    /** Depois de enviar: a pessoa quer ver a própria mensagem, mesmo se estava lendo lá em cima. */
+    scrollToEnd(): void;
+    protected onKey(event: Event): void;
+    protected submit(): void;
+    protected statusOf(m: SpineChatMessage): SpineSuggestionStatus | null;
+    /** "Ana Souza (Equipe)": do outro lado, o papel junto do nome — inclusive a própria pessoa no outro papel. */
+    private authorText;
+    private dayKey;
+    /** "Hoje", "Ontem" ou a data por extenso (no idioma do catálogo e no fuso da pessoa). */
+    private dayLabel;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SpineSuggestionChatComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SpineSuggestionChatComponent, "spine-suggestion-chat", never, { "items": { "alias": "items"; "required": false; "isSignal": true; }; "side": { "alias": "side"; "required": true; "isSignal": true; }; "me": { "alias": "me"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "empty": { "alias": "empty"; "required": false; "isSignal": true; }; "hasMore": { "alias": "hasMore"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "canWrite": { "alias": "canWrite"; "required": false; "isSignal": true; }; "composerLabel": { "alias": "composerLabel"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "sendLabel": { "alias": "sendLabel"; "required": false; "isSignal": true; }; "sending": { "alias": "sending"; "required": false; "isSignal": true; }; "error": { "alias": "error"; "required": false; "isSignal": true; }; "draft": { "alias": "draft"; "required": false; "isSignal": true; }; }, { "draft": "draftChange"; "loadHistory": "loadHistory"; "send": "send"; }, never, ["[spineChatComposer]", "[spineChatReadOnly]"], true, never>;
+}
+
+/** Um selo da linha: o nome e, se quiser, a cor (1..8, a paleta categórica do tema); sem cor, uma estável pelo id. */
+interface SpineTagRowItem {
+    id: string;
+    name: string;
+    color?: number;
+}
+/** Cor categórica estável para um id (o mesmo grupo sempre na mesma cor, em qualquer tela). */
+declare function spineTagColor(id: string): number;
+/**
+ * Selos numa linha só, no modelo dos rótulos do quadro (fundo claro da cor e o ponto na cor cheia): cabem os que cabem
+ * na largura e o resto vira "+N", com os nomes na dica e para o leitor de tela. Mede de novo quando a largura muda
+ * (ResizeObserver) e quando a lista muda; sem medida (servidor, teste sem layout), mostra todos.
+ *
+ * Os que não cabem continuam no DOM, fora do fluxo e invisíveis (`visibility: hidden`), só para a largura deles poder
+ * ser medida; ficam `aria-hidden` — quem lê a tela ouve os nomes no "+N".
+ */
+declare class SpineTagRowComponent {
+    private readonly text;
+    private readonly host;
+    private readonly browser;
+    private readonly injector;
+    private readonly destroyRef;
+    readonly items: _angular_core.InputSignal<readonly SpineTagRowItem[]>;
+    readonly label: _angular_core.InputSignal<string>;
+    /** Texto quando não há nenhum (vazio = nada). */
+    readonly empty: _angular_core.InputSignal<string>;
+    protected readonly tags: _angular_core.Signal<{
+        color: number;
+        id: string;
+        name: string;
+    }[]>;
+    /** Quantos cabem; começa com todos (sem medida, todos aparecem). */
+    protected readonly visible: _angular_core.WritableSignal<number>;
+    protected readonly hiddenCount: _angular_core.Signal<number>;
+    protected readonly hiddenNames: _angular_core.Signal<string>;
+    protected readonly moreText: _angular_core.Signal<string>;
+    constructor();
+    /** Quantos selos cabem na largura, reservando o "+N" quando nem todos cabem. */
+    private measure;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SpineTagRowComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SpineTagRowComponent, "spine-tag-row", never, { "items": { "alias": "items"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "empty": { "alias": "empty"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
 /**
  * Modal de documentação das telas: índice (com busca) à esquerda e leitura à direita. Montado uma vez
  * pelo `spine-layout`; abrir, fechar e o que se lê vêm todos do `SpineDocsService`.
@@ -2996,6 +4122,6 @@ declare const SPINE_MARKDOWN_PURIFY_CONFIG: Config;
 /** HTML limpo pelo perfil do spine, ou `null` quando não há DOM (SSR: melhor não renderizar). */
 declare function sanitizeSpineMarkdownHtml(html: string): string | null;
 
-export { AiAgentComponent, AppLauncherComponent, HeaderComponent, LayoutComponent, SPINE_BRAND, SPINE_GLOBAL_PREFERENCE_KEYS, SPINE_IDLE_WARNING_SECONDS, SPINE_MARKDOWN_PURIFY_CONFIG, SPINE_PREFERENCES_SAVE_DELAY_MS, SPINE_RATING_COMMENT_MAX, SPINE_RATING_SCORE_MAX, SPINE_SETTINGS_ALIASES, SPINE_SETTINGS_KEYS, SPINE_SETTINGS_SECTIONS, SPINE_SUGGESTION_KINDS, SPINE_SUGGESTION_KIND_COLORS, SPINE_SUGGESTION_KIND_ICONS, SPINE_SUGGESTION_LIMITS, SPINE_SUGGESTION_PUBLIC_SORTS, SPINE_SUGGESTION_PUBLIC_STATUSES, SPINE_SUGGESTION_STATUSES, SPINE_SUGGESTION_STATUS_COLORS, SPINE_SUGGESTION_STATUS_ICONS, SettingsPanelComponent, ShortcutService, ShortcutsCheatsheetComponent, SidebarComponent, SpineAccountPreferencesService, SpineAccountSecurityService, SpineAppTokensService, SpineBrandComponent, SpineConnectionBannerComponent, SpineDocsComponent, SpineDocsService, SpineIdleService, SpineIdleWarningComponent, SpineInitialSetupComponent, SpineInitialSetupService, SpineLogoutService, SpineMarkdownComponent, SpineMyGroupsService, SpineNewsComponent, SpineNewsService, SpineNoticesService, SpinePageActionsDirective, SpinePageActionsSlot, SpineRatingStarsComponent, SpineRatingsService, SpineSettingsService, SpineStartPageService, SpineSuggestionsService, accountErrorCode, argosAccountApi, buildMcpConfig, effectiveIdleMinutes, idleLimits, isInternalPath, provideSettingsSection, ratingTargetKey, resolveSettingsSection, sanitizeSpineMarkdownHtml, spineScoreBand, spineStarFills, stable };
-export type { AccountActivityEntry, AccountActivityPage, AccountBadges, AccountMethod, AccountOverview, AccountPreferences, AccountReauth, AccountSession, AppToken, AppTokenList, AppTokenOptions, CreatedAppToken, DocsEntry, DocsGroup, DocsView, GroupMember, GroupRole, ManagedGroup, RealmUser, ShortcutActions, SpineAccountPreferencesDoc, SpineAccountPreferencesStatus, SpineAppSuggestion, SpineAppSuggestionsQuery, SpineGlobalPreferencesDoc, SpineIdleLimits, SpineInitialSetupMode, SpineInitialSetupStep, SpineNewsAuthor, SpineNewsDetail, SpineNewsFilter, SpineNewsKind, SpineNewsPage, SpineNewsSummary, SpineNotice, SpineNoticePermission, SpineRating, SpineRatingAverage, SpineRatingScope, SpineRatingTarget, SpineScoreBand, SpineSettingsSection, SpineStarFill, SpineSuggestion, SpineSuggestionComment, SpineSuggestionDraft, SpineSuggestionKind, SpineSuggestionPerson, SpineSuggestionPublicSort, SpineSuggestionPublicStatus, SpineSuggestionStatus };
+export { AiAgentComponent, AppLauncherComponent, HeaderComponent, LayoutComponent, NEW_SCREEN_VALUE, SPINE_BRAND, SPINE_GLOBAL_PREFERENCE_KEYS, SPINE_IDLE_WARNING_SECONDS, SPINE_INBOX_POLL_MS, SPINE_INBOX_SOURCES, SPINE_MARKDOWN_PURIFY_CONFIG, SPINE_PREFERENCES_SAVE_DELAY_MS, SPINE_RATING_COMMENT_MAX, SPINE_RATING_SCORE_MAX, SPINE_SETTINGS_ALIASES, SPINE_SETTINGS_KEYS, SPINE_SETTINGS_SECTIONS, SPINE_SUGGESTIONS_PAGE_ID, SPINE_SUGGESTIONS_PAGE_PATH, SPINE_SUGGESTION_KINDS, SPINE_SUGGESTION_KIND_COLORS, SPINE_SUGGESTION_KIND_ICONS, SPINE_SUGGESTION_LIMITS, SPINE_SUGGESTION_PAGE_PARAM, SPINE_SUGGESTION_PUBLIC_SORTS, SPINE_SUGGESTION_PUBLIC_STATUSES, SPINE_SUGGESTION_REASONS, SPINE_SUGGESTION_STATUSES, SPINE_SUGGESTION_STATUS_COLORS, SPINE_SUGGESTION_STATUS_ICONS, SPINE_SUGGESTION_TAB_CONVERSATION, SPINE_SUGGESTION_TAB_PARAM, SPINE_SUGGESTION_VISIBLE_SORTS, SPINE_SUGGESTION_WAITING, SPINE_SUGGESTION_WAITING_COLORS, SPINE_TAB, SPINE_WORKSPACE_LIMITS, SettingsPanelComponent, ShortcutService, ShortcutsCheatsheetComponent, SidebarComponent, SpineAccountPreferencesService, SpineAccountSecurityService, SpineAppTokensService, SpineBrandComponent, SpineConnectionBannerComponent, SpineDocsComponent, SpineDocsService, SpineIdleService, SpineIdleWarningComponent, SpineInboxButtonComponent, SpineInboxService, SpineInitialSetupComponent, SpineInitialSetupService, SpineLogoutService, SpineMarkdownComponent, SpineMyGroupsService, SpineNewsComponent, SpineNewsService, SpineNoticesService, SpinePageActionsDirective, SpinePageActionsSlot, SpineRatingStarsComponent, SpineRatingsService, SpineSettingsService, SpineStartPageService, SpineSuggestionChatComponent, SpineSuggestionsService, SpineTagRowComponent, SpineUnsavedChangesService, SpineWorkspaceNavService, accountErrorCode, argosAccountApi, buildMcpConfig, effectiveIdleMinutes, idleLimits, isInternalPath, provideSettingsSection, provideSpineInboxSource, provideSpineSuggestionsPage, ratingTargetKey, registerSpineUnsavedChanges, resolveSettingsSection, sanitizeSpineMarkdownHtml, screenModule, screenName, spineNormalizeUrl, spineParamsOf, spinePathOf, spineScoreBand, spineStarFills, spineSuggestionsEnabled, spineTagColor, stable, suggestionScreens };
+export type { AccountActivityEntry, AccountActivityPage, AccountBadges, AccountMethod, AccountOverview, AccountPreferences, AccountReauth, AccountSession, AppToken, AppTokenList, AppTokenOptions, CreatedAppToken, DocsEntry, DocsGroup, DocsView, GroupMember, GroupMembersPage, GroupMembersQuery, GroupRole, ManagedGroup, RealmUser, ShortcutActions, SpineAccountPreferencesDoc, SpineAccountPreferencesStatus, SpineAppSuggestion, SpineAppSuggestionsQuery, SpineChatMessage, SpineChatSide, SpineGlobalPreferencesDoc, SpineIdleLimits, SpineInboxEntry, SpineInboxItem, SpineInboxSource, SpineInitialSetupMode, SpineInitialSetupStep, SpineNewsAuthor, SpineNewsDetail, SpineNewsFilter, SpineNewsKind, SpineNewsPage, SpineNewsSummary, SpineNotice, SpineNoticePermission, SpineOpenTabOptions, SpineRating, SpineRatingAverage, SpineRatingScope, SpineRatingTarget, SpineScoreBand, SpineSettingsSection, SpineStarFill, SpineSuggestion, SpineSuggestionComment, SpineSuggestionDraft, SpineSuggestionKind, SpineSuggestionMessage, SpineSuggestionPerson, SpineSuggestionPublicSort, SpineSuggestionPublicStatus, SpineSuggestionReason, SpineSuggestionScreen, SpineSuggestionStatus, SpineSuggestionUpdate, SpineSuggestionVisibleSort, SpineSuggestionWaiting, SpineTab, SpineTabParams, SpineTagRowItem, SpineVisibleCounts, SpineVisibleQuery, SpineVisibleSuggestion, SuggestionScreenOption };
 //# sourceMappingURL=trismegisto-spine-layout.d.ts.map