@trismegisto/spine 3.3.0 → 3.3.2

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

@@ -1,13 +1,13 @@
 import * as _angular_core from '@angular/core';
-import { OnDestroy, OnInit, ElementRef, InjectionToken, Type, Provider } from '@angular/core';
+import { OnDestroy, OnInit, InjectionToken, Type, Provider, TemplateRef } from '@angular/core';
 import { Router } from '@angular/router';
 import * as _trismegisto_spine from '@trismegisto/spine';
-import { SpineConfig, SpineNewsSlide, Route, ThemeService, ThemePresetService, DensityService, SpineHourCyclePreference, SpineStartPagePreference, SpineNoticeType, SpinePreferencesService, SpineMcpServer, SpineFeatures } from '@trismegisto/spine';
-import { BehaviorSubject, Observable, Subject } from 'rxjs';
+import { Route, ThemeService, ThemePresetService, DensityService, SpineConfig, SpinePreferencesService, SpineHourCyclePreference, SpineStartPagePreference, SpineNoticeType, SpineMcpServer, SpineFeatures } from '@trismegisto/spine';
+import { Subject } from 'rxjs';
 import * as _trismegisto_angular from '@trismegisto/angular';
-import { HermesShortcutItem, WorkspaceStore, TabItem, MenuItem, SidebarNode, HermesThemeMode, HermesDensity, HermesSidebarService, SegmentedOption, ComboboxOption } from '@trismegisto/angular';
+import { HermesShortcutItem, WorkspaceStore, TabItem, MenuItem, HermesCommand, SidebarNode, HermesThemeMode, HermesDensity, SegmentedOption, HermesSidebarService, ComboboxOption, BreadcrumbItem, TagColor } from '@trismegisto/angular';
 import * as _trismegisto_primitives from '@trismegisto/primitives';
-import { formatMessage, HermesMotionPreference, Weekday, AlertVariant, HermesFont } from '@trismegisto/primitives';
+import { formatMessage, 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';
@@ -16,147 +16,176 @@ import { RouteDocument } from '@trismegisto/spine/routing';
 import { SafeHtml } from '@angular/platform-browser';
 import { Config } from 'dompurify';
 
+/** `full`: aparência e depois o essencial (primeiro acesso, "Refazer"). `essentials`: só os cartões do essencial. */
+type SpineInitialSetupMode = 'full' | 'essentials';
+/** Etapa na tela: a escolha de aparência ou os cartões do essencial. */
+type SpineInitialSetupStep = 'appearance' | 'essentials';
 /**
- * Fase do tour: `idle` (inativo: não é devido, terminou, foi pulado/interrompido ou não sobrou passo),
- * `pending` (vai aparecer: desde o `maybeStart()`/`restart()` até o primeiro passo, enquanto espera o
- * shell e os alvos) e `running` (um passo na tela). Quem não pode disputar a tela com o tour (o painel
- * de novidades) espera `idle` — não um tempo fixo.
- */
-type OnboardingState = 'idle' | 'pending' | 'running';
-interface OnboardingStep {
-    /** seletor CSS do alvo; ausente = passo centralizado (boas-vindas/encerramento). */
-    target?: string;
-    title: string;
-    /** pode conter HTML simples (<b>). */
-    description: string;
-}
-/**
- * Primeiro elemento do seletor que está de fato na tela (tem tamanho e conteúdo). Não usa
- * `offsetParent`: ele é `null` pra `position: fixed` (a sidebar) e pra `display: contents`, e o
- * passo sumia do tour mesmo com o alvo visível. Com as abas vivas do workspace há uma barra de
- * página por aba — só a da aba ativa tem tamanho, e é ela que o holofote precisa achar.
- */
-declare function findTourTarget(selector: string): HTMLElement | null;
-/**
- * Onboarding interativo próprio (sem dependência externa). O overlay/holofote e o
- * balão são renderizados pelo OnboardingOverlayComponent, que escuta este serviço.
- * Aparece uma vez por máquina (flag em localStorage), namespaced por cliente.
+ * Configuração inicial em tela cheia (`spine-initial-setup`, montada no layout): no primeiro acesso a pessoa escolhe
+ * tema, cor, densidade, tamanho do texto, fonte e animações, com a prévia ao lado, e depois vê o essencial (busca,
+ * abas, favoritos, configurações). Pode pular a qualquer momento: pular também conta como feita.
+ *
+ * "Feita" é da pessoa, não do app (`SpineAccountPreferencesService.setupDone`, no documento global do Argos): quem
+ * fez num sistema não a vê de novo em outro. Sem a conta, fica no navegador. Desligada com
+ * `SpineFeatures.initialSetup: false`.
  */
-declare class OnboardingService {
-    private readonly text;
-    /** Passo atual (null = tour inativo). O overlay component reage a isto. */
-    readonly current$: BehaviorSubject<{
-        step: OnboardingStep;
-        index: number;
-        total: number;
-    } | null>;
-    private readonly stateSubject;
-    /** Fase do tour (ver `OnboardingState`). Emite o valor atual ao assinar. */
-    readonly state$: Observable<OnboardingState>;
-    /** Fase atual, síncrona. */
-    get state(): OnboardingState;
-    private readonly doneKey;
-    private steps;
-    private index;
-    private waiting;
-    constructor(config: SpineConfig | null);
-    private get done();
-    private markDone;
-    /**
-     * Dispara o tour só se ainda não foi visto nesta máquina. Chamar após o login. Quando é devido, o
-     * estado vira `pending` NA HORA (síncrono), antes da espera pelo shell — é isso que segura as
-     * novidades; quando não é, continua `idle`. Chamar de novo com o tour já em andamento não faz nada.
-     */
-    maybeStart(): void;
-    /** Reabre o tour manualmente (menu Ajuda), ignorando a flag. Também passa por `pending` → `running`. */
-    restart(): void;
-    /**
-     * Interrompe o tour (pendente ou na tela) SEM marcar como visto: o automático volta na próxima entrada.
-     * Usado quando a pessoa abre outra coisa que disputaria a tela com ele (as novidades pelo menu).
-     */
-    stop(): void;
-    /** Passos no idioma ativo (o texto é lido do catálogo ao começar o tour). Descrições com `<b>`. */
-    private allSteps;
+declare class SpineInitialSetupService {
+    private readonly preferences;
+    private readonly injector;
+    /** Ligada (padrão) ou desligada pelo app (`SpineFeatures.initialSetup: false`). */
+    readonly enabled: boolean;
+    readonly isOpen: _angular_core.WritableSignal<boolean>;
+    readonly mode: _angular_core.WritableSignal<SpineInitialSetupMode>;
+    readonly step: _angular_core.WritableSignal<SpineInitialSetupStep>;
+    private asked;
     /**
-     * Começa do primeiro passo assim que todos os alvos estão na tela, ou no fim do prazo só com os passos
-     * que têm alvo visível (e os sem alvo). Sem nenhum passo, só marca como visto. Não bloqueia: confere
-     * de novo a cada `TARGET_POLL_MS`.
+     * Chamado uma vez pelo layout na entrada: abre se a configuração ainda não foi feita. Espera a conta responder
+     * (`setupDone` deixa de ser `null`), sem prazo: quem decide é a conta, e a falha dela cai no que o navegador sabe.
      */
-    private start;
-    private emit;
-    private setState;
-    private clearWaiting;
+    maybeOpen(): void;
+    /** Abre a configuração inteira (aparência e o essencial), mesmo já feita: "Refazer" nas configurações. */
+    open(): void;
+    /** Só os cartões do essencial ("Rever o essencial": menu do perfil, atalhos, tela inicial). */
+    openEssentials(): void;
     next(): void;
-    prev(): void;
-    /** Encerra o tour (concluído ou pulado) e marca como visto. */
+    back(): void;
+    /** Concluída ou pulada: marca como feita e fecha. */
     finish(): void;
-    get isFirst(): boolean;
-    get isLast(): boolean;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<OnboardingService, [{ optional: true; }]>;
-    static ɵprov: _angular_core.ɵɵInjectableDeclaration<OnboardingService>;
+    /** `true` quando já deu para decidir (feita ou aberta agora). */
+    private decide;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SpineInitialSetupService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<SpineInitialSetupService>;
 }
 
+/** Quem escreveu a novidade, como o argos-admin devolve (nome ou usuário, e a foto). */
+interface SpineNewsAuthor {
+    readonly name: string;
+    readonly picture: string | null;
+}
+/**
+ * Tipo da novidade: só texto (`informativo`); "o que há de novo", com introdução e a lista de mudanças
+ * (`implementacao`); ou "como era x como ficou", com introdução e o antes e o agora (`alteracao`).
+ */
+type SpineNewsKind = 'informativo' | 'implementacao' | 'alteracao';
+/** Uma novidade na lista (`GET /me/news`): sem o corpo. */
+interface SpineNewsSummary {
+    readonly id: string;
+    /** Servidor antigo não manda: vale `informativo`. */
+    readonly kind?: SpineNewsKind;
+    readonly title: string;
+    readonly summary: string;
+    readonly published_at: string;
+    readonly author: SpineNewsAuthor | null;
+}
 /**
- * Painel de novidades do app (ver `provideSpineNews`). Decide o que está devido — ainda não visto
- * NESTE navegador e ainda dentro do `until` — e abre sozinho uma vez, depois do tour de boas-vindas.
- * O "já visto" é por app (`hermes_<clientId>_news_seen`): novidade de um app não some por ter sido
- * vista em outro no mesmo domínio.
+ * Uma novidade aberta (`GET /me/news/:id`): com o conteúdo, já saneado pelo servidor ao gravar. `body_html` é o texto
+ * (no informativo) ou a introdução (nos outros tipos); `items` é a lista da implementação; `before_html` e `after_html`,
+ * os dois lados da alteração.
+ */
+interface SpineNewsDetail extends SpineNewsSummary {
+    readonly body_html: string;
+    readonly items?: readonly string[];
+    readonly before_html?: string;
+    readonly after_html?: string;
+    /** Alterada depois de publicada: quem editou por último e quando (servidor antigo não manda). */
+    readonly edited?: (SpineNewsAuthor & {
+        readonly at: string;
+    }) | null;
+}
+/** Uma página da lista. */
+interface SpineNewsPage {
+    readonly news: readonly SpineNewsSummary[];
+    readonly total: number;
+    readonly page: number;
+    readonly limit: number;
+}
+/**
+ * Novidades do app, escritas por quem o administra (auto-serviço ou painel central do Argos) e lidas de
+ * `argos-admin /me/news` — sempre da aplicação LOGADA e só as publicadas, na validade e para o público da pessoa (o
+ * servidor filtra). Sem `SPINE_ADMIN_API` (ou sem HTTP) não há novidades e nada aparece, sem erro.
+ *
+ * Sem interromper ninguém:
+ * - na entrada (`announceOnEntry`), lê as mais recentes e avisa no canto as ainda não anunciadas ("Novidade: …" ou
+ *   "N novidades", com "Ver"), uma vez por novidade e depois da configuração inicial;
+ * - o menu do perfil mostra quantas faltam ver (`unseenCount`) e o Início lista as primeiras (`highlights`);
+ * - "Ver" (aviso, menu, Início, configurações) abre o painel lateral (`showAll`), paginado; abrir uma novidade
+ *   (`markSeen`) a marca como vista.
  *
- * Tour e novidades nunca dividem a tela: na entrada, as novidades esperam o tour ficar `idle` (ver
- * `OnboardingState`); fora dela, vale a última ação explícita da pessoa — o tour reaberto pelo menu
- * Ajuda fecha o painel de novidades, e as novidades abertas pelo menu interrompem o tour (sem marcá-lo
- * como visto).
+ * "Anunciada", "vista" e "favorita" são por app, por navegador e por id (`hermes_<clientId>_news_*`): novidade de um
+ * app não some por ter sido vista em outro no mesmo domínio. "Marcar como não lida" (`markUnseen`) desfaz o "vista".
  */
 declare class SpineNewsService {
-    private readonly onboarding;
-    private readonly items;
+    private readonly http;
+    private readonly auth;
+    private readonly adminApi;
+    private readonly toast;
+    private readonly text;
+    private readonly setup;
+    private readonly preferences;
+    private readonly injector;
     private readonly seenKey;
-    /** Slides em exibição (os devidos, ou todos os vigentes quando reaberto pelo menu). */
-    readonly slides: _angular_core.WritableSignal<readonly SpineNewsSlide[]>;
+    private readonly announcedKey;
+    private readonly favoritesKey;
+    /** Há onde buscar (argos-admin configurado). */
+    readonly available: boolean;
     readonly isOpen: _angular_core.WritableSignal<boolean>;
-    /** Há alguma novidade vigente — o item "Novidades" do menu só aparece com isto. */
+    /** Novidade a abrir junto com o painel (o Início pede uma específica); o painel consome e limpa. */
+    readonly requested: _angular_core.WritableSignal<string | null>;
+    /** As mais recentes (primeira página), lidas em `refresh`. */
+    readonly latest: _angular_core.WritableSignal<readonly SpineNewsSummary[]>;
+    /** Há alguma novidade para a pessoa — o item "Novidades" do menu só aparece com isto. */
     readonly hasAny: _angular_core.Signal<boolean>;
+    /** As mais recentes para o card do Início; `unseen` = ainda não aberta neste navegador. */
+    readonly highlights: _angular_core.Signal<{
+        id: string;
+        title: string;
+        text: string;
+        unseen: boolean;
+    }[]>;
+    /** Quantas das mais recentes ainda não foram abertas (a contagem do menu do perfil). */
+    readonly unseenCount: _angular_core.Signal<number>;
+    /** Muda quando o "já visto" é gravado, para quem lê `isUnseen`/`highlights` reler. */
+    readonly seenVersion: _angular_core.WritableSignal<number>;
+    /** Muda quando os favoritos mudam, para quem lê `isFavorite` reler. */
+    readonly favoritesVersion: _angular_core.WritableSignal<number>;
+    private announced;
     constructor();
+    /** Relê as mais recentes; qualquer falha deixa a lista vazia (o item some em vez de mostrar um erro sem contexto). */
+    refresh(): Promise<void>;
+    /** Uma página da lista (`page` a partir de 1). Falha propaga: o painel mostra o erro com "Tentar de novo". */
+    page(page: number, limit: number): Promise<SpineNewsPage>;
+    /** Uma novidade com o corpo. */
+    detail(id: string): Promise<SpineNewsDetail>;
     /**
-     * Chamado uma vez pelo layout na entrada: abre as devidas quando o tour estiver `idle` (não devido,
-     * concluído, pulado ou sem passo), mais `AFTER_TOUR_MS` para não emendar. Se o tour começar nesse
-     * intervalo, volta a esperar — por isso a ordem com `OnboardingService.maybeStart()` não importa,
-     * desde que ele seja chamado dentro desse intervalo (o layout chama os dois juntos, tour primeiro).
-     */
-    scheduleOnEntry(): void;
-    /** Marca como vistas todas as novidades devidas e as abre num único painel. */
-    showDue(): void;
-    /**
-     * Reabre todas as vigentes (menu do perfil), vistas ou não; as devidas entre elas passam a vistas.
-     * Interrompe o tour se ele estiver pendente ou na tela (ação mais recente da pessoa).
+     * Chamado uma vez pelo layout na entrada: lê as mais recentes, espera a configuração inicial se decidir (e terminar,
+     * se abriu) e avisa no canto as ainda não anunciadas. Nunca abre o painel sozinho.
      */
+    announceOnEntry(): Promise<void>;
+    /** Abre o painel lateral com a lista; as mais recentes deixam de ser anunciadas (o selo "Nova" fica até abrir). */
     showAll(): void;
+    /** Abre o painel já com uma novidade aberta (o card do Início). */
+    showItem(id: string): void;
     close(): void;
-    private open;
-    /** Vigentes: sem `until`, ou com `until` ainda não passado (comparação por data, AAAA-MM-DD). */
-    private current;
-    private due;
-    private readSeen;
-    private markSeen;
+    /** Ainda não aberta neste navegador. Lê `seenVersion` (reage a `markSeen`). */
+    isUnseen(id: string): boolean;
+    /** Abriu a novidade: vista (e anunciada) neste navegador. */
+    markSeen(id: string): void;
+    /** "Marcar como não lida": volta o selo "Nova" (e conta de novo no menu e no Início); não volta a ser anunciada. */
+    markUnseen(id: string): void;
+    /** Favorita neste navegador. Lê `favoritesVersion` (reage a `toggleFavorite`). */
+    isFavorite(id: string): boolean;
+    /** Liga ou desliga o favorito (marcador do painel). */
+    toggleFavorite(id: string): void;
+    private announce;
+    /** Mais recentes ainda não vistas nem anunciadas. */
+    private pending;
+    private read;
+    private remove;
+    private write;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<SpineNewsService, never>;
     static ɵprov: _angular_core.ɵɵInjectableDeclaration<SpineNewsService>;
 }
 
-/** Grupo do painel de atalhos. Id estável; o nome exibido vem do catálogo da lib (`shortcuts.groups`). */
-type ShortcutGroupId = 'navigation' | 'actions' | 'general';
-/** Item exibido no painel de atalhos (cheatsheet, aberto com "?"). */
-interface ShortcutItem {
-    /** Teclas já em texto, na plataforma atual (`'Ctrl + K'`, `'⌘K'`, `'G depois H'`). */
-    keys: string;
-    description: string;
-    group: ShortcutGroupId;
-}
-/** Atalhos agrupados, já com o nome do grupo no idioma ativo. */
-interface ShortcutGroup {
-    id: ShortcutGroupId;
-    name: string;
-    items: ShortcutItem[];
-}
 /** Ações concretas que o atalho dispara — ligadas pelo LayoutComponent. */
 interface ShortcutActions {
     navigate?: (url: string) => void;
@@ -183,7 +212,6 @@ declare class ShortcutService implements OnDestroy {
     private removers;
     private readonly userStorage;
     private readonly hermes;
-    private readonly lib;
     private readonly text;
     /** Emite quando o usuário pede o painel de atalhos (tecla "?" ou menu do perfil). */
     readonly help$: Subject<void>;
@@ -199,17 +227,6 @@ declare class ShortcutService implements OnDestroy {
      * Acompanha registro/remoção e a troca de idioma do catálogo da lib.
      */
     readonly panelItems: _angular_core.Signal<readonly HermesShortcutItem[]>;
-    /**
-     * Lista do painel em texto, no idioma e na plataforma atuais.
-     * @deprecated Use o `hm-shortcut-list` com `panelItems()` (ou `HermesShortcutService.list()`).
-     * Mantido para quem montava o próprio painel; sai numa próxima versão.
-     */
-    get shortcuts(): ShortcutItem[];
-    /**
-     * Atalhos por grupo, na ordem navegação → ações → geral, com o nome do grupo traduzido.
-     * @deprecated Use o `hm-shortcut-list` (agrupa, traduz e desenha as teclas). Sai numa próxima versão.
-     */
-    groups(): ShortcutGroup[];
     /** Liga as ações e registra os atalhos no `HermesShortcutService` (idempotente: chamadas seguintes só trocam as ações). */
     setActions(actions: ShortcutActions): void;
     ngOnDestroy(): void;
@@ -218,8 +235,6 @@ declare class ShortcutService implements OnDestroy {
     private navigate;
     /** Navega para o N-ésimo favorito (1-based) lido da store da navegação; N = o dígito do evento. */
     private goToFavorite;
-    /** Texto corrido das teclas para a API antiga (`shortcuts`): "Ctrl + K", "G depois H", "… ou …". */
-    private keysText;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<ShortcutService, never>;
     static ɵprov: _angular_core.ɵɵInjectableDeclaration<ShortcutService>;
 }
@@ -245,6 +260,12 @@ declare class SpineWorkspaceNavService {
     readonly focusedChain: _angular_core.Signal<Route[] | null>;
     private lastKnownPath;
     constructor();
+    /**
+     * 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.
+     */
+    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
@@ -284,7 +305,6 @@ declare class LayoutComponent implements OnInit {
     private router;
     private theme;
     private shortcuts;
-    private onboarding;
     private news;
     /** Aplica no boot o idioma e o fuso que a pessoa escolheu nas configurações. */
     private readonly preferences;
@@ -296,6 +316,7 @@ declare class LayoutComponent implements OnInit {
     private readonly idle;
     private readonly startPage;
     private readonly accountPreferences;
+    protected readonly setup: SpineInitialSetupService;
     /** 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
@@ -303,7 +324,7 @@ declare class LayoutComponent implements OnInit {
      *  o bastante (sem-permissão normalmente bloqueia o app inteiro, não uma aba) pra não justificar
      *  mais complexidade agora. */
     isNoPermission: boolean;
-    constructor(router: Router, theme: ThemeService, shortcuts: ShortcutService, onboarding: OnboardingService, news: SpineNewsService);
+    constructor(router: Router, theme: ThemeService, shortcuts: ShortcutService, news: SpineNewsService);
     private matchesNoPermission;
     ngOnInit(): void;
     protected onLocalNavigate(panelId: string, href: string): void;
@@ -326,7 +347,6 @@ declare class HeaderComponent implements OnInit {
     protected densityService: DensityService;
     private viewService;
     private router;
-    private onboarding;
     private shortcuts;
     isFullscreen: boolean;
     element: HTMLElement;
@@ -336,7 +356,10 @@ declare class HeaderComponent implements OnInit {
     homeRoute: string | null;
     /** Nome do app (SpineConfig.appName; padrão "Hermes") — quem desenha é o `spine-brand`. */
     protected readonly appName: string;
-    private readonly injector;
+    /** OnPush: view, crachá, perfil e histórico mudam fora dos eventos do template (observáveis do Orfeu,
+     *  outra aba, promessa da tela cheia) — cada um marca a view. Tema/densidade/família são signals. */
+    private readonly cdr;
+    private readonly destroyRef;
     protected readonly text: {
         home: string;
         apps: string;
@@ -351,23 +374,31 @@ declare class HeaderComponent implements OnInit {
         settings: string;
         appearance: string;
         shortcuts: string;
-        tour: string;
         news: string;
+        newsUnseen: string;
         logout: string;
         search: string;
         searchPlaceholder: string;
-        recentSearches: string;
-        clearRecent: string;
-        noResults: string;
+        searchFavorites: string;
+        searchRecent: string;
+        searchModules: string;
+        searchScreens: string;
     };
-    protected readonly fmt: typeof formatMessage;
     private readonly settings;
     private readonly news;
+    /** "Avaliar o {app}": a estrela do cabeçalho (`spine-rate-app-button`) e a janela de avaliação (`spine-rating-window`). */
+    private readonly ratings;
+    /**
+     * O botão de tela cheia só aparece sem avaliação: com ela, a estrela de avaliar ocupa o lugar dele (o atalho de
+     * teclado da tela cheia continua) e o cabeçalho não fica com buraco quando `SpineFeatures.ratings` é `false`.
+     */
+    readonly showFullscreenButton: boolean;
+    private readonly setup;
     private readonly userStorage;
     private readonly logoutService;
     /** Por usuário (`SpineUserStorage`): `<clientId>_header_recent_searches_<sub>`; apagada no logout. */
     private get recentSearchKey();
-    constructor(authService: AuthorizationService, themeService: ThemeService, themePresetService: ThemePresetService, densityService: DensityService, viewService: ViewService, router: Router, onboarding: OnboardingService, shortcuts: ShortcutService, config: SpineConfig | null);
+    constructor(authService: AuthorizationService, themeService: ThemeService, themePresetService: ThemePresetService, densityService: DensityService, viewService: ViewService, router: Router, shortcuts: ShortcutService, config: SpineConfig | null);
     ngOnInit(): Promise<void>;
     updateView(data: any): void;
     /** Primeira rota navegável (DFS), atravessando grupos "transparentes" sem route_redirect. */
@@ -382,40 +413,38 @@ declare class HeaderComponent implements OnInit {
     switchBadge(badgeTypeId: string): Promise<void>;
     /** Sai pelo `SpineLogoutService`: com falha no Argos a pessoa fica aqui, com aviso, e o histórico fica. */
     logout(): Promise<boolean>;
-    /** Reabre o tour guiado de onboarding. */
-    startTour(): void;
+    /** Os cartões do essencial (busca, abas, favoritos, configurações). */
+    openEssentials(): void;
     /** Abre o painel de atalhos de teclado. */
     openShortcuts(): void;
     /** Menu do perfil: achatado (badges, se houver mais de um, + ações), já que `hm-menu`
      *  não tem submenu aninhado como o `hermes-dropdown` antigo tinha para a troca de crachá. */
     get profileMenuItems(): MenuItem[];
     onProfileMenuChosen(id: string): void;
-    quickBox?: ElementRef<HTMLElement>;
-    quickQuery: string;
+    private readonly quickAccess;
     quickOpen: boolean;
-    quickResults: QuickItem[];
-    quickActive: number;
     private quickIndex;
-    /** Histórico de buscas (mostrado ao focar com o campo vazio). */
+    /** Telas abertas pela busca (Configurações › Dados do navegador conta e apaga esta lista). */
     recentSearches: QuickItem[];
-    /** Verdadeiro quando o painel está exibindo o histórico (campo vazio). */
-    showingRecent: boolean;
+    /** Montados ao abrir: favoritos, abertos há pouco e módulos (o que aparece com o campo vazio) e as telas. */
+    searchCommands: readonly HermesCommand[];
+    protected readonly searchBrowse: string[];
+    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
-     *  internamente por ele) — abre o modal de busca, mesmo padrão do `docs/website`
-     *  (`openSearch()` em `app.component.ts`: `@if` monta o `hm-modal` só quando aberto). */
+    /** Chamado pelo `(searchRequested)` do `hm-header` (clique no campo ou `Ctrl K`, já tratado por ele): abre a paleta. */
     onSearchRequested(): void;
-    /** `(openChange)` do `hm-modal` — fecha ao clicar fora/Esc/botão de fechar. */
-    onQuickModalOpenChange(open: boolean): void;
-    onQuickSearch(): void;
-    quickGo(item: QuickItem): void;
-    quickMove(delta: number): void;
+    /**
+     * Comandos da paleta. Cada tela aparece uma vez: favoritos primeiro, depois os abertos há pouco que não são
+     * favoritos, os módulos (topo do menu) e, só na busca, o resto das telas. Favoritos e recentes valem só se a
+     * view atual (o crachá) ainda alcança a tela.
+     */
+    private buildSearchCommands;
+    private goTo;
     private readJson;
     private loadRecent;
     private pushRecent;
-    clearRecent(event?: Event): void;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<HeaderComponent, [null, null, null, null, null, null, null, null, { optional: true; }]>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<HeaderComponent, [null, null, null, null, null, null, null, { optional: true; }]>;
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<HeaderComponent, "spine-header", never, {}, {}, never, never, true, never>;
 }
 
@@ -441,14 +470,15 @@ declare class AppLauncherComponent implements OnInit {
         settings: string;
         appearance: string;
         shortcuts: string;
-        tour: string;
         news: string;
+        newsUnseen: string;
         logout: string;
         search: string;
         searchPlaceholder: string;
-        recentSearches: string;
-        clearRecent: string;
-        noResults: string;
+        searchFavorites: string;
+        searchRecent: string;
+        searchModules: string;
+        searchScreens: string;
     };
     private readonly cdr;
     apps: AppDef[];
@@ -634,107 +664,268 @@ declare class SpineLogoutService {
     static ɵprov: _angular_core.ɵɵInjectableDeclaration<SpineLogoutService>;
 }
 
-interface Box {
-    top: number;
-    left: number;
-    width: number;
-    height: number;
+/** Um cartão do essencial: o texto tem `{key}` onde entra a tecla (desenhada como `<kbd>`). */
+interface EssentialCard {
+    readonly id: string;
+    readonly icon: string;
+    readonly title: string;
+    readonly before: string;
+    readonly after: string;
+    readonly keys: ShortcutDisplay | null;
 }
 /**
- * Desenho do tour guiado: escurece a tela, recorta um holofote sobre o alvo do passo e põe o balão
- * (título, texto, progresso e navegação) onde couber. Segue o `OnboardingService`; recalcula a cada
- * passo e quando a janela rola ou muda de tamanho.
+ * Tela cheia da configuração inicial (ver `SpineInitialSetupService`): sem cabeçalho nem menu, por cima do shell
+ * (que fica `inert` enquanto ela está aberta). Cada escolha vale na hora — chama os mesmos serviços do painel de
+ * configurações —, e a prévia ao lado é desenhada com os tokens do tema, então acompanha tudo.
  */
-declare class OnboardingOverlayComponent implements OnInit, OnDestroy {
-    private onboarding;
-    protected readonly text: {
-        progress: string;
+declare class SpineInitialSetupComponent {
+    protected readonly setup: SpineInitialSetupService;
+    private readonly messages;
+    protected readonly t: {
+        label: string;
+        step: string;
         skip: string;
         back: string;
         next: string;
         finish: string;
-        welcomeTitle: string;
-        welcomeText: string;
-        appsTitle: string;
-        appsText: string;
+        close: string;
+        greeting: string;
+        greetingAnonymous: string;
+        appearanceIntro: string;
+        preview: string;
+        previewPage: string;
+        essentialsTitle: string;
+        essentialsIntro: string;
         searchTitle: string;
         searchText: string;
-        navModulesTitle: string;
-        navModulesText: string;
-        navModeTitle: string;
-        navModeText: string;
         tabsTitle: string;
         tabsText: string;
-        splitTitle: string;
-        splitText: string;
-        whereTitle: string;
-        whereText: string;
-        themeTitle: string;
-        themeText: string;
-        densityTitle: string;
-        densityText: string;
-        fullscreenTitle: string;
-        fullscreenText: string;
-        profileTitle: string;
-        profileText: string;
-        doneTitle: string;
-        doneText: string;
+        favoritesTitle: string;
+        favoritesText: string;
+        settingsTitle: string;
+        settingsText: string;
     };
-    protected readonly fmt: typeof formatMessage;
-    cardRef?: ElementRef<HTMLDivElement>;
-    step: OnboardingStep | null;
-    index: number;
-    total: number;
-    /** holofote (null = passo centralizado, sem recorte). */
-    spot: Box | null;
-    /** posição do balão. */
-    card: {
-        top: number;
-        left: number;
-        centered: boolean;
+    protected readonly s: {
+        heading: string;
+        appearance: string;
+        appearanceKeywords: string;
+        theme: string;
+        themeDescription: string;
+        themeKeywords: string;
+        themeLight: string;
+        themeDark: string;
+        themeSystem: string;
+        accent: string;
+        accentDescription: string;
+        accentKeywords: string;
+        density: string;
+        densityDescription: string;
+        densityKeywords: string;
+        comfortable: string;
+        compact: string;
+        font: string;
+        fontDescription: string;
+        fontKeywords: string;
+        sidebar: string;
+        sidebarDescription: string;
+        sidebarKeywords: string;
+        sidebarHelp: string;
+        sidebarAuto: string;
+        sidebarFixed: string;
+        sidebarCompact: string;
+        region: string;
+        regionKeywords: string;
+        language: string;
+        languageDescription: string;
+        languageKeywords: string;
+        languageAuto: string;
+        timeZone: string;
+        timeZoneKeywords: string;
+        timeZoneHint: string;
+        timeZoneAuto: string;
+        hourCycle: string;
+        hourCycleHint: string;
+        hourCycleKeywords: string;
+        hourCycleAuto: string;
+        hourCycle24: string;
+        hourCycle12: string;
+        weekStart: string;
+        weekStartDescription: string;
+        weekStartKeywords: string;
+        weekStartAuto: string;
+        shortcuts: string;
+        shortcutsDescription: string;
+        shortcutsKeywords: string;
+        setup: string;
+        setupDescription: string;
+        setupKeywords: string;
+        redoSetup: string;
+        essentials: string;
+        essentialsDescription: string;
+        essentialsKeywords: string;
+        showEssentials: string;
+        accessibility: string;
+        accessibilityKeywords: string;
+        textSize: string;
+        textSizeDescription: string;
+        textSizeKeywords: string;
+        motion: string;
+        motionDescription: string;
+        motionKeywords: string;
+        motionSystem: string;
+        motionReduce: string;
+        motionFull: string;
+        help: string;
+        helpKeywords: string;
+        news: string;
+        newsDescription: string;
+        newsKeywords: string;
+        showNews: string;
+        browserData: string;
+        browserDataDescription: string;
+        browserDataKeywords: string;
+        recentPages: string;
+        recentPagesKeywords: string;
+        recentSearches: string;
+        recentSearchesKeywords: string;
+        favorites: string;
+        favoritesKeywords: string;
+        pagesCount: _trismegisto_primitives.PluralMessage;
+        searchesCount: _trismegisto_primitives.PluralMessage;
+        clear: string;
+        confirmClear: string;
+        cancel: string;
+        recentPagesCleared: string;
+        recentSearchesCleared: string;
+        favoritesCleared: string;
+        restorePreferences: string;
+        restorePreferencesDescription: string;
+        restorePreferencesHelp: string;
+        restorePreferencesKeywords: string;
+        restore: string;
+        confirmRestore: string;
+        preferencesRestored: string;
+        account: string;
+        accountKeywords: string;
+        user: string;
+        accessLevel: string;
+        accessLevelKeywords: string;
+        session: string;
+        sessionDescription: string;
+        sessionKeywords: string;
+        sessionUnknown: string;
+        sessionExpired: string;
+        sessionExpiresIn: string;
+        sessionExpiresAt: string;
+        accessToken: string;
+        accessTokenDescription: string;
+        accessTokenKeywords: string;
+        copy: string;
+        moreAbout: string;
+        appTokens: string;
+        appTokensDescription: string;
+        appTokensKeywords: string;
+        appTokensHelp: string;
+        groups: string;
+        groupsDescription: string;
+        groupsKeywords: string;
+        groupRole: string;
+        groupRoleDisabled: string;
+        logout: string;
+        logoutDescription: string;
+        logoutKeywords: string;
+        mfa: string;
+        mfaDescription: string;
+        mfaKeywords: string;
+        signedInAccount: string;
+        signedInRealm: string;
+        twoFactor: string;
+        twoFactorDescription: string;
+        twoFactorKeywords: string;
+        recoveryCodes: string;
+        recoveryCodesDescription: string;
+        recoveryCodesKeywords: string;
+        sessions: string;
+        sessionsDescription: string;
+        sessionsKeywords: string;
+        sessionsSection: string;
+        sessionsSectionDescription: string;
+        sessionsSectionKeywords: string;
+        about: string;
+        aboutKeywords: string;
+        application: string;
+        version: string;
+        versionKeywords: string;
+        buildDate: string;
+        environment: string;
+        environmentKeywords: string;
+        links: string;
+        linksKeywords: string;
+        docs: string;
+        reportIssue: string;
+        repository: string;
+        dependencies: string;
+        dependenciesDescription: string;
+        dependenciesKeywords: string;
+        supportInfo: string;
+        supportInfoDescription: string;
+        supportInfoKeywords: string;
+        noSessionToken: string;
+        tokenCopied: string;
+        supportCopied: string;
+        copyBlocked: string;
     };
-    private sub?;
-    private reposition?;
-    private readonly cdr;
-    private readonly injector;
-    constructor(onboarding: OnboardingService);
-    get isFirst(): boolean;
-    get isLast(): boolean;
-    ngOnInit(): void;
-    ngOnDestroy(): void;
-    /** Holofote e balão do passo atual: primeiro com a altura estimada, depois com a medida real. */
-    private layout;
-    /**
-     * Refina a posição depois que o balão foi desenhado (a altura depende do texto). Roda depois do
-     * render e só marca a view se a posição mudou: sem NG0100 e sem precisar do zone.js.
-     */
-    private positionCard;
-    /** Alvo fora da faixa visível: rola até o meio antes de medir (o `scroll` da janela refaz a conta). */
-    private bringIntoView;
-    /** Largura que o CSS dá ao balão (medida quando já existe) e a altura informada. */
-    private cardSize;
-    private viewport;
-    private samePosition;
-    onViewportChange(): void;
-    next(): void;
-    prev(): void;
-    skip(): void;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<OnboardingOverlayComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<OnboardingOverlayComponent, "spine-onboarding-overlay", never, {}, {}, never, never, true, never>;
+    protected readonly fmt: typeof formatMessage;
+    private readonly theme;
+    private readonly hermesTheme;
+    private readonly themeConfig;
+    private readonly presets;
+    private readonly density;
+    private readonly i18n;
+    protected readonly preferences: SpinePreferencesService;
+    protected readonly appName: string;
+    private readonly heading;
+    /** Primeiro nome do perfil, para a saudação. */
+    protected readonly greeting: string;
+    protected readonly stepNumber: _angular_core.Signal<1 | 2>;
+    protected readonly stepTotal: _angular_core.Signal<1 | 2>;
+    protected readonly families: readonly _trismegisto_tokens.HermesFamily[];
+    protected readonly themeMode: _angular_core.Signal<HermesThemeMode>;
+    protected readonly appliedTheme: _angular_core.Signal<_trismegisto_tokens.HermesThemeName>;
+    protected readonly family: _angular_core.Signal<string>;
+    protected readonly densityValue: _angular_core.Signal<HermesDensity>;
+    protected readonly fontValue: _angular_core.Signal<_trismegisto_primitives.HermesBuiltinFont>;
+    protected readonly textSizeValue: _angular_core.Signal<string>;
+    protected readonly themeOptions: readonly SegmentedOption[];
+    protected readonly densityOptions: readonly SegmentedOption[];
+    protected readonly fontOptions: readonly SegmentedOption[];
+    protected readonly motionOptions: readonly SegmentedOption[];
+    protected readonly textSizeOptions: _angular_core.Signal<readonly SegmentedOption<string>[]>;
+    private readonly platform;
+    protected readonly essentials: readonly EssentialCard[];
+    constructor();
+    protected setThemeMode(mode: string): void;
+    protected setFamily(id: string): void;
+    protected setDensity(value: string): void;
+    protected setFont(value: string): void;
+    protected setTextSize(value: string): void;
+    protected setMotion(value: string): void;
+    private card;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SpineInitialSetupComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SpineInitialSetupComponent, "spine-initial-setup", never, {}, {}, never, never, true, never>;
 }
 
 /**
  * Painel de atalhos (cheatsheet). Abre com "?" (via `ShortcutService.help$`) e lista, com o
  * `hm-shortcut-list` da lib, os atalhos agrupados — com busca e o interruptor dos atalhos de tecla
- * única (WCAG 2.1.4; a escolha persiste no `SpinePreferencesService`). Também é o último passo do
- * onboarding.
+ * única (WCAG 2.1.4; a escolha persiste no `SpinePreferencesService`). Leva também ao essencial.
  */
 declare class ShortcutsCheatsheetComponent implements OnInit, OnDestroy {
     open: boolean;
     protected readonly text: {
         heading: string;
         hint: string;
-        replayTour: string;
+        essentials: string;
         dismiss: string;
         openSearch: string;
         goHome: string;
@@ -748,20 +939,18 @@ declare class ShortcutsCheatsheetComponent implements OnInit, OnDestroy {
         closeOverlay: string;
     };
     private readonly shortcuts;
-    private readonly onboarding;
+    private readonly setup;
+    /** OnPush: o "?" e o menu do perfil abrem o painel por `help$`, fora dos eventos deste template. */
+    private readonly cdr;
     /** Atalhos do painel: registrados (favoritos numa linha só) + os que outra peça dispara. */
     protected readonly items: _angular_core.Signal<readonly _trismegisto_angular.HermesShortcutItem[]>;
     /** Atalhos de tecla única ligados — sem eles o "?" da dica não funciona. */
     protected readonly characterKeys: _angular_core.Signal<boolean>;
     /** Dica com a tecla no meio: o texto do catálogo partido em volta de `{key}`. */
     protected get hintParts(): string[];
-    /** @deprecated O painel agora é o `hm-shortcut-list`; use `ShortcutService.panelItems()`. Sai numa próxima versão. */
-    get groups(): ShortcutGroup[];
-    /** @deprecated As teclas são desenhadas pelo `hm-shortcut-list`. Sai numa próxima versão. */
-    chips(keys: string): string[];
     private sub?;
-    /** Reabre o tour de onboarding e fecha este painel. */
-    replayTour(): void;
+    /** Abre os cartões do essencial e fecha este painel. */
+    openEssentials(): void;
     ngOnInit(): void;
     ngOnDestroy(): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<ShortcutsCheatsheetComponent, never>;
@@ -775,7 +964,7 @@ declare const SPINE_SETTINGS_KEYS: {
     readonly accessibility: "acessibilidade";
     readonly region: "regiao";
     readonly shortcuts: "atalhos";
-    /** Novidades e tour guiado. */
+    /** Novidades, configuração inicial e o essencial. */
     readonly help: "ajuda";
     /** Tipos de aviso do app e aviso do navegador (`SpineFeatures.notices`). */
     readonly notices: "notificacoes";
@@ -788,9 +977,6 @@ declare const SPINE_SETTINGS_KEYS: {
     readonly sessions: "sessoes";
     /** Grupos desta aplicação em que a pessoa tem função (argos-admin `/me/groups`); só aparece com algum. */
     readonly groups: "grupos";
-    /** @deprecated A seção "Conta e segurança" virou "MFA" e "Sessões": `seguranca` abre a de MFA (ver
-     *  `SPINE_SETTINGS_ALIASES`). Use `mfa` ou `sessions`. */
-    readonly security: "seguranca";
     readonly about: "sobre";
 };
 /** Chaves antigas de `?settings=` que continuam abrindo a seção que as substituiu (links já publicados). */
@@ -850,6 +1036,17 @@ interface SpineAccountPreferencesDoc {
     browserNotices?: 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.
+ */
+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. */
+type SpineGlobalPreferencesDoc = Pick<SpineAccountPreferencesDoc, 'v' | (typeof SPINE_GLOBAL_PREFERENCE_KEYS)[number]> & {
+    /** A configuração inicial já foi feita (ou pulada): não aparece de novo em nenhum app. */
+    setupDone?: boolean;
+};
 /** `local`: só no navegador (recurso desligado, sem API da conta, ou Argos sem o endpoint). */
 type SpineAccountPreferencesStatus = 'idle' | 'local' | 'loading' | 'saving' | 'synced' | 'error';
 /**
@@ -865,6 +1062,12 @@ type SpineAccountPreferencesStatus = 'idle' | 'local' | 'loading' | 'saving' | '
  * - Depois, cada mudança é gravada na conta, agrupada (`SPINE_PREFERENCES_SAVE_DELAY_MS`).
  * - Sem a API da conta, com o recurso desligado ou com um Argos que não tem o endpoint (404/400), fica só no
  *   navegador (`status() === 'local'`), sem erro na tela.
+ * - Com o documento global (`{api}/preferences/global`), a aparência e a região (`SPINE_GLOBAL_PREFERENCE_KEYS`)
+ *   vão nele e valem em todos os apps; o do app fica com o resto. Na leitura, o do app é aplicado primeiro (o que
+ *   ele ainda tiver de antes do global) e o global por cima. Argos sem a rota global: tudo no do app, como antes.
+ *
+ * Também guarda se a configuração inicial já foi feita (`setupDone`): no documento global quando há, senão no
+ * navegador. Quem já tinha aparência guardada (na conta ou no navegador) conta como feita.
  */
 declare class SpineAccountPreferencesService {
     private readonly browser;
@@ -882,10 +1085,15 @@ declare class SpineAccountPreferencesService {
     readonly status: _angular_core.WritableSignal<SpineAccountPreferencesStatus>;
     /** Hora da última leitura/gravação bem-sucedida. */
     readonly syncedAt: _angular_core.WritableSignal<Date | null>;
+    /** Configuração inicial feita (ou pulada). `null` enquanto a conta não respondeu. */
+    readonly setupDone: _angular_core.WritableSignal<boolean | null>;
     /** O documento que o navegador tem agora. */
     readonly snapshot: _angular_core.Signal<SpineAccountPreferencesDoc>;
     private loaded;
+    /** O Argos tem o documento global (lido com sucesso nesta sessão). */
+    private globalOn;
     private lastSaved;
+    private lastSavedGlobal;
     private timer;
     private readyPromise;
     constructor();
@@ -897,12 +1105,22 @@ declare class SpineAccountPreferencesService {
     ready(timeoutMs?: number): Promise<void>;
     /** Grava agora o que estiver pendente ("Sincronizar agora"); relê a conta se ela ainda não respondeu. */
     syncNow(): Promise<void>;
+    /** Marca a configuração inicial como feita (concluída ou pulada): vai para a conta com o resto, ou fica aqui. */
+    completeSetup(): void;
     private load;
+    /** O documento global, ou `null` quando o Argos não tem a rota (versão anterior): aí tudo fica no do app. */
+    private loadGlobal;
+    /** O que vai em cada documento agora. Sem o global, tudo no do app. */
+    private split;
     /** Aplica o documento da conta pelos mesmos caminhos das telas (cada `set*` também grava no navegador). */
     private apply;
     private schedule;
+    /** Grava o que mudou desde a última gravação (`force`: os dois documentos, mudados ou não). */
     private save;
     private failed;
+    /** Configuração inicial feita neste navegador, ou aparência já escolhida aqui antes de ela existir. */
+    private localSetupDone;
+    private writeLocalSetupDone;
     private clearTimer;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<SpineAccountPreferencesService, never>;
     static ɵprov: _angular_core.ɵɵInjectableDeclaration<SpineAccountPreferencesService>;
@@ -977,7 +1195,7 @@ type BrowserList = 'recents' | 'searches' | 'favorites';
  * sessão, sair), MFA (verificação em duas etapas e códigos de recuperação do Argos), Sessões (token de
  * acesso, tokens de aplicação e sessões e dispositivos do Argos), Aparência, Acessibilidade (tamanho do texto,
  * animações), Região (idioma, fuso, formato de hora, primeiro dia da semana), Atalhos, Dados do navegador
- * (limpar listas, restaurar preferências), Ajuda (novidades, tour) e Sobre, mais as seções que o app registrar
+ * (limpar listas, restaurar preferências), Ajuda (novidades, configuração inicial, o essencial) e Sobre, mais as seções que o app registrar
  * com `provideSettingsSection`. Tudo vale na hora — cada controle chama o serviço que já persiste aquela
  * preferência (tema, densidade, menu lateral, fuso, tamanho do texto…).
  *
@@ -1037,10 +1255,14 @@ declare class SettingsPanelComponent {
         shortcuts: string;
         shortcutsDescription: string;
         shortcutsKeywords: string;
-        tour: string;
-        tourDescription: string;
-        tourKeywords: string;
-        replayTour: string;
+        setup: string;
+        setupDescription: string;
+        setupKeywords: string;
+        redoSetup: string;
+        essentials: string;
+        essentialsDescription: string;
+        essentialsKeywords: string;
+        showEssentials: string;
         accessibility: string;
         accessibilityKeywords: string;
         textSize: string;
@@ -1165,7 +1387,6 @@ declare class SettingsPanelComponent {
         readonly mfa: "mfa";
         readonly sessions: "sessoes";
         readonly groups: "grupos";
-        readonly security: "seguranca";
         readonly about: "sobre";
     };
     /** Seção aberta, com a chave antiga já trocada pela nova (`seguranca` → `mfa`). */
@@ -1183,7 +1404,7 @@ declare class SettingsPanelComponent {
     protected readonly sidebar: HermesSidebarService;
     protected readonly preferences: SpinePreferencesService;
     private readonly shortcutService;
-    private readonly onboarding;
+    private readonly setup;
     private readonly auth;
     private readonly authConfig;
     private readonly toast;
@@ -1270,6 +1491,125 @@ declare class SettingsPanelComponent {
         syncError: string;
         syncNow: string;
     };
+    /** Sobre › Avaliação: a média da ferramenta e "Avaliar" (`SpineFeatures.ratings` com `SPINE_ADMIN_API`). */
+    protected readonly ratingsEnabled: boolean;
+    protected readonly ratingText: {
+        rateScreen: string;
+        rateApp: string;
+        ratedApp: string;
+        heading: string;
+        subheading: string;
+        aboutScreen: string;
+        aboutApp: string;
+        score: string;
+        scoreOf: string;
+        scoreNamed: string;
+        scoreShort: string;
+        scoreNames: Record<1 | 2 | 3 | 4 | 5, string>;
+        noScore: string;
+        scaleHint: string;
+        comment: string;
+        commentPlaceholder: string;
+        submit: string;
+        update: string;
+        previous: string;
+        scoreRequired: string;
+        loading: string;
+        thanks: string;
+        updated: string;
+        saveError: string;
+        period: string;
+        periods: Record<"all" | "d7" | "d30" | "d90", string>;
+        refresh: string;
+        appCard: string;
+        screensCard: string;
+        appCardHint: string;
+        screensCardHint: string;
+        scoreMax: string;
+        average: string;
+        total: _trismegisto_primitives.PluralMessage;
+        comments: _trismegisto_primitives.PluralMessage;
+        noRatings: string;
+        distribution: string;
+        distributionRow: string;
+        ranking: string;
+        rankingHint: string;
+        sort: string;
+        sorts: Record<"worst" | "best" | "most", string>;
+        noScreens: string;
+        filterByScreen: string;
+        recent: string;
+        recentHint: string;
+        filterScope: string;
+        allScopes: string;
+        tool: string;
+        screens: string;
+        filterScreen: string;
+        allScreens: string;
+        filterScore: string;
+        allScores: string;
+        withComment: string;
+        clearFilters: string;
+        noComment: string;
+        itemActions: string;
+        copyComment: string;
+        commentCopied: string;
+        copyFailed: string;
+        showAppRatings: string;
+        showScreenRatings: string;
+        emptyList: string;
+        pagination: string;
+        unknownUser: string;
+        loadError: string;
+        forbidden: string;
+        updatedAt: string;
+        details: string;
+        detailsOf: string;
+        tabScreens: string;
+        tabAreas: string;
+        tabTrends: string;
+        viewAll: string;
+        allHeading: string;
+        justNow: string;
+        yesterdayAt: string;
+        dateAt: string;
+        sortsShort: Record<"worst" | "best" | "most", string>;
+        bands: Record<"all" | "bad" | "mid" | "good", string>;
+        bandFilter: string;
+        filterArea: string;
+        allAreas: string;
+        noArea: string;
+        filterByArea: string;
+        screensCount: _trismegisto_primitives.PluralMessage;
+        searchScreens: string;
+        searchScreensLabel: string;
+        searchAreas: string;
+        searchAreasLabel: string;
+        tableEmpty: string;
+        areasEmpty: string;
+        colScreen: string;
+        colArea: string;
+        colScreens: string;
+        colScore: string;
+        colTotal: string;
+        colComments: string;
+        colTrend: string;
+        colOpen: string;
+        tablePagination: string;
+        areasPagination: string;
+        trendOf: string;
+        trendNone: string;
+        trendCaption: string;
+        trendEmpty: string;
+        trendValue: string;
+        trendWeek: string;
+        aboutRating: string;
+        aboutRatingKeywords: string;
+        rateAction: string;
+        noRatingsYet: string;
+        loadingAverage: string;
+        averageError: string;
+    };
     /**
      * "Copiar token de acesso" é ferramenta de desenvolvimento: põe o token da sessão (Bearer de tudo que a
      * pessoa pode fazer) na área de transferência, ao alcance de qualquer app/extensão que leia o clipboard.
@@ -1284,7 +1624,7 @@ declare class SettingsPanelComponent {
     protected readonly appliedTheme: _angular_core.Signal<_trismegisto_tokens.HermesThemeName>;
     protected readonly family: _angular_core.Signal<string>;
     protected readonly densityValue: _angular_core.Signal<HermesDensity>;
-    protected readonly fontValue: _angular_core.Signal<HermesFont>;
+    protected readonly fontValue: _angular_core.Signal<_trismegisto_primitives.HermesBuiltinFont>;
     protected readonly families: readonly _trismegisto_tokens.HermesFamily[];
     protected setThemeMode(mode: string): void;
     protected setFamily(id: string): void;
@@ -1317,11 +1657,14 @@ declare class SettingsPanelComponent {
     protected setWeekStart(value: string): void;
     /** Atalhos registrados (favoritos numa linha só) + os que outra peça dispara — os mesmos do painel "?". */
     protected readonly shortcutItems: _angular_core.Signal<readonly _trismegisto_angular.HermesShortcutItem[]>;
-    /** "Ver novidades" só quando o app tem alguma vigente (`provideSpineNews`). */
+    /** "Ver novidades" só com alguma novidade para a pessoa (argos-admin `/me/news`). */
     protected readonly hasNews: _angular_core.Signal<boolean>;
-    /** Fecha o painel antes: novidades e tour ocupam a tela. */
+    /** "Refazer" a configuração inicial só quando o app não a desligou. */
+    protected readonly setupEnabled: boolean;
+    /** Fecha o painel antes: novidades, configuração inicial e o essencial ocupam a tela. */
     protected showNews(): void;
-    protected replayTour(): void;
+    protected redoSetup(): void;
+    protected showEssentials(): void;
     /** Relida quando o painel abre e depois de limpar (as buscas recentes não têm sinal próprio). */
     private readonly dataVersion;
     protected readonly counts: _angular_core.Signal<Readonly<Record<BrowserList, number>>>;
@@ -1377,6 +1720,8 @@ declare class SettingsPanelComponent {
     /** Grupos desta aplicação de que a pessoa é membro (relidos a cada abertura); sem nenhum, a seção some. */
     private readonly myGroupsService;
     protected readonly myGroups: _angular_core.WritableSignal<_trismegisto_spine_layout.ManagedGroup[]>;
+    /** Grupo aberto na seção Grupos (tela de membros): o cabeçalho da seção sai de vista. */
+    protected readonly groupOpen: _angular_core.WritableSignal<boolean>;
     private readonly idle;
     private readonly startPageService;
     private readonly router;
@@ -1501,6 +1846,14 @@ interface ManagedGroup {
     assignable_roles: GroupRole[];
     /** Só Administrador troca a função dos outros membros. */
     can_change_roles: boolean;
+    /** Resumo dos membros (servidor que já manda): total e os primeiros, com foto. */
+    members_count?: number;
+    members_preview?: {
+        user_id: string;
+        username: string;
+        name: string | null;
+        picture: string | null;
+    }[];
 }
 interface GroupMember {
     user_id: string;
@@ -1725,6 +2078,10 @@ declare class SpineAccountSecurityService {
     preferences(): Promise<AccountPreferences>;
     /** Substitui o documento de preferências desta aplicação na conta (até 16 KB). */
     savePreferences(preferences: Record<string, unknown>): Promise<AccountPreferences>;
+    /** Preferências da pessoa que valem em todos os apps (`GET {api}/preferences/global`). */
+    globalPreferences(): Promise<AccountPreferences>;
+    /** Substitui o documento global (até 16 KB). */
+    saveGlobalPreferences(preferences: Record<string, unknown>): Promise<AccountPreferences>;
     private send;
     private request;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<SpineAccountSecurityService, never>;
@@ -2127,30 +2484,473 @@ declare class SpineDocsService {
     static ɵprov: _angular_core.ɵɵInjectableDeclaration<SpineDocsService>;
 }
 
+/** Filtro em pílula do topo do painel. */
+type SpineNewsFilter = 'all' | 'unread' | 'favorites';
+interface MonthGroup {
+    readonly key: string;
+    readonly label: string;
+    readonly items: readonly SpineNewsSummary[];
+}
 /**
- * Painel de novidades: um diálogo com carrossel — "olha o que mudou", não tutorial (esse é o tour
- * de boas-vindas). Montado uma vez no layout; quem decide quando abre é o `SpineNewsService`.
+ * Painel lateral de novidades e o modal de leitura. Montado uma vez no layout; quem abre é o `SpineNewsService` (aviso
+ * da entrada, menu do perfil, Início, configurações).
+ *
+ * Painel: sem cards — itens de texto separados por divisor, agrupados por mês (data, selo "Nova", título, resumo em
+ * duas linhas e o autor com foto), com busca ("Buscar novidades…") e filtros em pílula (Todas, Não lidas, Favoritas,
+ * cada um com a contagem). Favoritar é o marcador à direita de cada item. O item aberto ganha a barra de destaque.
+ *
+ * Busca e filtros rodam no navegador: "não lida" e "favorita" só existem nele (por id, no localStorage), então o
+ * painel lê as mais recentes de `/me/news` em páginas de 50, em sequência, até ter todas (teto de 200) e filtra a
+ * lista carregada — as contagens das pílulas batem com o que aparece.
+ *
+ * Modal: trilha "Início › Novidades › título", título grande (com "Nova" se ainda não tinha sido aberta), a linha de
+ * meta (data, autor, tipo), o resumo como texto de abertura e o conteúdo do tipo — o texto (informativo), "O que
+ * mudou" com os checks (implementação) ou o antes e o agora lado a lado (alteração). Rodapé: "Marcar como não lida" e
+ * "Entendi".
+ *
+ * O HTML vem de rich text, saneado pelo servidor ao gravar, e é mostrado pelo próprio `hm-rich-text` em `readonly`
+ * (que passa pela lista branca dele de novo) — nunca por `[innerHTML]`. Os itens da implementação são texto puro.
  */
 declare class SpineNewsComponent {
     protected readonly news: SpineNewsService;
     protected readonly text: {
         heading: string;
-        carousel: string;
-        dismiss: string;
+        close: string;
+        unseen: string;
+        toastOne: string;
+        toastMany: string;
+        see: string;
+        loading: string;
+        empty: string;
+        loadError: string;
+        retry: string;
+        pages: string;
+        search: string;
+        searchPlaceholder: string;
+        filters: string;
+        filterAll: string;
+        filterUnread: string;
+        filterFavorites: string;
+        favorite: string;
+        unfavorite: string;
+        noResults: string;
+        home: string;
+        changes: string;
+        before: string;
+        after: string;
+        markUnread: string;
+        gotIt: string;
+        kindInformativo: string;
+        kindImplementacao: string;
+        kindAlteracao: string;
+        publishedOn: string;
+        editedOn: string;
+        body: string;
+        detailError: string;
     };
-    private readonly document;
-    /** O hm-carousel pede `image`/`alt` sempre presentes (vazios = sem imagem / decorativa). A
-     * ilustração é desenhada na hora de abrir, com as cores do tema daquele momento. */
-    protected readonly slides: _angular_core.Signal<{
-        title: string;
-        text: string;
-        image: string;
-        alt: string;
-    }[]>;
+    private readonly locale;
+    private readonly dateFormat;
+    private readonly dayFormat;
+    private readonly monthFormat;
+    protected readonly uid: string;
+    protected readonly filters: readonly SpineNewsFilter[];
+    protected readonly hasText: (html: string | undefined) => boolean;
+    /** Tudo o que foi carregado (as mais recentes, até o teto). */
+    protected readonly items: _angular_core.WritableSignal<readonly SpineNewsSummary[]>;
+    protected readonly loading: _angular_core.WritableSignal<boolean>;
+    protected readonly error: _angular_core.WritableSignal<boolean>;
+    readonly query: _angular_core.WritableSignal<string>;
+    readonly filter: _angular_core.WritableSignal<SpineNewsFilter>;
+    /** Página atual e quantas novidades cabem no painel (medido pela altura dele; refeito ao redimensionar). */
+    readonly page: _angular_core.WritableSignal<number>;
+    readonly pageSize: _angular_core.WritableSignal<number>;
+    protected readonly pageState: _angular_core.Signal<PaginationState>;
+    private readonly toolsRef;
+    private readonly listRef;
+    /** Altura de um item, medida no primeiro que aparece (estável: não muda a cada página). */
+    private rowPx;
+    /** A novidade aberta no modal (o resumo, já na mão) e o conteúdo dela quando chega. */
+    protected readonly opened: _angular_core.WritableSignal<SpineNewsSummary | null>;
+    /** Estava "Nova" quando abriu (abrir já marca como vista; o selo do modal lembra que era). */
+    protected readonly openedUnseen: _angular_core.WritableSignal<boolean>;
+    protected readonly detail: _angular_core.WritableSignal<SpineNewsDetail | null>;
+    protected readonly detailError: _angular_core.WritableSignal<boolean>;
+    /** Respostas fora de ordem (reabriu o painel, abriu outra) não sobrescrevem a atual. */
+    private loadSeq;
+    private detailSeq;
+    /** Contagem de cada pílula, sobre o que foi carregado (a busca não muda as contagens). */
+    protected readonly counts: _angular_core.Signal<Record<SpineNewsFilter, number>>;
+    /** O que passa no filtro e na busca (na ordem da lista: da mais recente). */
+    protected readonly filtered: _angular_core.Signal<readonly SpineNewsSummary[]>;
+    /** A página dentro do total (trocar o filtro ou o tamanho da página não deixa numa página que não existe). */
+    protected readonly currentPage: _angular_core.Signal<number>;
+    /** A página atual, agrupada por mês. */
+    protected readonly groups: _angular_core.Signal<readonly MonthGroup[]>;
+    /** "Nova" = ainda não aberta neste navegador (reage a `markSeen`/`markUnseen`). */
+    protected readonly unseen: (id: string) => boolean;
+    protected readonly favorite: (id: string) => boolean;
+    constructor();
+    private measure;
+    protected changePage(next: PaginationState): void;
+    protected filterLabel(f: SpineNewsFilter): string;
+    protected favoriteLabel(item: SpineNewsSummary): string;
+    protected kindOf(item: SpineNewsSummary): SpineNewsKind;
+    protected kindIcon(item: SpineNewsSummary): string;
+    protected kindLabel(item: SpineNewsSummary): string;
+    protected crumbs(item: SpineNewsSummary): BreadcrumbItem[];
+    /** "Início" da trilha leva à tela inicial: fecha o modal e o painel. */
+    protected onCrumb(crumb: BreadcrumbItem): void;
+    protected dayOf(item: SpineNewsSummary): string;
+    protected publishedOn(item: SpineNewsSummary): string;
+    protected editedOn(at: string): string;
+    /** Lê as páginas em sequência (50 por vez) até ter todas ou o teto; a lista aparece já com a primeira. */
+    load(): Promise<void>;
+    /** Abre no modal e marca como vista; o conteúdo chega em seguida. */
+    open(item: SpineNewsSummary): void;
+    /** "Marcar como não lida": volta o selo "Nova" e fecha. */
+    protected markUnread(): void;
+    protected closeItem(): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<SpineNewsComponent, never>;
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<SpineNewsComponent, "spine-news", never, {}, {}, never, never, true, never>;
 }
 
+/** O que se avalia: a ferramenta inteira (`app`) ou uma tela (`screen`). */
+type SpineRatingScope = 'app' | 'screen';
+/** Alvo de uma avaliação. Tela: `screenPath` é a chave (a rota); `screenLabel`, o caminho legível que vai junto. */
+interface SpineRatingTarget {
+    scope: SpineRatingScope;
+    screenPath?: string | null;
+    screenLabel?: string | null;
+}
+/** A avaliação da pessoa como o argos-admin devolve (`/me/ratings`). */
+interface SpineRating {
+    scope: SpineRatingScope;
+    screen_path: string | null;
+    screen_label: string | null;
+    /** 0 a 10 (10 = 5 estrelas; 7 = 3,5). */
+    score: number;
+    comment: string | null;
+    created_at: string;
+    updated_at: string;
+}
+/** Média da ferramenta que qualquer pessoa logada vê (`/me/ratings/summary`): 0 a 10 com uma casa, ou `null`. */
+interface SpineRatingAverage {
+    average: number | null;
+    total: number;
+}
+/** Chave de um alvo ("app" ou "screen:<rota>"): o que foi avaliado nesta sessão e a troca de alvo da janela. */
+declare const ratingTargetKey: (t: SpineRatingTarget) => string;
+/** Teto do comentário (o mesmo do servidor e da coluna). */
+declare const SPINE_RATING_COMMENT_MAX = 500;
+/**
+ * Avaliações da pessoa (nota de 0 a 10, 5 estrelas com meia, e um comentário) — `argos-admin /me/ratings`, sempre da
+ * aplicação LOGADA (o servidor tira o client do token da sessão) e uma por escopo/tela: avaliar de novo substitui. Liga
+ * com `SpineFeatures.ratings` e só com `SPINE_ADMIN_API`; sem os dois, `enabled` é falso e nada de avaliação aparece.
+ *
+ * `windowTarget` é o que a janela de avaliação (flutuante, montada no cabeçalho) está avaliando: `openApp` (a estrela
+ * do cabeçalho e Configurações › Sobre) e `openScreen` (a estrela da barra da página) trocam o alvo da mesma janela, e
+ * `closeWindow` fecha. `appRated` diz se a pessoa já avaliou a ferramenta (a estrela do cabeçalho fica cheia) e
+ * `appAverage` é a média da ferramenta (Configurações › Sobre); os dois são lidos uma vez, por quem os mostra.
+ */
+declare class SpineRatingsService {
+    private readonly http;
+    private readonly auth;
+    private readonly adminApi;
+    /** Ligado por padrão (como as sugestões): só `features.ratings: false` desliga; sem a API da conta ou HTTP, nada. */
+    readonly enabled: boolean;
+    /** O que a janela de avaliação está avaliando; `null` = fechada. Uma janela só, para a ferramenta e para a tela. */
+    readonly windowTarget: _angular_core.WritableSignal<SpineRatingTarget | null>;
+    /** Alvos avaliados nesta sessão do app (a estrela da barra fica cheia); não pergunta ao servidor a cada tela. */
+    private readonly ratedNow;
+    /** A pessoa já avaliou a ferramenta (servidor, lido uma vez por `checkAppRated`, ou gravado agora). */
+    readonly appRated: _angular_core.WritableSignal<boolean>;
+    /** Média da ferramenta (`loadAppAverage`); `null` enquanto não foi lida. */
+    readonly appAverage: _angular_core.WritableSignal<SpineRatingAverage | null>;
+    private appRatedChecked;
+    private get url();
+    /** "Avaliar o {app}": abre a janela (ou troca o conteúdo dela) para a ferramenta. */
+    openApp(): void;
+    /** "Avaliar esta tela": abre a janela (ou troca o conteúdo dela) para a tela. */
+    openScreen(target: SpineRatingTarget): void;
+    closeWindow(): void;
+    isRated(target: SpineRatingTarget): boolean;
+    /**
+     * Lê uma vez se a pessoa já avaliou a ferramenta (a estrela do cabeçalho). Falha de rede deixa vazia, sem aviso:
+     * avaliar continua funcionando, só a estrela não sabe da avaliação antiga.
+     */
+    checkAppRated(): Promise<void>;
+    /** Média e total da ferramenta (`GET /me/ratings/summary`); quem mostra trata a falha. */
+    loadAppAverage(): Promise<SpineRatingAverage>;
+    /** A avaliação atual da pessoa nesse alvo (para pré-preencher), ou `null` se ainda não avaliou. */
+    mine(target: SpineRatingTarget): Promise<SpineRating | null>;
+    /** Cria ou atualiza a avaliação (nota 0 a 10); comentário vazio vai como `null`. */
+    save(target: SpineRatingTarget, score: number, comment: string): Promise<SpineRating>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SpineRatingsService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<SpineRatingsService>;
+}
+
+/** Nota máxima: 10 = 5 estrelas cheias (cada estrela vale 2, meia estrela vale 1). */
+declare const SPINE_RATING_SCORE_MAX = 10;
+type SpineScoreBand = 1 | 2 | 3 | 4 | 5;
+type SpineStarFill = 'empty' | 'half' | 'full';
+/** Faixa do rótulo qualitativo de uma nota: 0–2 ruim, 3–4 regular, 5–6 bom, 7–8 muito bom, 9–10 excelente. */
+declare function spineScoreBand(score: number): SpineScoreBand;
+/** Preenchimento das 5 estrelas para a nota (uma média vai para a meia estrela mais próxima: 8,4 = 4 estrelas). */
+declare function spineStarFills(score: number | null | undefined): SpineStarFill[];
+/**
+ * Estrelas de uma nota de 0 a 10, com meia estrela: 10 = 5 estrelas, 7 = 3,5, 0 = nenhuma. Ao lado, a nota em número
+ * ("7/10"; média com uma casa, "8,4/10").
+ *
+ * - `readonly`: só mostra (média do auto-serviço, Configurações › Sobre). Para o leitor é uma imagem com o nome
+ *   "8,4 de 10".
+ * - editável (o formulário de avaliação): um `role="slider"` de 0 a 10 com o valor falado "7 de 10 — Muito bom". As
+ *   setas mudam de meia em meia estrela (1 ponto), PageUp/PageDown de estrela em estrela, Home dá 0 e End dá 10. No
+ *   mouse, a metade inicial da estrela é a meia e a final é a inteira; clicar de novo na primeira metade da primeira
+ *   estrela (nota 1) deixa em 0. Sem nota escolhida (`null`), o valor falado é "Sem nota".
+ *
+ * Meia estrela sem desenho próprio: a estrela vazia por baixo e a cheia por cima, cortada na metade do lado inicial
+ * (em RTL, o lado direito).
+ */
+declare class SpineRatingStarsComponent {
+    /** Nota de 0 a 10 (média pode ter casa decimal); `null` = sem nota. Editável: muda com o clique e o teclado. */
+    readonly value: _angular_core.ModelSignal<number | null>;
+    /** Só mostra (sem foco nem clique). */
+    readonly readonly: _angular_core.InputSignal<boolean>;
+    /** A nota em número ao lado ("7/10"). */
+    readonly showValue: _angular_core.InputSignal<boolean>;
+    /** Editável: também o rótulo qualitativo ("Muito bom") ao lado da nota. */
+    readonly showName: _angular_core.InputSignal<boolean>;
+    readonly size: _angular_core.InputSignal<"small" | "medium" | "large">;
+    /** Nome acessível do slider (ou `labelledBy`, o id de um rótulo visível). */
+    readonly label: _angular_core.InputSignal<string>;
+    readonly labelledBy: _angular_core.InputSignal<string>;
+    readonly describedBy: _angular_core.InputSignal<string>;
+    readonly invalid: _angular_core.InputSignal<boolean>;
+    private readonly messages;
+    private readonly text;
+    private readonly host;
+    private readonly numberFormat;
+    protected readonly max = 10;
+    /** Prévia do mouse (editável): vence a nota escolhida no desenho, não no valor. */
+    protected readonly hovered: _angular_core.WritableSignal<number | null>;
+    protected readonly shown: _angular_core.Signal<number | null>;
+    protected readonly fills: _angular_core.Signal<SpineStarFill[]>;
+    protected readonly short: _angular_core.Signal<string>;
+    protected readonly named: _angular_core.Signal<string>;
+    /** O que o leitor fala: "8,4 de 10" (imagem) ou "7 de 10 — Muito bom" (slider). */
+    protected readonly spoken: _angular_core.Signal<string>;
+    private format;
+    /** Clique numa metade: aquela nota; de novo na primeira metade (nota 1), 0 -- o "nenhuma estrela" do mouse. */
+    protected pick(score: number): void;
+    protected onKey(event: KeyboardEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SpineRatingStarsComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SpineRatingStarsComponent, "spine-rating-stars", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "readonly": { "alias": "readonly"; "required": false; "isSignal": true; }; "showValue": { "alias": "showValue"; "required": false; "isSignal": true; }; "showName": { "alias": "showName"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "labelledBy": { "alias": "labelledBy"; "required": false; "isSignal": true; }; "describedBy": { "alias": "describedBy"; "required": false; "isSignal": true; }; "invalid": { "alias": "invalid"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; }, never, never, true, never>;
+}
+
+/**
+ * Lugar das ações da tela na barra da página (`spine-page-bar`): um por painel do workspace, fornecido pelo
+ * `spine-page-panel`. A tela não fala com ele direto: usa `<ng-template spinePageActions>`.
+ */
+declare class SpinePageActionsSlot {
+    readonly template: _angular_core.WritableSignal<TemplateRef<unknown> | null>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SpinePageActionsSlot, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<SpinePageActionsSlot>;
+}
+/**
+ * Ações que valem para a tela inteira (período, "Atualizar", "Atualizado em…") na barra da página, à direita do título:
+ *
+ * ```html
+ * <ng-template spinePageActions>
+ *   <hm-segmented-control … />
+ *   <hm-button icon="refresh" (clicked)="reload()">Atualizar</hm-button>
+ * </ng-template>
+ * ```
+ *
+ * O conteúdo continua sendo da tela (bindings e eventos no componente dela); só aparece na barra do painel em que a tela
+ * está. Fora de um painel (tela montada sozinha, teste), aparece no próprio lugar do `ng-template`. Uma tela por painel:
+ * a última que registrar vale, e sair da tela tira as ações da barra.
+ */
+declare class SpinePageActionsDirective implements OnDestroy {
+    private readonly slot;
+    private readonly template;
+    constructor();
+    ngOnDestroy(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SpinePageActionsDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SpinePageActionsDirective, "ng-template[spinePageActions]", 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];
+/**
+ * Os status, na ordem das colunas. Toda sugestão nasce `em_analise` (o antigo "Nova" saiu; ainda aparece no histórico,
+ * pelo `legacyStatuses` do catálogo). `concluida` e `recusada` encerram: recusada sai do quadro na hora, concluída
+ * depois de alguns dias (o servidor decide; ver `done_days` do quadro), e as duas ficam no arquivo.
+ */
+declare const SPINE_SUGGESTION_STATUSES: readonly ["em_analise", "planejada", "em_desenvolvimento", "concluida", "recusada"];
+type SpineSuggestionStatus = (typeof SPINE_SUGGESTION_STATUSES)[number];
+/** Os status que aparecem em "Sugestões do app" (as de todo mundo): a recusada não entra (nem a arquivada pela equipe). */
+declare const SPINE_SUGGESTION_PUBLIC_STATUSES: readonly ["em_analise", "planejada", "em_desenvolvimento", "concluida"];
+type SpineSuggestionPublicStatus = (typeof SPINE_SUGGESTION_PUBLIC_STATUSES)[number];
+/** Ordem de "Sugestões do app": as mais apoiadas (padrão do servidor) ou as mais novas. */
+declare const SPINE_SUGGESTION_PUBLIC_SORTS: readonly ["votes", "recent"];
+type SpineSuggestionPublicSort = (typeof SPINE_SUGGESTION_PUBLIC_SORTS)[number];
+/** Cor da etiqueta de status (a mesma em "Minhas sugestões" e no kanban do auto-serviço). */
+declare const SPINE_SUGGESTION_STATUS_COLORS: Record<SpineSuggestionStatus, TagColor>;
+/** Ícone de cada status (coluna do kanban, etiqueta do arquivo). */
+declare const SPINE_SUGGESTION_STATUS_ICONS: Record<SpineSuggestionStatus, string>;
+/** Ícone e cor de cada tipo (o modal de nova sugestão e o cartão do kanban). */
+declare const SPINE_SUGGESTION_KIND_ICONS: Record<SpineSuggestionKind, string>;
+declare const SPINE_SUGGESTION_KIND_COLORS: Record<SpineSuggestionKind, TagColor>;
+/** Limites do servidor (colunas da migration): o formulário corta antes. */
+declare const SPINE_SUGGESTION_LIMITS: {
+    readonly title: 140;
+    readonly description: 4000;
+    readonly screen: 512;
+};
+interface SpineSuggestionPerson {
+    user_id: string;
+    username: string | null;
+    name: string | null;
+    picture: string | null;
+}
+/** Uma sugestão como o argos-admin devolve (`/me/suggestions` e `/auto-service/:clientId/suggestions`). */
+interface SpineSuggestion {
+    id: string;
+    /** A chave da sugestão no app ("SUG-12"), a mesma que a equipe usa no quadro. */
+    key?: string;
+    kind: SpineSuggestionKind;
+    title: string;
+    description: string;
+    screen: {
+        path: string | null;
+        label: string | null;
+    };
+    status: SpineSuggestionStatus;
+    position: number;
+    votes: number;
+    /** Quem consulta também apoia (só nas leituras da pessoa). */
+    voted: boolean;
+    comments_count: number;
+    last_comment: {
+        comment: string;
+        created_at: string;
+    } | null;
+    /** Desde quando está no status atual (o último evento para ele; sem evento, a criação). */
+    status_at?: string;
+    created_at: string;
+    updated_at: string;
+    /** Só no auto-serviço: quem pediu, com a foto (null = pessoa removida). */
+    author?: SpineSuggestionPerson | null;
+    /** Só em "já pediram nesta tela": a sugestão é de quem consulta (autora ou relatora). */
+    mine?: boolean;
+    /** Só em "Minhas": quem consulta é relatora (a sugestão dela foi agrupada nesta), não a autora. */
+    reporter?: boolean;
+    /** Só em "Minhas": as sugestões de quem consulta agrupadas nesta ("SUG-30 agrupada em SUG-12"). */
+    merged_from?: Array<{
+        id: string;
+        key: string;
+        title: string;
+    }>;
+}
+/**
+ * Uma sugestão em "Sugestões do app" (`/me/suggestions/all`): só o que é público do pedido, de quem quer que seja —
+ * nada do quadro de trabalho da equipe, e os comentários contados e o último são só os públicos.
+ */
+interface SpineAppSuggestion {
+    id: string;
+    key: string;
+    kind: SpineSuggestionKind;
+    title: string;
+    /** Texto puro (a descrição inteira, até 4000). */
+    description: string;
+    screen: {
+        path: string | null;
+        label: string | null;
+    };
+    status: SpineSuggestionStatus;
+    votes: number;
+    /** Quem consulta apoia. */
+    voted: boolean;
+    /** É de quem consulta: não dá para apoiar (o servidor responde `409 own_suggestion`). */
+    mine: boolean;
+    comments_count: number;
+    last_comment: {
+        comment: string;
+        created_at: string;
+    } | null;
+    created_at: string;
+    /** Quem pediu, com a foto (null = pessoa removida). */
+    author: SpineSuggestionPerson | null;
+}
+/** Comentário público de uma sugestão (`/me/suggestions/:id/comments`); `status` = a mudança que ele acompanha. */
+interface SpineSuggestionComment {
+    id: string;
+    comment: string;
+    status: SpineSuggestionStatus | null;
+    created_at: string;
+    author: SpineSuggestionPerson | null;
+}
+interface SpineAppSuggestionsQuery {
+    limit: number;
+    offset: number;
+    status?: SpineSuggestionPublicStatus | '';
+    /** Título, descrição, tela ou a chave ("SUG-12"). */
+    q?: string;
+    /** Só as pedidas nesta rota. */
+    screen?: string;
+    sort?: SpineSuggestionPublicSort;
+}
+interface SpineSuggestionDraft {
+    kind: SpineSuggestionKind;
+    title: string;
+    description: string;
+    screen: {
+        path: string | null;
+        label: string | null;
+    };
+}
+/**
+ * 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`).
+ */
+declare class SpineSuggestionsService {
+    private readonly http;
+    private readonly auth;
+    private readonly adminApi;
+    private url;
+    create(draft: SpineSuggestionDraft): Promise<SpineSuggestion>;
+    /** As minhas, da mais nova; `status` filtra uma coluna. */
+    mine(opts: {
+        limit: number;
+        offset: number;
+        status?: SpineSuggestionStatus | '';
+    }): Promise<{
+        suggestions: SpineSuggestion[];
+        total: number;
+    }>;
+    /** "Sugestões do app": as de todas as pessoas no app (menos recusadas e arquivadas), com filtros e paginação. */
+    all(query: SpineAppSuggestionsQuery): Promise<{
+        suggestions: SpineAppSuggestion[];
+        total: number;
+    }>;
+    /** Os comentários públicos de uma sugestão (o detalhe só de leitura), do mais novo. */
+    comments(id: string, page: {
+        limit: number;
+        offset: number;
+    }): Promise<{
+        comments: SpineSuggestionComment[];
+        total: number;
+    }>;
+    /** 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>;
+    unvote(id: string): Promise<void>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SpineSuggestionsService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<SpineSuggestionsService>;
+}
+
 /**
  * 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`.
@@ -2196,6 +2996,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, OnboardingOverlayComponent, OnboardingService, SPINE_BRAND, SPINE_IDLE_WARNING_SECONDS, SPINE_MARKDOWN_PURIFY_CONFIG, SPINE_PREFERENCES_SAVE_DELAY_MS, SPINE_SETTINGS_ALIASES, SPINE_SETTINGS_KEYS, SPINE_SETTINGS_SECTIONS, SettingsPanelComponent, ShortcutService, ShortcutsCheatsheetComponent, SidebarComponent, SpineAccountPreferencesService, SpineAccountSecurityService, SpineAppTokensService, SpineBrandComponent, SpineConnectionBannerComponent, SpineDocsComponent, SpineDocsService, SpineIdleService, SpineIdleWarningComponent, SpineLogoutService, SpineMarkdownComponent, SpineMyGroupsService, SpineNewsComponent, SpineNewsService, SpineNoticesService, SpineSettingsService, SpineStartPageService, accountErrorCode, argosAccountApi, buildMcpConfig, effectiveIdleMinutes, findTourTarget, idleLimits, isInternalPath, provideSettingsSection, resolveSettingsSection, sanitizeSpineMarkdownHtml, stable };
-export type { AccountActivityEntry, AccountActivityPage, AccountBadges, AccountMethod, AccountOverview, AccountPreferences, AccountReauth, AccountSession, AppToken, AppTokenList, AppTokenOptions, CreatedAppToken, DocsEntry, DocsGroup, DocsView, GroupMember, GroupRole, ManagedGroup, OnboardingState, OnboardingStep, RealmUser, ShortcutActions, ShortcutGroup, ShortcutGroupId, ShortcutItem, SpineAccountPreferencesDoc, SpineAccountPreferencesStatus, SpineIdleLimits, SpineNotice, SpineNoticePermission, SpineSettingsSection };
+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 };
 //# sourceMappingURL=trismegisto-spine-layout.d.ts.map