@trismegisto/spine 2.0.0

package/types/trismegisto-spine.d.ts

@@ -0,0 +1,1161 @@
+import * as i0 from '@angular/core';
+import { Type, InjectionToken, NgZone, EnvironmentProviders, Provider } from '@angular/core';
+import { HermesThemeName, HermesThemeMode, HermesFamily, HermesDensity } from '@trismegisto/angular';
+import { HermesThemeExtension, PluralMessage, CatalogOverride } from '@trismegisto/primitives';
+
+interface Route {
+    route_display_name?: string | null;
+    route_icon?: string | null;
+    /**
+     * @deprecated use `router_id` (ou `routerIdOf`). Nome histórico: no nó 'page' o argos-auth-server
+     * sempre mandou aqui o `router_id` (nunca o `web.routes.route_id`, que é `routed_id`). Continua
+     * vindo, com o mesmo valor, para spines/Orfeu antigos.
+     */
+    route_id?: string | null;
+    route_name?: string | null;
+    route_order?: number | null;
+    route_path?: string | null;
+    route_redirect?: string | null;
+    route_redirect_to?: string | null;
+    route_type?: string | null;
+    /** A ROTA do nó (`web.routes.route_id`): nome/ícone/path. Reaproveitável em vários routers. */
+    routed_id: string;
+    routes?: Route[] | null;
+    /**
+     * Identidade da TELA: o router do client (`web.router.router_id`, a posição da tela na
+     * navegação). Só no nó 'page' -- nó de grupo (navigation/menu/...) é compartilhado por vários
+     * routers e não tem um próprio. É por ele que o spine acha o componente (`COMPONENT_ROUTES`),
+     * o documento e a descrição. Argos anterior a 2026-10-05 não manda: use `routerIdOf`, que cai
+     * no `route_id` (mesmo valor).
+     */
+    router_id?: string | null;
+    /** Texto curto da tela (`web.router.description`), exibido na barra da página abaixo do título. */
+    description?: string | null;
+    source_template_router_id?: string | null;
+}
+/** `router_id` da tela (nó 'page'), aceitando o argos antigo (que só mandava `route_id`, mesmo valor). */
+declare function routerIdOf(route: Route | null | undefined): string | null;
+
+/**
+ * Funde nós IRMÃOS que apontam para o mesmo endereço (`route_redirect`), em toda a árvore.
+ *
+ * Herança do roteamento antigo: o nível do nó (header/navigation/menu/item/submenu/page) dizia ONDE ele
+ * era desenhado — header no topo, menu na lateral, o resto no `<router-outlet>` de cada app. Agora tudo
+ * é menu (`spine-sidebar`) e o nível não importa mais, só o endereço. Só que o argos-auth-server monta a
+ * view pulando nível vazio: um router header("laboratorio")→page("prova-de-conceito") e outro
+ * navigation("laboratorio")→page("dashboard") viram dois nós de topo DIFERENTES com o mesmo
+ * `/laboratorio`. Resultado: dois "laboratorio" no menu, e a resolução por nível (`findRouteThrough`, que
+ * pega o PRIMEIRO irmão que casa) só enxergava os filhos de um deles — a página do outro caía no
+ * fallback do `ViewGuard` (volta para o início). Achado real, 2026-10-07.
+ *
+ * Regras:
+ * - Só funde irmãos da MESMA lista, com `route_redirect` igual e não vazio (grupo transparente, sem
+ *   endereço, nunca é fundido — não há o que comparar).
+ * - O nó fundido é o primeiro da lista (mantém posição, nome, ícone e `routed_id` dele); `router_id`/
+ *   `description`/`source_template_router_id` vêm do primeiro que tiver. Os filhos de todos são
+ *   juntados (ordenados por `route_order`, estável) e fundidos de novo, recursivamente.
+ * - Lista sem nenhum endereço repetido sai IGUAL (mesmo array, mesmos objetos): nada muda para app cuja
+ *   árvore já era consistente.
+ * - Nunca muta a entrada (a view é do `ViewService` do orfeu, compartilhada).
+ *
+ * Use `spineRoutesOf(view)` em vez de ler `view.routes` direto: o resultado é guardado por identidade do
+ * array, então todo consumidor (guard, painel, sidebar, busca...) recebe a MESMA árvore fundida.
+ */
+declare function mergeRouteTree(routes: readonly Route[] | null | undefined): Route[];
+/** A árvore fundida da view atual (`ViewService.currentView`) — ver `mergeRouteTree`. */
+declare function spineRoutesOf(view: {
+    routes?: readonly Route[] | null;
+} | null | undefined): Route[];
+
+/**
+ * Ponto único de import dos componentes standalone do `@trismegisto/angular` usados nos templates do
+ * spine. O DS novo é standalone-only (sem agregador), então este array cumpre o mesmo papel prático:
+ * um `@Component({ imports: [...HERMES_DS_IMPORTS] })` em vez de listar cada símbolo em cada arquivo
+ * que usa `hm-*`.
+ */
+declare const HERMES_DS_IMPORTS: readonly Type<unknown>[];
+
+/**
+ * Logo e favicon do app (`SpineConfig.logo`/`SpineConfig.favicon`). O spine não embute marca nenhuma:
+ * o arquivo é sempre do app, servido de `src/assets`.
+ */
+/** Logo do header: um caminho (os dois temas) ou as variantes clara/escura + texto alternativo. */
+type SpineLogoConfig = string | {
+    light: string;
+    dark?: string;
+    alt?: string;
+};
+/** Convenção quando o app não configura `logo`: `src/assets/images/logo.svg` servido em `assets/images/`. */
+declare const SPINE_DEFAULT_LOGO = "assets/images/logo.svg";
+/** Logo já normalizado. */
+interface SpineLogoSources {
+    light: string;
+    dark: string | null;
+    /** Texto alternativo explícito; `null` usa o padrão (o nome do app). */
+    alt: string | null;
+}
+/** Normaliza `SpineConfig.logo`: omitido → convenção; `false`/vazio → sem imagem (`null`). */
+declare function resolveSpineLogo(logo: SpineLogoConfig | false | null | undefined): SpineLogoSources | null;
+/**
+ * Aponta o favicon do documento para `href`: atualiza o primeiro `<link rel="icon">` (ou `shortcut icon`)
+ * e remove os outros (senão o navegador pode continuar escolhendo um deles); sem nenhum, cria um no
+ * `<head>`. O `type` acompanha a extensão (some quando ela é desconhecida).
+ */
+declare function applySpineFavicon(doc: Document, href: string): HTMLLinkElement | null;
+
+interface SpineConfig {
+    clientId: string;
+    /**
+     * Famílias de cor próprias do app (opcional): acrescentar (`families`), trocar uma existente
+     * (`replace: { poseidon: minhaFamilia }` — posição e preferência salva passam para a nova) e a
+     * família inicial (`defaultFamily`). Ver `extendThemeConfig` do `@trismegisto/primitives`; a família
+     * se monta e exporta no `hm-theme-builder`.
+     */
+    theme?: HermesThemeExtension;
+    /** Nome do app exibido ao lado do logo no header (ex.: "Hefesto"). Padrão: "Hermes". */
+    appName?: string;
+    /**
+     * Logo do header, servido pelo próprio app (caminho relativo ao `<base href>`, ex.: arquivo em
+     * `src/assets/images/`). Formas:
+     * - omitido: convenção `assets/images/logo.svg` (`SPINE_DEFAULT_LOGO`);
+     * - `'assets/images/logo.png'`: um arquivo só, para os dois temas;
+     * - `{ light, dark?, alt? }`: `dark` é usado no tema escuro (do `ThemeService`); `alt` substitui o texto
+     *   alternativo padrão;
+     * - `false`: sem imagem (só o nome, sem nenhuma requisição).
+     * Se a imagem não carregar (404/erro), o header esconde a imagem e mostra só o nome. Um componente de
+     * marca em `SPINE_BRAND` (`@trismegisto/spine/layout`) tem prioridade sobre a imagem.
+     */
+    logo?: SpineLogoConfig | false;
+    /** Mostra o `appName` ao lado do logo. Padrão: `true`. Com `false` o nome só aparece se não houver logo
+     * visível (sem imagem, ou imagem que falhou) — o link da marca nunca fica sem texto. */
+    showAppName?: boolean;
+    /** Favicon do app (ex.: `'assets/favicon.ico'`). Se definido, o `provideUi` atualiza o `<link rel="icon">`
+     * do `index.html` (ou cria um) no bootstrap; sem isto o spine não mexe no favicon. */
+    favicon?: string;
+    /** Exibe a aba "Especificação técnica" da documentação das telas (`RouteDocument.loadTechnical`).
+     * Padrão: `isDevMode()`. Apps com build de produção em homologação passam
+     * `!environment.production` (ou equivalente) para mostrá-la fora de produção. */
+    technicalDocs?: boolean;
+}
+declare const SPINE_CONFIG: InjectionToken<SpineConfig>;
+
+/**
+ * Wrapper fino sobre `HermesThemeService` (que já persiste em `localStorage` e aplica
+ * `data-theme`/`--hm-*` via `HermesThemeDirective`): mantém o mesmo nome/API de injeção do
+ * spine antigo, e adiciona só o que o DS novo não cobre — sincronização entre ABAS do
+ * navegador via `BroadcastChannel` (o `ThemeService` antigo tinha isso; `HermesThemeService`
+ * é por-aba). Aplica os atributos diretamente no `<body>` em vez de exigir que cada app
+ * consumidor lembre de colocar `hermesTheme` no template — mesmo espírito do antigo, que
+ * também escrevia `hermes-theme` no `<body>` a partir do serviço, não do template.
+ */
+declare class ThemeService {
+    private document;
+    private platformId;
+    private zone;
+    private readonly hermesTheme;
+    private channel;
+    private readonly channelName;
+    constructor(document: Document, platformId: Object, zone: NgZone, config: SpineConfig | null);
+    get current(): HermesThemeName;
+    /** Escolha do usuário: `light`, `dark` ou `system` (acompanha o sistema operacional). */
+    get mode(): HermesThemeMode;
+    setMode(mode: HermesThemeMode): void;
+    setTheme(theme: HermesThemeName): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ThemeService, [null, null, null, { optional: true; }]>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ThemeService>;
+}
+
+/**
+ * Wrapper fino sobre `HermesThemeService.family`/`setFamily`/`families` — substitui o
+ * `applyThemePreset`/`PRESETS` do addon `theme-builder` antigo (que já expunha só paletas
+ * FIXAS pré-definidas, nunca cor arbitrária digitada pelo usuário: o spine antigo usava só
+ * essa lista fixa, então trocar para `family` do DS novo é a mesma mecânica de UX — grid de
+ * paletas prontas —, só muda o catálogo de opções e como cada uma deriva claro/escuro
+ * internamente). Persistência entre abas já vem de `HermesThemeService` (localStorage).
+ */
+declare class ThemePresetService {
+    private readonly hermesTheme;
+    get current(): HermesFamily;
+    get families(): readonly HermesFamily[];
+    setPreset(family: HermesFamily): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ThemePresetService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ThemePresetService>;
+}
+
+interface DensitySetting {
+    name: HermesDensity;
+}
+/**
+ * Wrapper fino sobre `HermesThemeService.density`/`setDensity` (já persistido em
+ * `localStorage` pelo DS novo) — mantém o nome/API do spine antigo e adiciona a
+ * sincronização entre abas via `BroadcastChannel` que `HermesThemeService` não tem
+ * (é por-aba). Ver `ThemeService` (mesmo padrão, mesmo motivo).
+ */
+declare class DensityService {
+    private platformId;
+    private zone;
+    private readonly hermesTheme;
+    private channel;
+    private readonly channelName;
+    constructor(platformId: Object, zone: NgZone, config: SpineConfig | null);
+    get current(): DensitySetting;
+    setDensity(density: HermesDensity): void;
+    /** Só alterna entre comfortable e compact — mesmo comportamento do spine antigo
+     *  (que chamava a densidade não-compacta de "regular"; o DS novo chama de "comfortable"). */
+    toggleDensity(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DensityService, [null, null, { optional: true; }]>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DensityService>;
+}
+
+/** Registra o catálogo de ícones inteiro — o spine (header/sidebar/navegação/modal/onboarding)
+ * usa ícones de várias origens (shield, pencil, trash, floppy, chevrons...) que não vêm
+ * embutidos de graça (os componentes do hermes só registram os ícones que eles próprios usam); sem isto, todo `hm-icon` do spine cai
+ * silenciosamente no hambúrguer de fallback pra qualquer app que consuma este pacote. */
+declare function provideUi(config?: SpineConfig): EnvironmentProviders;
+
+/** Dados do `package.json` do app (nome, versão, dependências...), passados em
+ * `provideShell({ packageInfo })`. Mora no pacote raiz (e não em `@trismegisto/spine/shell`, onde
+ * nasceu) porque o painel de configurações do `@trismegisto/spine/layout` também lê — e o shell
+ * importa o layout, então o layout importar o shell fecharia um ciclo. O shell reexporta o
+ * MESMO token (mesma instância), então quem importava de lá continua funcionando. */
+interface PackageInfo {
+    name?: string;
+    version?: string;
+    description?: string;
+    license?: string;
+    buildDate?: string;
+    environment?: string;
+    repository?: {
+        url?: string;
+    };
+    developer?: {
+        name?: string;
+        homepage?: string;
+        email?: string;
+    };
+    docs?: string;
+    issues?: string;
+    dependencies?: Record<string, string>;
+    [key: string]: any;
+}
+declare const APP_PACKAGE_INFO: InjectionToken<PackageInfo>;
+
+/**
+ * Preferências do usuário que não são de tema (tema/família/densidade continuam no
+ * `HermesThemeService`; modo do menu lateral no `HermesSidebarService`): fuso horário, idioma e o
+ * interruptor dos atalhos de tecla única (WCAG 2.1.4) do `HermesShortcutService`.
+ *
+ * Por enquanto vive no navegador (localStorage, sincronizado entre abas). A sincronização com o
+ * servidor (argos-admin `/me/preferences`) entra depois sem mudar esta API: quem lê `timeZone()`
+ * não precisa saber de onde o valor veio.
+ */
+declare class SpinePreferencesService {
+    private readonly browser;
+    private readonly zone;
+    private readonly ns;
+    private readonly timeZoneKey;
+    private readonly languageKey;
+    private readonly characterKeysKey;
+    private readonly shortcuts;
+    private readonly i18n;
+    /** Idioma com que o app subiu (`provideHermesI18n`) — vale quando a pessoa não escolheu nenhum. */
+    readonly appLanguage: string;
+    private readonly channel;
+    /** Fuso escolhido (IANA, ex.: "America/Sao_Paulo"). Vazio = o do navegador. */
+    readonly timeZone: i0.WritableSignal<string>;
+    /** Fuso do navegador, para mostrar ao lado da opção "automático". */
+    readonly browserTimeZone: string;
+    /** O fuso que vale de fato: o escolhido ou, sem escolha, o do navegador. */
+    readonly effectiveTimeZone: i0.Signal<string>;
+    /** Idioma escolhido (BCP 47: `pt-BR`, `en`, `es`). Vazio = o padrão do app. */
+    readonly language: i0.WritableSignal<string>;
+    /**
+     * Atalhos de tecla única (`?`, `G H`) ligados — WCAG 2.1.4. Guardado por app (`'on'`/`'off'`);
+     * sem escolha salva, vale o padrão do `HermesShortcutService` (`provideHermesShortcuts`).
+     */
+    readonly characterKeys: i0.WritableSignal<boolean>;
+    /** Idiomas oferecidos na configuração, cada um com o nome no próprio idioma (padrão de mercado). */
+    readonly languages: readonly {
+        readonly value: string;
+        readonly label: string;
+    }[];
+    constructor();
+    /** Liga/desliga os atalhos de tecla única na hora, guarda e avisa as outras abas. */
+    setCharacterKeys(enabled: boolean): void;
+    private saveCharacterKeys;
+    private applyCharacterKeys;
+    private readCharacterKeys;
+    /** Troca o idioma da lib e do spine na hora, guarda e avisa as outras abas. Vazio = padrão do app. */
+    setLanguage(value: string): void;
+    private applyLanguage;
+    setTimeZone(value: string): void;
+    /** Todos os fusos IANA que o navegador conhece (vazio em navegador antigo). */
+    supportedTimeZones(): string[];
+    private read;
+    private write;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SpinePreferencesService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SpinePreferencesService>;
+}
+
+/**
+ * Base da API do argos-admin-server (ex.: `https://exemplo.com.br/argos/admin/api`) —
+ * recursos do próprio usuário (`/me/*`, hoje os tokens de aplicação) que o painel de
+ * configurações usa. Quem chama `provideAutoService({ adminApi })` já fornece este token (é a
+ * mesma URL); um app sem auto-service fornece direto, ou fica sem as partes do painel que
+ * dependem do servidor (elas se escondem em vez de quebrar).
+ */
+declare const SPINE_ADMIN_API: InjectionToken<string>;
+
+/** A page remembered by the shell, either as a favorite or as a recent visit. */
+interface QuickAccessItem {
+    readonly id: string;
+    readonly icon: string;
+    readonly displayName: string;
+    readonly redirect: string;
+    /** Ancestor labels, top-down. `[]` = top-level page; absent = stored by an older version. */
+    readonly trail?: readonly string[];
+}
+/**
+ * Favorites and recently visited pages, shared by every consumer in the app (page bar, home screen)
+ * and persisted per client in `localStorage`.
+ */
+declare class SpineQuickAccessService {
+    private readonly browser;
+    private readonly favoritesKey;
+    private readonly recentsKey;
+    private readonly favoriteList;
+    private readonly recentList;
+    readonly favorites: i0.Signal<readonly QuickAccessItem[]>;
+    readonly recents: i0.Signal<readonly QuickAccessItem[]>;
+    private readonly favoriteSet;
+    constructor(config: SpineConfig | null);
+    isFavorite(id: string | null | undefined): boolean;
+    toggleFavorite(item: QuickAccessItem): void;
+    recordVisit(item: QuickAccessItem): void;
+    forgetRecent(id: string): void;
+    private commit;
+    private load;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SpineQuickAccessService, [{ optional: true; }]>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SpineQuickAccessService>;
+}
+
+/**
+ * O mínimo do `environment` de um app que dá pra derivar em tempo de execução. Estrutural de
+ * propósito (não importa o `Environment` de nenhum app): serve pra todos.
+ */
+interface RuntimeEnvironmentShape {
+    authorizationServer: {
+        authority?: string;
+        redirectUrl?: string;
+        postLogoutRedirectUri?: string;
+    };
+    graphql?: Record<string, {
+        http: string;
+        ws?: string;
+    }>;
+}
+interface RuntimeEnvironmentInfo {
+    /** `window.location.origin`. */
+    readonly origin: string;
+    /** Prefixo do app (base href sem a barra final), ex.: `/prometeu`. Vazio na raiz. */
+    readonly basePath: string;
+    /** Sem porta na URL: o app está atrás do proxy (Caddy), não na porta direta do container. */
+    readonly behindProxy: boolean;
+    /** URL ainda sem valor real (vazia ou `CHANGE_ME`) — a única que pode ser derivada. */
+    readonly unset: (url: string | undefined) => boolean;
+}
+/**
+ * Ajusta o `environment` ao lugar onde o app está rodando — chamar no `main.ts`, ANTES do
+ * `bootstrapApplication`. Antes cada app tinha a sua versão (só o Hefesto derivava as URLs); agora a
+ * regra é uma só:
+ *
+ * - **Sempre:** `redirectUrl`/`postLogoutRedirectUri` = origem + prefixo atual. O servidor exige
+ *   `redirect_uri` absoluto e o app pode viver sob um prefixo (`/prometeu`); um valor fixo no
+ *   environment não bate com a rota real e o callback nunca casa.
+ * - **Atrás do proxy (sem porta na URL):**
+ *   - `authority` = `<origem>/argos` — mesmo domínio da página, senão o cookie de sessão sai com o
+ *     escopo errado e a sessão não persiste (bug já visto no argos);
+ *   - cada endpoint GraphQL **ainda sem valor real** vira `<origem><prefixo>/graphql` (HTTP e WS —
+ *     o WebSocket atende no mesmo caminho do HTTP em todo GraphQL do astra). URL explícita no
+ *     environment sempre ganha: em prod o front pode estar num domínio e o backend em outro.
+ *
+ * Devolve `origin`/`basePath`/`behindProxy`/`unset` pro que for específico do app (ex.: a URL da
+ * API REST do hefesto-server).
+ */
+declare function applyRuntimeEnvironment(environment: RuntimeEnvironmentShape): RuntimeEnvironmentInfo;
+
+/**
+ * Ilustração gerada pelo spine, nas cores do tema em vigor: o ícone da novidade no centro e,
+ * opcionalmente, selos (ícone + rótulo) orbitando em volta. Ícones são nomes do @trismegisto/icons.
+ */
+interface SpineNewsIllustration {
+    readonly icon: string;
+    readonly satellites?: readonly {
+        readonly icon: string;
+        readonly label: string;
+    }[];
+}
+/** Um slide do painel de novidades. */
+interface SpineNewsSlide {
+    readonly title: string;
+    readonly text: string;
+    /** Ilustração desenhada pelo spine (recomendado — acompanha tema claro/escuro e família). */
+    readonly illustration?: SpineNewsIllustration;
+    /** Imagem própria (caminho em `assets/` do app); vence a `illustration`. Sem nenhuma das duas, o
+     * slide é só texto. */
+    readonly image?: string;
+    /** Descrição da imagem pra quem não a vê. Vazia marca a imagem como decorativa. */
+    readonly alt?: string;
+}
+/**
+ * Uma novidade do app: aparece sozinha uma vez por navegador, depois do tour de boas-vindas, e fica
+ * marcada como vista ao ser exibida.
+ */
+interface SpineNewsItem {
+    /** Chave estável. Trocar o id faz a novidade aparecer de novo para todo mundo. */
+    readonly id: string;
+    readonly slides: readonly SpineNewsSlide[];
+    /** Data (AAAA-MM-DD) a partir da qual a novidade deixa de ser oferecida. Opcional. */
+    readonly until?: string;
+}
+/** Multi: cada chamada de `provideSpineNews` contribui com uma lista. */
+declare const SPINE_NEWS: InjectionToken<readonly (readonly SpineNewsItem[])[]>;
+/**
+ * Registra as novidades do app (no `app.config.ts`, junto do `provideUi`). Ficam no código, no
+ * mesmo commit da funcionalidade que anunciam. A ordem da lista é a ordem dos slides.
+ *
+ * ```ts
+ * provideSpineNews([
+ *   { id: 'build-com-versao-2026-09', slides: [{ title: 'Build direto da linha', text: '…' }] },
+ * ]),
+ * ```
+ */
+declare function provideSpineNews(items: readonly SpineNewsItem[]): EnvironmentProviders;
+
+/**
+ * Textos do próprio spine (cabeçalho, navegação, configurações, tour, telas do auto-serviço…), no
+ * mesmo formato do `HermesMessages` da lib: seção → chave, parâmetros nomeados (`{name}`) e plural
+ * por `PluralMessage`. Alguns textos levam marcação simples (`<b>`, `<strong>`, `<code>`) e são
+ * exibidos com `[innerHTML]` — estão indicados no comentário.
+ *
+ * O idioma ativo é o do `HermesI18nService` da lib: `setLocale` troca a lib e o spine juntos.
+ */
+interface SpineMessages {
+    meta: {
+        locale: string;
+    };
+    header: {
+        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;
+        /** `{term}` = o que foi digitado. */
+        noResults: string;
+    };
+    navigation: {
+        back: string;
+        home: string;
+        favorite: string;
+        unfavorite: string;
+        copyLink: string;
+        linkCopied: string;
+    };
+    sidebar: {
+        modules: string;
+        /** `{module}` = nome do módulo aberto. */
+        moduleNavigation: string;
+        apps: string;
+    };
+    pageBar: {
+        favorite: string;
+        unfavorite: string;
+        copyLink: string;
+        linkCopied: string;
+        docs: string;
+        trail: string;
+    };
+    pagePanel: {
+        notFoundTitle: string;
+        notFoundText: string;
+    };
+    docs: {
+        heading: string;
+        index: string;
+        search: string;
+        noMatch: string;
+        empty: string;
+        view: string;
+        usage: string;
+        technical: string;
+        loading: string;
+        loadError: string;
+        /** Convite no lado da leitura enquanto nenhuma página do índice foi aberta. */
+        invite: string;
+    };
+    news: {
+        heading: string;
+        carousel: string;
+        dismiss: string;
+    };
+    /** Tour guiado. As descrições (`*Text`) levam `<b>` e são exibidas com `[innerHTML]`. */
+    tour: {
+        /** `{current}` de `{total}`. */
+        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;
+    };
+    shortcuts: {
+        heading: string;
+        /** `{key}` vira a tecla desenhada como chip. */
+        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;
+    };
+    settings: {
+        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;
+        /** `{language}` = idioma padrão do app. */
+        languageAuto: string;
+        timeZone: string;
+        timeZoneKeywords: string;
+        /** `{now}` = data e hora agora no fuso escolhido. */
+        timeZoneHint: string;
+        /** `{zone}` = fuso detectado no navegador. */
+        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;
+        /** `{time}` = hora. */
+        sessionExpired: string;
+        /** `{minutes}` e `{time}`. */
+        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;
+    };
+    /** Rótulos do texto que "Informações para suporte" copia. */
+    support: {
+        application: string;
+        version: string;
+        build: string;
+        environment: string;
+        page: string;
+        browser: string;
+        screen: string;
+        theme: string;
+        /** `{theme}`, `{mode}`, `{family}`, `{density}`, `{font}`. */
+        themeValue: string;
+        timeZone: string;
+        accessLevel: string;
+        date: string;
+    };
+    appTokens: {
+        unavailable: string;
+        /** `{name}`. */
+        created: string;
+        /** `[innerHTML]`; `{date}`. */
+        sendHeader: string;
+        copyToken: string;
+        saved: string;
+        loading: string;
+        /** `{date}`. */
+        expiredOn: string;
+        expiresOn: string;
+        lastUsed: string;
+        never: string;
+        revoke: string;
+        confirmRevoke: string;
+        empty: string;
+        noBadges: string;
+        /** `[innerHTML]`; `{name}` = aplicação. */
+        appOnly: string;
+        accessLevel: string;
+        name: string;
+        namePlaceholder: string;
+        nameRequired: string;
+        nameMax: string;
+        validity: string;
+        days30: string;
+        days90: string;
+        months6: string;
+        year1: string;
+        create: string;
+        cancel: string;
+        newToken: string;
+        /** `{valid}` de `{max}`. */
+        validCount: string;
+        limit: string;
+        loadError: string;
+        badgesError: string;
+        createError: string;
+        copied: string;
+        copyFailed: string;
+        /** `{name}`. */
+        revoked: string;
+        revokeError: string;
+    };
+    notification: {
+        genericError: string;
+    };
+    graphql: {
+        /** Envelope ausente: o resolver estourou e o campo voltou `null` (`unwrap`). */
+        noResponse: string;
+        serviceFailure: string;
+        done: string;
+        failed: string;
+    };
+    /** Telas de acesso do shell (`/blocked`, `/no-permission`). */
+    access: {
+        blockedText: string;
+        blockedAction: string;
+        noRightsText: string;
+    };
+    /**
+     * Retorno do login (`/callback`) e aviso de conexão do shell (`spine-connection-banner`), sobre o
+     * `connectionState$`/`reauthorizationRequired$` do `@orfeu/angular`. A sessão nunca cai por isso.
+     */
+    session: {
+        /** Argos inalcançável (sem acesso à rede, servidor fora do ar): a sessão continua, a lib tenta de novo sozinha. */
+        offline: string;
+        reconnecting: string;
+        reauthorizing: string;
+        /** O Argos recusou a renovação e a reautorização automática não aconteceu: a pessoa decide. */
+        reauthorizationRequired: string;
+        signInAgain: string;
+        callbackFailedHeading: string;
+        callbackFailedText: string;
+    };
+    routing: {
+        notPublished: string;
+        /** `{code}` = id da rota. */
+        notPublishedCode: string;
+    };
+    home: {
+        noAccessTitle: string;
+        noAccessText: string;
+        yourScreens: string;
+        modules: string;
+        privileged: string;
+        recent: string;
+        recentCaption: string;
+        screenCount: PluralMessage;
+        /** `{name}`. */
+        favorite: string;
+        unfavorite: string;
+        favorites: string;
+        navigate: string;
+        settings: string;
+        tools: string;
+        systemDocs: string;
+        colScreen: string;
+        colWhere: string;
+        colFavorite: string;
+        noModule: string;
+    };
+    /** Telas do auto-serviço. Textos com `[innerHTML]` indicados. */
+    autoService: {
+        loading: string;
+        cancel: string;
+        save: string;
+        create: string;
+        edit: string;
+        remove: string;
+        search: string;
+        active: string;
+        inactive: string;
+        confirmChanges: string;
+        appsTitle: string;
+        appsIntro: string;
+        clientTitle: string;
+        clientIntro: string;
+        /** Nome acessível da faixa de abas da tela Cliente (Rotas/Roteadores/Acesso). */
+        clientSections: string;
+        tabRoutes: string;
+        tabRouters: string;
+        tabAccess: string;
+        /** `[innerHTML]`. */
+        noClients: string;
+        pickClient: string;
+        groupsTitle: string;
+        groupsIntro: string;
+        /** @deprecated não é mais exibido (o auto-serviço não repete título/explicação que a barra da página e a aba já dão). */
+        groupsFixed: string;
+        pickGroup: string;
+        noDescription: string;
+        /** @deprecated não é mais exibido (o auto-serviço não repete título/explicação que a barra da página e a aba já dão). */
+        pickGroupHint: string;
+        manageMembers: string;
+        membersCaption: string;
+        noMembers: string;
+        colUser: string;
+        colMemberSince: string;
+        /** `{group}`. */
+        membersHeading: string;
+        addUser: string;
+        userSearch: string;
+        role: string;
+        pickRole: string;
+        add: string;
+        suggestions: string;
+        moreSuggestions: string;
+        /** `{group}`. */
+        membersOf: string;
+        noMembersShort: string;
+        newMember: string;
+        /** `{user}`. */
+        addedBy: string;
+        removal: string;
+        removalEmpty: string;
+        undoRemoval: string;
+        saveChanges: string;
+        colRole: string;
+        colAddedAt: string;
+        newAccess: string;
+        newAccessHeading: string;
+        accessCaption: string;
+        noAccess: string;
+        colGroup: string;
+        colBadge: string;
+        manageRoutes: string;
+        group: string;
+        /** `{group}`. */
+        routesOf: string;
+        /** `[innerHTML]`; `{badge}`. */
+        guardsHint: string;
+        noPrivateRoutes: string;
+        register: string;
+        appsSearchIntro: string;
+        secretCreated: string;
+        pickApp: string;
+        disable: string;
+        enable: string;
+        delete: string;
+        /** Nome acessível da faixa de abas da aplicação escolhida (Operações/Acessos). */
+        appSections: string;
+        tabOperations: string;
+        tabAccesses: string;
+        editApp: string;
+        newApp: string;
+        name: string;
+        grants: string;
+        appAccessCaption: string;
+        noAppAccess: string;
+        colType: string;
+        manageOperations: string;
+        /** `{group}`. */
+        operationsOf: string;
+        noOperations: string;
+        operationsCaption: string;
+        colIdentifier: string;
+        colMethod: string;
+        colLevel: string;
+        colDescription: string;
+        colAllowedGroups: string;
+        groupCount: PluralMessage;
+        /** @deprecated não é mais exibido (o auto-serviço não repete título/explicação que a barra da página e a aba já dão). */
+        routersTitle: string;
+        newRouter: string;
+        routersCaption: string;
+        noRouters: string;
+        private: string;
+        public: string;
+        editRouter: string;
+        page: string;
+        hierarchy: string;
+        levelHeader: string;
+        levelNavigation: string;
+        levelMenu: string;
+        levelItem: string;
+        levelSubmenu: string;
+        privateHint: string;
+        routerDescription: string;
+        routerDescriptionHint: string;
+        colPage: string;
+        colBuiltPath: string;
+        colVisibility: string;
+        /** @deprecated não é mais exibido (o auto-serviço não repete título/explicação que a barra da página e a aba já dão). */
+        routesTitle: string;
+        newRoute: string;
+        routesCaption: string;
+        noRoutes: string;
+        editRoute: string;
+        internalName: string;
+        displayName: string;
+        icon: string;
+        iconPlaceholder: string;
+        path: string;
+        info: string;
+        excludable: string;
+        /** Dica do "Excluível" ao editar rota protegida: o auto-serviço não libera, só o Argos central. */
+        excludableLocked: string;
+        /** Selo da rota/roteador que veio de template (não editável pelo auto-serviço) e a explicação dele. */
+        templateTag: string;
+        templateLocked: string;
+        /** Exemplo e regra do caminho: um trecho só do endereço (o "/" entre níveis é o roteador que põe). */
+        pathPlaceholder: string;
+        pathHint: string;
+        pathInvalid: string;
+        colExcludable: string;
+        excludableYes: string;
+        excludableNo: string;
+        colName: string;
+        colDisplay: string;
+        colIcon: string;
+        colPath: string;
+    };
+    /**
+     * Tela "Auditoria" (`@trismegisto/spine/audit`, `SpineAuditComponent`): a mesma nos dois escopos — o
+     * auto-serviço (apps do projeto do client) e o painel central do argos admin (`scope: 'admin'`). O nome
+     * da chave ficou do tempo em que só o auto-serviço a tinha.
+     */
+    autoServiceAudit: {
+        title: string;
+        intro: string;
+        /** Aba da tela de Aplicações que abre a auditoria ali mesmo. */
+        tabApps: string;
+        period: string;
+        periodLastHour: string;
+        period24h: string;
+        period7d: string;
+        period30d: string;
+        /** Aviso quando o período vem das datas da faixa de filtros (a escolha rápida fica sem efeito). */
+        periodFromFilters: string;
+        filters: string;
+        filterDates: string;
+        filterApp: string;
+        filterUser: string;
+        filterOperation: string;
+        filterMethod: string;
+        filterOutcome: string;
+        filterEntry: string;
+        userPlaceholder: string;
+        operationPlaceholder: string;
+        methodRead: string;
+        methodWrite: string;
+        methodDelete: string;
+        methodStream: string;
+        outcomeSuccess: string;
+        outcomeFailure: string;
+        outcomeDenied: string;
+        kpiTotal: string;
+        kpiTotalDescription: string;
+        kpiFailures: string;
+        kpiDenied: string;
+        /** `{percent}`. */
+        kpiShare: string;
+        kpis: string;
+        timeline: string;
+        /** `{from}`, `{to}`. */
+        timelineSummary: string;
+        /** `{time}`, `{total}`, `{failures}`, `{denied}`. */
+        bucketSummary: string;
+        timelineEmpty: string;
+        topOperations: string;
+        topUsers: string;
+        topApps: string;
+        noTop: string;
+        eventCount: PluralMessage;
+        failureCount: PluralMessage;
+        deniedCount: PluralMessage;
+        /** `{name}`. */
+        filterBy: string;
+        eventsCaption: string;
+        colWhen: string;
+        colApp: string;
+        colUser: string;
+        colOperation: string;
+        colMethod: string;
+        colOutcome: string;
+        colStatus: string;
+        colDuration: string;
+        /** `{ms}`. */
+        durationMs: string;
+        /** Rodapé da tabela: o que vem depois da contagem ("1 - 50 de 120 {pageItems}"). */
+        pageItems: string;
+        /** Rodapé da tabela: rótulo do seletor de eventos por página. */
+        pageSize: string;
+        /** Falha ao trocar de página (o resumo e a página anterior continuam). */
+        pageError: string;
+        loading: string;
+        emptyTitle: string;
+        emptyText: string;
+        clearFilters: string;
+        errorTitle: string;
+        errorText: string;
+        retry: string;
+        rangeTooLarge: string;
+        forbidden: string;
+        anonymous: string;
+        detailHeading: string;
+        detailLoading: string;
+        detailError: string;
+        fieldWhen: string;
+        fieldApp: string;
+        fieldUser: string;
+        fieldActor: string;
+        fieldIp: string;
+        fieldOperation: string;
+        fieldIdentifier: string;
+        fieldMethod: string;
+        fieldLevel: string;
+        fieldPermission: string;
+        fieldOutcome: string;
+        fieldStatus: string;
+        fieldDuration: string;
+        fieldRoute: string;
+        fieldTarget: string;
+        fieldOrigin: string;
+        originEntry: string;
+        originInternal: string;
+        fieldTrace: string;
+        fieldEventId: string;
+        fieldMessage: string;
+        fieldReceivedAt: string;
+        fieldInstance: string;
+        fieldSdk: string;
+        fieldDetails: string;
+        viewTrace: string;
+        traceHeading: string;
+        traceLoading: string;
+        traceError: string;
+        traceEmpty: string;
+        traceHidden: PluralMessage;
+        traceCurrent: string;
+        /** `{operation}`, `{time}`. */
+        openTraceEvent: string;
+        /** Introdução da tela no escopo `admin` (painel central, todos os apps). */
+        introAdmin: string;
+        period6h: string;
+        refresh: string;
+        autoRefresh: string;
+        /** `{time}`. */
+        updatedAt: string;
+        /** Rótulo do indicador enquanto a tabela/rankings recarregam (as linhas atuais continuam à vista). */
+        updating: string;
+        filterUserId: string;
+        filterLevel: string;
+        filterPermission: string;
+        filterActor: string;
+        filterStatus: string;
+        filterTrace: string;
+        userIdPlaceholder: string;
+        statusPlaceholder: string;
+        tracePlaceholder: string;
+        levelPublic: string;
+        levelPrivate: string;
+        levelProtected: string;
+        levelOptional: string;
+        permissionAllowed: string;
+        permissionForbidden: string;
+        permissionUnauthorized: string;
+        permissionPublic: string;
+        actorUser: string;
+        actorAppToken: string;
+        actorApiToken: string;
+        actorPublic: string;
+        actorUnauthenticated: string;
+        /** Escopo `admin`: a conta não tem as operações `admin:audit:*`. */
+        forbiddenAdmin: string;
+        /** 400 `invalid_filter` do servidor. `{detail}` = explicação dele. */
+        invalidFilter: string;
+        /** Descrição dos KPIs clicáveis (falhas/negados viram filtro). */
+        kpiFilterHint: string;
+        /** Rodapé dos rankings: `{from}`, `{to}`, `{total}`. */
+        topsRange: string;
+        /** `{name}` = título do ranking. */
+        topsPrevious: string;
+        /** `{name}` = título do ranking. */
+        topsNext: string;
+        topsError: string;
+        filterByTrace: string;
+        /** Rótulo do alternador "Ações | Eventos". */
+        unitLabel: string;
+        unitActions: string;
+        unitEvents: string;
+        kpiTotalActions: string;
+        kpiTotalActionsDescription: string;
+        /** `{from}`, `{to}`. */
+        timelineSummaryActions: string;
+        /** `{time}`, `{total}`, `{failures}`, `{denied}`. */
+        bucketSummaryActions: string;
+        timelineEmptyActions: string;
+        actionsCaption: string;
+        pageItemsActions: string;
+        pageErrorActions: string;
+        emptyTitleActions: string;
+        /** Coluna com a quantidade de spans (registros) da ação. */
+        colSpans: string;
+        /** Dica da célula de spans: `{apps}` = aplicações envolvidas. */
+        spansApps: string;
+        /** Spans de fora do escopo do client: contados à parte. */
+        spansHidden: PluralMessage;
+        actionDetailHeading: string;
+        /** Ação sem a entrada (entry) no período: começa por uma chamada entre aplicações. */
+        orphanNote: string;
+        orphanTag: string;
+        spansHeading: string;
+        /** Linha do tempo dos spans: `{count}` spans em `{duration}`. */
+        spansSummary: string;
+        /** `{app}`, `{operation}`, `{outcome}`, `{offset}`, `{duration}`. */
+        spanRow: string;
+    };
+}
+declare const SPINE_MESSAGES_PT_BR: SpineMessages;
+
+declare const SPINE_MESSAGES_EN: SpineMessages;
+
+declare const SPINE_MESSAGES_ES: SpineMessages;
+
+type SpineMessagesOverride = CatalogOverride<SpineMessages>;
+interface SpineI18nConfig {
+    /** Catálogos extras ou substitutos, por idioma (mesmas chaves do `SpineMessages`). */
+    readonly catalogs?: Readonly<Record<string, SpineMessages>>;
+    /** Textos avulsos sobrescritos por cima do catálogo ativo, em qualquer idioma. */
+    readonly override?: SpineMessagesOverride;
+}
+declare const SPINE_I18N_CONFIG: InjectionToken<SpineI18nConfig>;
+/**
+ * Textos do spine no idioma ativo para quem não tem injeção (funções puras como o `unwrap` do
+ * `@trismegisto/spine/graphql`, chamado em qualquer lugar do app). É o mesmo catálogo vivo do
+ * `SPINE_MESSAGES` — segue `setLocale` — assim que o shell o injetou; antes disso, o pt-BR.
+ */
+declare function currentSpineMessages(): SpineMessages;
+/**
+ * Textos do spine no idioma ativo da lib (`HermesI18nService.locale`): uma troca de idioma com
+ * `setLocale` atualiza a lib e o spine juntos, sem recarregar. Leitura igual à do `HERMES_MESSAGES`
+ * (`inject(SPINE_MESSAGES).header.settings`), viva também em template.
+ */
+declare const SPINE_MESSAGES: InjectionToken<SpineMessages>;
+/** Sobrescreve textos do spine e/ou acrescenta idiomas. O idioma em si vem de `provideHermesI18n`. */
+declare function provideSpineMessages(config: SpineI18nConfig): Provider;
+
+export { APP_PACKAGE_INFO, DensityService, HERMES_DS_IMPORTS, SPINE_ADMIN_API, SPINE_CONFIG, SPINE_DEFAULT_LOGO, SPINE_I18N_CONFIG, SPINE_MESSAGES, SPINE_MESSAGES_EN, SPINE_MESSAGES_ES, SPINE_MESSAGES_PT_BR, SPINE_NEWS, SpinePreferencesService, SpineQuickAccessService, ThemePresetService, ThemeService, applyRuntimeEnvironment, applySpineFavicon, currentSpineMessages, mergeRouteTree, provideSpineMessages, provideSpineNews, provideUi, resolveSpineLogo, routerIdOf, spineRoutesOf };
+export type { DensitySetting, PackageInfo, QuickAccessItem, Route, RuntimeEnvironmentInfo, RuntimeEnvironmentShape, SpineConfig, SpineI18nConfig, SpineLogoConfig, SpineLogoSources, SpineMessages, SpineMessagesOverride, SpineNewsIllustration, SpineNewsItem, SpineNewsSlide };
+//# sourceMappingURL=trismegisto-spine.d.ts.map