@trismegisto/spine 2.0.0

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

@@ -0,0 +1,1054 @@
+import * as _angular_core from '@angular/core';
+import { OnDestroy, OnInit, ElementRef, InjectionToken, Type, Provider } from '@angular/core';
+import { Router } from '@angular/router';
+import * as _orfeu_angular_core from '@orfeu/angular/core';
+import { AuthorizationService, ViewService, UserProfile, AppDef, RealmAppsService } from '@orfeu/angular/core';
+import * as _trismegisto_spine from '@trismegisto/spine';
+import { SpineConfig, SpineNewsSlide, Route, ThemeService, ThemePresetService, DensityService, SpinePreferencesService } from '@trismegisto/spine';
+import { BehaviorSubject, Subject } from 'rxjs';
+import * as _trismegisto_angular from '@trismegisto/angular';
+import { HermesShortcutItem, WorkspaceStore, TabItem, MenuItem, SidebarNode, HermesSidebarService, SegmentedOption, HermesThemeMode, HermesDensity, ComboboxOption } from '@trismegisto/angular';
+import * as _trismegisto_primitives from '@trismegisto/primitives';
+import { formatMessage, HermesFont } from '@trismegisto/primitives';
+import * as _trismegisto_tokens from '@trismegisto/tokens';
+import * as _trismegisto_spine_layout from '@trismegisto/spine/layout';
+import { RouteDocument } from '@trismegisto/spine/routing';
+import { SafeHtml } from '@angular/platform-browser';
+
+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.
+ */
+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 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. */
+    maybeStart(): void;
+    /** Reabre o tour manualmente (menu Ajuda), ignorando a flag. */
+    restart(): void;
+    /** Passos no idioma ativo (o texto é lido do catálogo ao começar o tour). Descrições com `<b>`. */
+    private allSteps;
+    /**
+     * 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`.
+     */
+    private start;
+    private emit;
+    next(): void;
+    prev(): void;
+    /** Encerra o tour (concluído ou pulado) e marca como visto. */
+    finish(): void;
+    get isFirst(): boolean;
+    get isLast(): boolean;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<OnboardingService, [{ optional: true; }]>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<OnboardingService>;
+}
+
+/**
+ * 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.
+ */
+declare class SpineNewsService {
+    private readonly onboarding;
+    private readonly items;
+    private readonly seenKey;
+    /** Slides em exibição (os devidos, ou todos os vigentes quando reaberto pelo menu). */
+    readonly slides: _angular_core.WritableSignal<readonly SpineNewsSlide[]>;
+    readonly isOpen: _angular_core.WritableSignal<boolean>;
+    /** Há alguma novidade vigente — o item "Novidades" do menu só aparece com isto. */
+    readonly hasAny: _angular_core.Signal<boolean>;
+    constructor();
+    /** Chamado uma vez pelo layout na entrada: abre as devidas, esperando o tour terminar. */
+    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. */
+    showAll(): 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;
+    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;
+    toggleTheme?: () => void;
+    toggleFullscreen?: () => void;
+    logout?: () => void;
+    openSettings?: () => 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.
+ *
+ * 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).
+ */
+declare class ShortcutService implements OnDestroy {
+    private actions;
+    private removers;
+    private readonly favKey;
+    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>;
+    /** Teclas (referência) → descrição viva, para o painel acompanhar a troca de idioma. */
+    private readonly own;
+    /** Os atalhos do shell. `describe` lê o catálogo na hora (o idioma pode mudar depois do registro). */
+    private definitions;
+    /** Só exibidos: quem dispara é outra peça (hm-header, navegador, diálogos). */
+    private displayOnly;
+    /**
+     * O que o painel lista (`<hm-shortcut-list [registered]="false" [items]="panelItems()">`): os
+     * atalhos registrados no `HermesShortcutService`, com os favoritos numa linha só, e os só exibidos.
+     * 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;
+    /** Ação ausente devolve `false`: o evento segue sem `preventDefault` (o navegador faz o dele). */
+    private call;
+    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>;
+}
+
+/**
+ * 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.
+ */
+declare class SpineWorkspaceNavService {
+    private readonly router;
+    private readonly viewService;
+    readonly store: WorkspaceStore;
+    private readonly state;
+    readonly root: _angular_core.Signal<_trismegisto_primitives.PanelNode>;
+    readonly focusedPanelId: _angular_core.Signal<string>;
+    /** Cadeia resolvida (header→…→page) da aba ativa do painel FOCADO — é o que `spine-sidebar`
+     *  (menu) e `spine-navigation` (breadcrumb) leem pra saber "onde estamos", no lugar do antigo
+     *  `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;
+    constructor();
+    /** 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. */
+    private chainFor;
+    tabFor(url: string): TabItem;
+    /** O `+` de um painel: abre a home ali, como um navegador. */
+    openNewTab(panelId: 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;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SpineWorkspaceNavService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<SpineWorkspaceNavService>;
+}
+
+/**
+ * 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
+ * (`100dvh`, não `%` cascateado — `@trismegisto/core` não fixa altura de `html`/`body`, é
+ * responsabilidade de quem consome, mesmo tanto quanto o docs faz no próprio `styles.scss`),
+ * `hm-header` (utilitários — tema/densidade/apps/perfil, nunca navegação de página) + `.body`
+ * (`hm-sidebar` fixa + `.main` com `hm-workspace`). **Sem barra de breadcrumb própria** — isso
+ * era resíduo do spine antigo (`spine-navigation`), removido: o docs não tem uma, a navegação
+ * inteira mora na sidebar. Entre o header e o corpo fica o `spine-connection-banner` (aviso de conexão
+ * do `@orfeu/angular`, vazio quando `online`).
+ *
+ * O `<router-outlet>` que sobra aqui é só pra `/no-permission` (a única rota do shell com
+ * `component` de verdade — o resto da árvore do backend nunca passa pelo `Router` pra renderizar,
+ * só pra `ViewGuard` confirmar que a URL resolve). Fica sempre montado (nunca dentro de um `@if`)
+ * e escondido via `[hidden]` quando não é a rota ativa — destruir/recriar o outlet num `@if`
+ * arriscaria perder a ativação da rota se a navegação e a checagem de `isNoPermission` não
+ * corressem na mesma volta de detecção de mudanças.
+ */
+declare class LayoutComponent implements OnInit {
+    private router;
+    private theme;
+    private auth;
+    private shortcuts;
+    private onboarding;
+    private news;
+    /** Aplica no boot o idioma e o fuso que a pessoa escolheu nas configurações. */
+    private readonly preferences;
+    protected readonly workspace: SpineWorkspaceNavService;
+    private readonly settings;
+    /** 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
+     *  painel secundário navegando localmente pra `/no-permission` não passa por aqui — cenário raro
+     *  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, auth: AuthorizationService, shortcuts: ShortcutService, onboarding: OnboardingService, news: SpineNewsService);
+    private matchesNoPermission;
+    ngOnInit(): void;
+    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>;
+}
+
+/** Item achatado da árvore de rotas, usado pela busca global (quick-launcher). */
+interface QuickItem {
+    name: string;
+    icon: string;
+    redirect: string;
+    path: string;
+}
+declare class HeaderComponent implements OnInit {
+    private authService;
+    protected themeService: ThemeService;
+    protected themePresetService: ThemePresetService;
+    protected densityService: DensityService;
+    private viewService;
+    private router;
+    private onboarding;
+    private shortcuts;
+    isFullscreen: boolean;
+    element: HTMLElement;
+    headerBlocked: boolean;
+    /** route_redirect da primeira rota navegável da view atual — usado pela marca do header.
+     *  null quando a view não tem nenhuma rota (nesse caso a marca não é link). */
+    homeRoute: string | null;
+    /** Nome do app (SpineConfig.appName; padrão "Hermes") — quem desenha é o `spine-brand`. */
+    protected readonly appName: string;
+    private readonly injector;
+    protected readonly text: {
+        home: string;
+        apps: string;
+        themeDark: string;
+        themeLight: string;
+        densityComfortable: string;
+        densityCompact: string;
+        fullscreen: string;
+        exitFullscreen: string;
+        user: string;
+        accessLevels: string;
+        settings: string;
+        appearance: string;
+        shortcuts: string;
+        tour: string;
+        news: string;
+        logout: string;
+        search: string;
+        searchPlaceholder: string;
+        recentSearches: string;
+        clearRecent: string;
+        noResults: string;
+    };
+    protected readonly fmt: typeof formatMessage;
+    private readonly settings;
+    private readonly news;
+    private readonly recentSearchKey;
+    constructor(authService: AuthorizationService, themeService: ThemeService, themePresetService: ThemePresetService, densityService: DensityService, viewService: ViewService, router: Router, onboarding: OnboardingService, shortcuts: ShortcutService, config: SpineConfig | null);
+    ngOnInit(): Promise<void>;
+    updateView(data: any): void;
+    /** Primeira rota navegável (DFS), atravessando grupos "transparentes" sem route_redirect. */
+    private findFirstNavigable;
+    setTheme(theme: 'light' | 'dark'): void;
+    setDensity(): void;
+    get isCompactDensity(): boolean;
+    toggleFullscreen(): void;
+    get badge(): _orfeu_angular_core.Badge | null;
+    get badges(): _orfeu_angular_core.Badge[];
+    get profile(): UserProfile;
+    switchBadge(badgeTypeId: string): Promise<void>;
+    logout(): void;
+    /** Reabre o tour guiado de onboarding. */
+    startTour(): 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;
+    quickOpen: boolean;
+    quickResults: QuickItem[];
+    quickActive: number;
+    private quickIndex;
+    /** Histórico de buscas (mostrado ao focar com o campo vazio). */
+    recentSearches: QuickItem[];
+    /** Verdadeiro quando o painel está exibindo o histórico (campo vazio). */
+    showingRecent: boolean;
+    /** 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). */
+    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;
+    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 ɵcmp: _angular_core.ɵɵComponentDeclaration<HeaderComponent, "spine-header", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * A grade de apps não cabe no `MenuItem` de linha única do `hm-menu` (ícone grande + nome
+ * embaixo, em coluna) — em vez de forçar isso num componente pensado pra lista de ações, usa
+ * um popover próprio (mesmo padrão do backdrop-fecha-fora da busca global do header).
+ */
+declare class AppLauncherComponent implements OnInit {
+    private authService;
+    private realmAppsService;
+    protected readonly text: {
+        home: string;
+        apps: string;
+        themeDark: string;
+        themeLight: string;
+        densityComfortable: string;
+        densityCompact: string;
+        fullscreen: string;
+        exitFullscreen: string;
+        user: string;
+        accessLevels: string;
+        settings: string;
+        appearance: string;
+        shortcuts: string;
+        tour: string;
+        news: string;
+        logout: string;
+        search: string;
+        searchPlaceholder: string;
+        recentSearches: string;
+        clearRecent: string;
+        noResults: string;
+    };
+    private readonly cdr;
+    apps: AppDef[];
+    loading: boolean;
+    open: boolean;
+    constructor(authService: AuthorizationService, realmAppsService: RealmAppsService);
+    ngOnInit(): Promise<void>;
+    toggle(): void;
+    close(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AppLauncherComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AppLauncherComponent, "spine-app-launcher", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Marca do header: logo do app (`SpineConfig.logo`, padrão `assets/images/logo.svg`) + `appName`, dentro
+ * de um link para a home. Ordem: componente de `SPINE_BRAND` > imagem > só o nome.
+ *
+ * - Tema escuro usa `logo.dark` quando houver; se ele falhar, volta para `logo.light`.
+ * - Imagem que não carrega (404/erro) some — nada de ícone quebrado — e o nome aparece mesmo com
+ *   `showAppName: false`, para o link nunca ficar sem texto.
+ * - Texto alternativo: `logo.alt` se configurado; senão o `appName` quando o nome está escondido, e vazio
+ *   (imagem decorativa) quando o nome já está ao lado — o leitor de tela não lê o nome duas vezes.
+ */
+declare class SpineBrandComponent {
+    /** Rota da home (primeira rota navegável); `null` desenha a marca sem link. */
+    readonly homeRoute: _angular_core.InputSignal<string | null>;
+    /** Dica do link (ex.: "Página inicial"). */
+    readonly label: _angular_core.InputSignal<string>;
+    private readonly config;
+    private readonly theme;
+    protected readonly brand: _angular_core.Type<unknown> | null;
+    protected readonly appName: string;
+    private readonly sources;
+    private readonly showAppName;
+    /** Endereços que já deram erro nesta sessão do componente. */
+    private readonly failed;
+    /** Imagem a mostrar agora (tema atual, sem as que falharam); `null` = nenhuma. */
+    readonly src: _angular_core.Signal<string | null>;
+    readonly nameVisible: _angular_core.Signal<boolean>;
+    readonly alt: _angular_core.Signal<string>;
+    onError(src: string): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SpineBrandComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SpineBrandComponent, "spine-brand", never, { "homeRoute": { "alias": "homeRoute"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Componente de marca que o header do shell desenha no lugar da imagem de `SpineConfig.logo` (tem
+ * prioridade sobre ela). Injeção em vez de projeção de conteúdo porque o `LayoutComponent` é montado
+ * pelo `Router`, não pelo template do app — não existe `<ng-content>` alcançável de fora. O componente
+ * fica dentro do link da marca (que leva à home): não ponha link nem botão nele, e se ele for só
+ * imagem, dê nome acessível ou deixe o `appName` visível (`showAppName`, padrão `true`).
+ * `null` (padrão) usa a imagem. Ex.: `{ provide: SPINE_BRAND, useValue: MarcaComponent }` no
+ * `app.config.ts`.
+ */
+declare const SPINE_BRAND: InjectionToken<Type<unknown> | null>;
+
+/**
+ * Menu lateral fixo — TODA a navegação do shell mora aqui agora, nunca no header (decisão
+ * explícita do usuário: "não deve ter ícones de navegação no menu superior, deve ter um menu
+ * lateral de navegação fixa" — o antigo `h-nav`/`hm-menu-button` de nível 'header'/'menu' do
+ * `header.component.html` foi removido, essa navegação virou `modules` abaixo).
+ *
+ * Dois níveis, um de cada vez — MESMO padrão de back/forward do `docs/website`'s sidebar (achado
+ * real, 2026-09-28: a primeira versão mostrava os dois SEMPRE juntos, empilhados, achando que o
+ * modelo de rotas do backend não permitia "sair" de um módulo — errado; nada impede mostrar só um
+ * nível por vez com um botão de voltar, é só um `signal` local):
+ * - `modules` (nível 1, 'header', de `ViewService.currentView` direto — não muda com a navegação
+ *   do painel): a lista pra trocar de módulo.
+ * - `menus`: a cadeia resolvida da aba ativa do painel FOCADO
+ *   (`SpineWorkspaceNavService.focusedChain`) — os itens do módulo ATUAL.
+ * `viewingModules` decide qual dos dois aparece; volta pra `false` sozinho sempre que o módulo
+ * atual muda (navegação real feita, mesma UX do `leaveModule()` do docs).
+ */
+declare class SidebarComponent {
+    protected readonly text: {
+        modules: string;
+        moduleNavigation: string;
+        apps: string;
+    };
+    protected readonly fmt: typeof formatMessage;
+    private readonly workspace;
+    private readonly viewService;
+    private readonly authService;
+    private readonly realmApps;
+    /** 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;
+    /** Sem nenhum crachá (nenhum grupo do app — ver `ViewGuard`, tela `/blocked`), o menu fica vazio
+     *  mesmo que a view traga rotas públicas: listar o que leva de volta ao "Acesso bloqueado" não
+     *  ajuda. `badges` não é sinal, mas a view sempre é refeita depois do token (`view.update`), e é
+     *  ela que recalcula isto. */
+    protected readonly modules: _angular_core.Signal<SidebarNode[]>;
+    protected readonly currentModule: _angular_core.Signal<Route | null>;
+    /** Filhos diretos do módulo atual — sem filtrar por `route_type` (ver `toSidebarNode`). */
+    protected readonly menus: _angular_core.Signal<SidebarNode[]>;
+    /** Nem todo nível 1 é um "módulo" navegável — "Início"/"Monitoração" na árvore real são
+     *  `route_type: 'page'` SEM filhos, folhas diretas (achado real, 2026-09-28: mostravam
+     *  cabeçalho + botão voltar + área de conteúdo vazia, como se fossem módulos de verdade). Só
+     *  entra no modo "dentro do módulo" quando há algo pra mostrar como submenu. */
+    protected readonly currentModuleHasChildren: _angular_core.Signal<boolean>;
+    /** `true` = mostrando a lista de módulos; `false` = mostrando o menu do módulo atual. Cai pra
+     *  `true` sozinho quando o módulo atual não tem submenu nenhum — nesse caso não existe "dentro
+     *  do módulo" pra mostrar. */
+    private readonly wantsModules;
+    protected readonly viewingModules: _angular_core.Signal<boolean>;
+    /** 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;
+    constructor();
+    protected showModules(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SidebarComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SidebarComponent, "spine-sidebar", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Aviso discreto de conexão no topo do shell, sobre o `connectionState$` e o `reauthorizationRequired$` do
+ * `@orfeu/angular`. A sessão nunca cai por nada disto (sem rede, Argos fora do ar, refresh recusado):
+ * a lib segue tentando sozinha e este banner só conta o que está acontecendo.
+ *
+ * - `offline`: aviso (`warning`) — Argos inalcançável; a lib tenta de novo com backoff e na volta da rede/foco.
+ * - `reconnecting` / `reauthorizing`: informativo (`info`), some quando volta a `online`.
+ * - `reauthorizationRequired$`: o Argos recusou a renovação e a reautorização automática não aconteceu
+ *   (desligada, outra aba cuidando ou proteção contra loop). Oferece "Entrar novamente", que chama
+ *   `authorize(urlAtual)` — o login volta para a mesma tela. Nunca chama `logout()`.
+ *
+ * `hm-alert` em `appearance="banner"` e `size="small"`: faixa de largura total, sem cantos, com os tokens
+ * de status do Hermes (`--hm-warning-*`/`--hm-info-*`); `role="status"` (não interrompe o leitor de tela).
+ */
+declare class SpineConnectionBannerComponent {
+    protected readonly text: {
+        offline: string;
+        reconnecting: string;
+        reauthorizing: string;
+        reauthorizationRequired: string;
+        signInAgain: string;
+        callbackFailedHeading: string;
+        callbackFailedText: string;
+    };
+    private readonly auth;
+    private readonly router;
+    private readonly state;
+    private readonly reauthRequired;
+    /** O que mostrar: a decisão pendente da pessoa vence o estado da conexão; `online` não mostra nada. */
+    protected readonly notice: _angular_core.Signal<_orfeu_angular_core.ConnectionState | "reauthorizationRequired">;
+    protected signInAgain(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SpineConnectionBannerComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SpineConnectionBannerComponent, "spine-connection-banner", never, {}, {}, never, never, true, never>;
+}
+
+interface Box {
+    top: number;
+    left: number;
+    width: number;
+    height: number;
+}
+/**
+ * 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.
+ */
+declare class OnboardingOverlayComponent implements OnInit, OnDestroy {
+    private onboarding;
+    protected readonly text: {
+        progress: string;
+        skip: string;
+        back: string;
+        next: string;
+        finish: string;
+        welcomeTitle: string;
+        welcomeText: string;
+        appsTitle: string;
+        appsText: 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;
+    };
+    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;
+    };
+    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>;
+}
+
+/**
+ * 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.
+ */
+declare class ShortcutsCheatsheetComponent implements OnInit, OnDestroy {
+    open: boolean;
+    protected readonly text: {
+        heading: string;
+        hint: string;
+        replayTour: string;
+        dismiss: string;
+        openSearch: string;
+        goHome: string;
+        goFavorite: string;
+        history: string;
+        openSettings: string;
+        toggleTheme: string;
+        fullscreen: string;
+        logout: string;
+        showHelp: string;
+        closeOverlay: string;
+    };
+    private readonly shortcuts;
+    private readonly onboarding;
+    /** 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;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ShortcutsCheatsheetComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ShortcutsCheatsheetComponent, "spine-shortcuts-cheatsheet", never, {}, {}, never, never, true, never>;
+}
+
+/** Seções que o próprio spine já traz. `key` é também o valor de `?settings=` na URL. */
+declare const SPINE_SETTINGS_KEYS: {
+    readonly appearance: "aparencia";
+    readonly region: "regiao";
+    readonly shortcuts: "atalhos";
+    readonly account: "conta";
+    readonly about: "sobre";
+};
+/** Seção extra do painel, registrada pelo app (ex.: preferências de deploy do hefesto). */
+interface SpineSettingsSection {
+    /** Identificador estável; também o que `?settings=<key>` abre. Não repetir os do spine. */
+    key: string;
+    label: string;
+    /** Ícone do hermes-icon na navegação. */
+    icon?: string;
+    description?: string;
+    /** Termos extras que acham a seção inteira na busca. */
+    keywords?: string;
+    /** Conteúdo da seção — de preferência `hm-settings-row`s, para a busca achar cada linha. */
+    component: Type<unknown>;
+}
+declare const SPINE_SETTINGS_SECTIONS: InjectionToken<SpineSettingsSection[]>;
+/** Registra uma seção do app no painel de configurações (aparece depois das do spine, antes de
+ * "Sobre"). Pode ser chamado várias vezes, uma por seção. */
+declare function provideSettingsSection(section: SpineSettingsSection): Provider;
+/** Abre/fecha o painel de configurações de qualquer lugar (menu do perfil, atalho, link). */
+declare class SpineSettingsService {
+    readonly isOpen: _angular_core.WritableSignal<boolean>;
+    /** Seção pedida na abertura (vazio = a primeira). */
+    readonly section: _angular_core.WritableSignal<string>;
+    open(section?: string): void;
+    close(): void;
+    toggle(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SpineSettingsService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<SpineSettingsService>;
+}
+
+/**
+ * Painel de configurações do shell (substitui as telas do antigo módulo "Sistema"): Aparência,
+ * Região, Atalhos, Conta 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).
+ *
+ * Aberto por `SpineSettingsService.open()` — menu do perfil, `Ctrl+,` ou `?settings=<seção>`.
+ */
+declare class SettingsPanelComponent {
+    protected readonly settings: SpineSettingsService;
+    private readonly messages;
+    protected readonly text: {
+        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;
+        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;
+        shortcuts: string;
+        shortcutsDescription: string;
+        shortcutsKeywords: string;
+        tour: string;
+        tourDescription: string;
+        tourKeywords: string;
+        replayTour: 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;
+        appTokens: string;
+        appTokensDescription: string;
+        appTokensKeywords: string;
+        logout: string;
+        logoutDescription: string;
+        logoutKeywords: 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;
+    };
+    protected readonly fmt: typeof formatMessage;
+    protected readonly keys: {
+        readonly appearance: "aparencia";
+        readonly region: "regiao";
+        readonly shortcuts: "atalhos";
+        readonly account: "conta";
+        readonly about: "sobre";
+    };
+    private readonly theme;
+    private readonly hermesTheme;
+    private readonly presets;
+    private readonly density;
+    protected readonly sidebar: HermesSidebarService;
+    protected readonly preferences: SpinePreferencesService;
+    private readonly shortcutService;
+    private readonly onboarding;
+    private readonly auth;
+    private readonly toast;
+    protected readonly packageInfo: _trismegisto_spine.PackageInfo;
+    private readonly config;
+    protected readonly appSections: _trismegisto_spine_layout.SpineSettingsSection[];
+    protected readonly appName: string;
+    protected readonly themeOptions: _angular_core.Signal<readonly SegmentedOption<string>[]>;
+    protected readonly densityOptions: _angular_core.Signal<readonly SegmentedOption<string>[]>;
+    protected readonly fontOptions: readonly SegmentedOption[];
+    protected readonly sidebarOptions: _angular_core.Signal<readonly SegmentedOption<string>[]>;
+    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<HermesFont>;
+    protected readonly families: readonly _trismegisto_tokens.HermesFamily[];
+    protected setThemeMode(mode: string): void;
+    protected setFamily(id: string): void;
+    protected setDensity(value: string): void;
+    protected setFont(value: string): void;
+    protected setSidebarMode(value: string): void;
+    protected readonly languageOptions: _angular_core.Signal<{
+        readonly value: string;
+        readonly label: string;
+    }[]>;
+    /** ~400 fusos, cada um com o deslocamento calculado: só monta quando o painel abre pela
+     *  primeira vez, não no carregamento de toda página (o painel vive no layout desde o início). */
+    private timeZoneCache;
+    protected readonly timeZoneOptions: _angular_core.Signal<readonly ComboboxOption[]>;
+    /** Hora agora no fuso efetivo — prévia de como as datas vão aparecer. */
+    protected readonly timeZonePreview: _angular_core.Signal<string>;
+    /** 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[]>;
+    protected replayTour(): void;
+    protected get profile(): _orfeu_angular_core.UserProfile;
+    protected get badge(): _orfeu_angular_core.Badge | null;
+    /** Validade da sessão lida do `exp` do próprio token (só leitura do payload, sem validar). */
+    protected get sessionExpiry(): string;
+    protected copyToken(): Promise<void>;
+    protected logout(): void;
+    protected readonly dependencies: {
+        version: string | undefined;
+        name: string;
+        label: string;
+    }[];
+    protected get buildDate(): string;
+    /** Texto pronto pra colar num chamado: app, versão, ambiente, navegador, tela, fuso e página. */
+    protected copySupportInfo(): Promise<void>;
+    private copy;
+    protected onOpenChange(open: boolean): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SettingsPanelComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SettingsPanelComponent, "spine-settings-panel", never, {}, {}, never, never, true, never>;
+}
+
+/** Um token de aplicação do usuário, como o argos-admin devolve (nunca o valor, só o prefixo). */
+interface AppToken {
+    id: string;
+    name: string;
+    description: string | null;
+    prefix: string;
+    badge_id: string;
+    badge_name: string;
+    expires_at: string;
+    created_at: string;
+    last_used_at: string | null;
+    expired: boolean;
+}
+interface AppTokenList {
+    tokens: AppToken[];
+    max_active: number;
+    max_days: number;
+}
+/** A aplicação logada e os níveis de acesso que o usuário pode escolher nela ao criar um token. */
+interface AppTokenOptions {
+    client: {
+        id: string;
+        name: string | null;
+    };
+    badges: {
+        id: string;
+        name: string;
+    }[];
+    max_days: number;
+}
+interface CreatedAppToken {
+    id: string;
+    /** Valor bruto — só existe nesta resposta. */
+    token: string;
+    expires_at: string;
+}
+/**
+ * Tokens de aplicação pessoais (`x-app-token`) do usuário logado — `argos-admin /me/app-tokens`.
+ * Sempre da aplicação LOGADA: o servidor tira o client do próprio access-token da sessão, então
+ * aqui não existe escolha de aplicação.
+ * Autentica com o access-token da sessão (o servidor recusa um app-token aqui: token não cria
+ * token). `available` é falso quando o app não tem a URL do argos-admin (`SPINE_ADMIN_API`).
+ */
+declare class SpineAppTokensService {
+    private readonly http;
+    private readonly auth;
+    private readonly adminApi;
+    readonly available: boolean;
+    private get baseUrl();
+    private get headers();
+    list(): Promise<AppTokenList>;
+    options(): Promise<AppTokenOptions>;
+    create(body: {
+        badge_id: string;
+        name: string;
+        validity_days: number;
+    }): Promise<CreatedAppToken>;
+    revoke(id: string): Promise<void>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SpineAppTokensService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<SpineAppTokensService>;
+}
+
+/** Documento de uma tela que a pessoa logada pode abrir. */
+interface DocsEntry extends RouteDocument {
+    /** Chave da tela (router_id ou, sem ele, o do template), sempre em minúsculas. */
+    readonly id: string;
+    readonly title: string;
+    readonly group: string;
+}
+interface DocsGroup {
+    readonly title: string;
+    readonly entries: readonly DocsEntry[];
+}
+type DocsView = 'usage' | 'technical';
+/**
+ * Estado da documentação das telas: o que está registrado em `COMPONENT_ROUTES` com `document`,
+ * filtrado pelas telas que existem na árvore da pessoa (documento de tela sem acesso nunca é oferecido),
+ * e a leitura em andamento no modal `spine-docs`.
+ */
+declare class SpineDocsService {
+    #private;
+    /** Visão técnica liberada (`SpineConfig.technicalDocs`; sem configuração, só em desenvolvimento). */
+    readonly technicalAvailable: boolean;
+    readonly isOpen: _angular_core.Signal<boolean>;
+    readonly current: _angular_core.Signal<DocsEntry | null>;
+    readonly view: _angular_core.Signal<DocsView>;
+    readonly content: _angular_core.Signal<string>;
+    readonly loading: _angular_core.Signal<boolean>;
+    readonly error: _angular_core.Signal<string>;
+    readonly showTechnical: _angular_core.Signal<boolean>;
+    readonly index: _angular_core.Signal<DocsGroup[]>;
+    constructor();
+    documentFor(routerId: string | null | undefined, sourceTemplateRouterId?: string | null): DocsEntry | null;
+    openForRoute(routerId: string | null | undefined, sourceTemplateRouterId?: string | null): void;
+    openIndex(): void;
+    close(): void;
+    open(entry: DocsEntry, view?: DocsView): Promise<void>;
+    show(view: DocsView): Promise<void>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SpineDocsService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<SpineDocsService>;
+}
+
+/**
+ * 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`.
+ */
+declare class SpineNewsComponent {
+    protected readonly news: SpineNewsService;
+    protected readonly text: {
+        heading: string;
+        carousel: string;
+        dismiss: 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;
+    }[]>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SpineNewsComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SpineNewsComponent, "spine-news", never, {}, {}, 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`.
+ */
+declare class SpineDocsComponent {
+    protected readonly docs: SpineDocsService;
+    protected readonly text: _trismegisto_spine.SpineMessages;
+    protected readonly query: _angular_core.WritableSignal<string>;
+    protected readonly groupId: string;
+    protected readonly viewOptions: _angular_core.Signal<SegmentedOption<DocsView>[]>;
+    protected readonly filtered: _angular_core.Signal<DocsGroup[]>;
+    protected readonly readingKey: _angular_core.Signal<string[]>;
+    protected select(entry: DocsEntry): void;
+    protected switchView(view: string): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SpineDocsComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SpineDocsComponent, "spine-docs", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Renderiza Markdown (GFM) como HTML com a tipografia do design system. O texto é tratado como dado:
+ * o HTML gerado passa pelo DOMPurify antes de chegar ao DOM.
+ */
+declare class SpineMarkdownComponent {
+    #private;
+    /** Markdown cru. Vazio não desenha nada. */
+    readonly content: _angular_core.InputSignal<string>;
+    protected readonly html: _angular_core.Signal<SafeHtml | null>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SpineMarkdownComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SpineMarkdownComponent, "spine-markdown", never, { "content": { "alias": "content"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+export { AppLauncherComponent, HeaderComponent, LayoutComponent, OnboardingOverlayComponent, OnboardingService, SPINE_BRAND, SPINE_SETTINGS_KEYS, SPINE_SETTINGS_SECTIONS, SettingsPanelComponent, ShortcutService, ShortcutsCheatsheetComponent, SidebarComponent, SpineAppTokensService, SpineBrandComponent, SpineConnectionBannerComponent, SpineDocsComponent, SpineDocsService, SpineMarkdownComponent, SpineNewsComponent, SpineNewsService, SpineSettingsService, findTourTarget, provideSettingsSection };
+export type { AppToken, AppTokenList, AppTokenOptions, CreatedAppToken, DocsEntry, DocsGroup, DocsView, OnboardingStep, ShortcutActions, ShortcutGroup, ShortcutGroupId, ShortcutItem, SpineSettingsSection };
+//# sourceMappingURL=trismegisto-spine-layout.d.ts.map