@trismegisto/spine 3.3.2 → 3.3.3

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

@@ -1,5 +1,5 @@
 import * as _angular_core from '@angular/core';
-import { OnDestroy, OnInit, InjectionToken, Type, Provider, TemplateRef } from '@angular/core';
+import { OnDestroy, InjectionToken, Signal, OnInit, Type, Provider, TemplateRef, DestroyRef, EnvironmentProviders } from '@angular/core';
 import { Router } from '@angular/router';
 import * as _trismegisto_spine from '@trismegisto/spine';
 import { Route, ThemeService, ThemePresetService, DensityService, SpineConfig, SpinePreferencesService, SpineHourCyclePreference, SpineStartPagePreference, SpineNoticeType, SpineMcpServer, SpineFeatures } from '@trismegisto/spine';
@@ -239,12 +239,85 @@ declare class ShortcutService implements OnDestroy {
     static ɵprov: _angular_core.ɵɵInjectableDeclaration<ShortcutService>;
 }
 
+/** Query de uma aba, como objeto (o último valor de cada nome). */
+type SpineTabParams = Readonly<Record<string, string>>;
+/**
+ * A aba do workspace em que a tela está montada (`inject(SPINE_TAB)` na tela). Com o keepAlive, várias abas da MESMA
+ * tela ficam vivas ao mesmo tempo (um registro por aba); `window.location`/`ActivatedRoute` só refletem a aba do
+ * painel focado. Aqui cada tela lê e escreve a SUA.
+ *
+ * ```ts
+ * private readonly tab = inject(SPINE_TAB, { optional: true });
+ * readonly pedido = computed(() => this.tab?.params()['pedido'] ?? null);
+ * // trocar a seção: a mesma aba, sem recriar a tela (e o endereço do navegador acompanha, se a aba está à vista)
+ * this.tab?.navigate({ queryParams: { secao: 'itens' } });
+ * // o nome do registro no lugar do nome da rota
+ * this.tab?.setLabel('Pedido 123');
+ * ```
+ */
+interface SpineTab {
+    /** Identidade estável da aba (o caminho, ou o caminho com os parâmetros que a identificam). */
+    readonly id: Signal<string>;
+    /** O painel em que a aba está agora. */
+    readonly panelId: Signal<string>;
+    /** O endereço atual da aba, com a query. */
+    readonly url: Signal<string>;
+    /** A query da aba. */
+    readonly params: Signal<SpineTabParams>;
+    /** A aba é a visível do painel focado (é a que o endereço do navegador mostra). */
+    readonly focused: Signal<boolean>;
+    /** Troca o nome (e, se vier, o ícone) da aba; persiste no F5 nas abas com parâmetros. */
+    setLabel(label: string, icon?: string): void;
+    /**
+     * Muda o endereço da própria aba. Com `queryParams`, mescla na query atual (`merge`, padrão) ou troca a query
+     * inteira (`merge: false`); `null`/`undefined` tira o parâmetro. Mesma tela: só a query muda, a tela não é recriada.
+     * Outra tela (um caminho diferente): é a navegação no lugar da aba, como um link dentro do painel.
+     */
+    navigate(target: string | {
+        queryParams: Readonly<Record<string, string | number | boolean | null | undefined>>;
+        merge?: boolean;
+    }): void;
+}
+declare const SPINE_TAB: InjectionToken<SpineTab>;
+
+/** O caminho de um endereço (sem query nem fragmento). */
+declare function spinePathOf(url: string): string;
+/** A query de um endereço, como objeto. */
+declare function spineParamsOf(url: string): SpineTabParams;
+/** Caminho + query com os nomes em ordem: o mesmo endereço escrito de dois jeitos vira um só (sem o fragmento). */
+declare function spineNormalizeUrl(url: string): string;
+/** Como abrir uma aba pelo app (`openTab`). */
+interface SpineOpenTabOptions {
+    /** Nome da aba (senão, o da rota). A tela pode trocar depois (`SPINE_TAB.setLabel`). */
+    label?: string;
+    icon?: string;
+    /**
+     * Os parâmetros que IDENTIFICAM a aba: com `['dispositivo']`, o mesmo dispositivo em outra seção reaproveita a aba
+     * aberta, e trocar a seção dentro dela não abre outra. Sem `match`, todos os parâmetros do endereço identificam.
+     */
+    match?: readonly string[];
+    /** Abre num painel novo ao lado do focado (para comparar), em vez de no próprio painel focado. */
+    beside?: boolean;
+}
 /**
  * Dono do `WorkspaceStore` do shell — mesmo padrão do `WorkspaceNavService` do docs/website
  * (`packages/hermes-ui/docs/website/src/app/workspace-nav.service.ts`), adaptado pra ler a
  * árvore de rotas do BACKEND (`ViewService.currentView`) em vez de um `page-registry.ts`
  * estático. Cada página visitada vira uma aba, pertencente a um painel; a navegação real do
  * `Router` (routerLink, busca, sidebar) sempre atualiza a aba ativa do painel FOCADO.
+ *
+ * **Dois jeitos de ter aba, que convivem.** A navegação de sempre (menu, links, busca) mantém UMA aba por tela, com o
+ * caminho como `id` — como antes; a query que a tela usa fica guardada no `url` da aba e volta junto quando a pessoa
+ * retorna a ela. E o app pode abrir **abas com parâmetros** (`openTab`): a mesma tela várias vezes, uma por registro
+ * (um pedido, um dispositivo...). Nelas o `id` é a identidade (o caminho com os parâmetros que a identificam) e o `url`
+ * é o endereço atual (com a query que a tela vai mudando).
+ * O keepAlive do workspace acompanha o `id`, então mudar a query da aba não recria a tela. Uma navegação real cai
+ * numa destas, em ordem:
+ * 1. o endereço já é o da aba ativa → nada;
+ * 2. a mesma tela da aba ativa, mantendo os parâmetros que a identificam → só o `url` da aba muda (mesma aba);
+ * 3. outra aba do painel já está nesse endereço → ela é ativada;
+ * 4. senão → a aba ativa passa a ser a da tela nova (o comportamento de sempre).
+ * `openTab` abre (ou foca, em qualquer painel) a aba de um endereço com parâmetros.
  */
 declare class SpineWorkspaceNavService {
     private readonly router;
@@ -258,22 +331,51 @@ declare class SpineWorkspaceNavService {
      *  `viewService.logControl$`/`breadCrumb$` globais (que só existiam porque havia uma página
      *  "atual" só; agora cada painel tem a sua). */
     readonly focusedChain: _angular_core.Signal<Route[] | null>;
-    private lastKnownPath;
+    /** O último endereço que o `Router` mostrou (normalizado, com a query): o `effect` abaixo não navega para ele de novo. */
+    private lastKnownUrl;
     constructor();
+    private activeTab;
+    /** Uma navegação real no painel focado: as quatro regras do comentário da classe. */
+    private followNavigation;
     /**
      * As abas abertas passam a obedecer à view atual: aba de tela que a pessoa não pode mais abrir fecha (e o
      * conteúdo dela é destruído junto); painel que ficaria sem aba nenhuma mostra o Início no lugar; a aba ativa
-     * de cada painel recebe o nome e o ícone da view nova. View vazia (ainda carregando) não fecha nada.
+     * de cada painel recebe o nome e o ícone da view nova (a aba com parâmetros guarda o nome que a tela deu). View
+     * vazia (ainda carregando) não fecha nada.
      */
     reconcileWithView(): void;
     /** Resolve a cadeia de rotas pra uma URL, direto na view atual — sem `Router`, sem `async`
      *  (o componente da folha só é carregado por quem for de fato desenhar o painel). Desce sozinho
      *  por nós organizacionais (com filhos, sem conteúdo próprio) — o rótulo/ícone da aba e o que a
-     *  sidebar/breadcrumb mostram refletem o destino DE VERDADE, não a rota-container clicada. */
+     *  sidebar/breadcrumb mostram refletem o destino DE VERDADE, não a rota-container clicada. A query não
+     *  conta: `ViewService.routePath` a tira. */
     private chainFor;
+    /** A aba de uma tela pelo endereço: o `id` é o caminho; com query, o endereço vai no `url` (a mesma aba da tela). */
     tabFor(url: string): TabItem;
+    /**
+     * Restaura uma aba salva (F5): a rota precisa continuar valendo para a pessoa. A aba com parâmetros volta com o
+     * endereço e o nome que tinha (o nome é o que a tela deu — "RT-MPLS-3046-0001" —, a rota não sabe); as outras
+     * voltam com o nome da rota (que acompanha o idioma).
+     */
+    private restoreTab;
     /** O `+` de um painel: abre a home ali, como um navegador. */
     openNewTab(panelId: string): void;
+    /**
+     * Abre (ou foca) a aba de um endereço com parâmetros — um registro por aba na mesma tela:
+     * `openTab('/vendas/pedidos?pedido=123&secao=itens', { label: 'Pedido 123', match: ['pedido'] })`.
+     * Se alguma aba (em qualquer painel) já tem essa identidade, ela é focada e passa a esse endereço; senão abre uma
+     * no painel focado (ou num painel novo ao lado, com `beside`). Só abre o que a view da pessoa permite (a mesma
+     * regra do menu e do `ViewGuard`); fora dela, não faz nada.
+     */
+    openTab(url: string, options?: SpineOpenTabOptions): void;
+    /** O nome (e o ícone) de uma aba, dado pela tela (`SPINE_TAB.setLabel`). */
+    setTabLabel(panelId: string, tabId: string, label: string, icon?: string): void;
+    /**
+     * A tela muda o endereço da própria aba (`SPINE_TAB.navigate`). A mesma tela, mantendo a identidade: só o `url` da
+     * aba muda (sem recriar a tela) e, se ela é a visível do painel focado, o endereço do navegador acompanha (sem
+     * empilhar histórico). Outra tela: navegação local no painel, como um link dentro dele.
+     */
+    navigateTab(panelId: string, tabId: string, url: string): void;
     /** Navegação LOCAL a um painel específico (usada pelo `PanelLocalLinkDirective`) — troca o
      *  ASSUNTO da aba ativa daquele painel, não empilha uma aba nova. */
     navigateLocally(panelId: string, href: string): void;
@@ -2779,6 +2881,132 @@ declare class SpinePageActionsDirective implements OnDestroy {
     static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SpinePageActionsDirective, "ng-template[spinePageActions]", never, {}, {}, never, never, true, never>;
 }
 
+/** Uma novidade na central de notificações (o sino do cabeçalho). */
+interface SpineInboxItem {
+    /** Único dentro da fonte. */
+    readonly id: string;
+    readonly title: string;
+    /** A novidade em uma linha ("Ana: pode mandar um exemplo?"). */
+    readonly body?: string;
+    /** Quando aconteceu (a novidade mais recente do item): ordena a lista e vira "há 5 min". */
+    readonly at: string | Date;
+    /** Quantas novidades o item junta (mostra "+N" a partir de 2). */
+    readonly count?: number;
+    /** Quem fez: a foto (ou as iniciais) na linha; sem pessoa, o ícone da fonte. */
+    readonly person?: {
+        readonly name: string;
+        readonly picture?: string | null;
+    } | null;
+}
+/**
+ * Uma fonte da central de notificações: o que há de novo PARA a pessoa num recurso (sugestões, aprovações, chamados…).
+ * Não são os toasts (`HermesToastService`/`NotificationService`), que passam: aqui fica até a pessoa ver. Registre com
+ * `provideSpineInboxSource`; o sino só aparece com alguma fonte.
+ */
+interface SpineInboxSource {
+    readonly id: string;
+    /** O nome da fonte ("Sugestões"), acima dos itens dela. */
+    readonly label: string;
+    /** Ícone da fonte (@trismegisto/icons), nos itens sem pessoa. */
+    readonly icon?: string;
+    /** As novidades (as mais recentes, até umas 20) e o total de itens com novidade (o número do sino). */
+    load(): Promise<{
+        readonly items: readonly SpineInboxItem[];
+        readonly total: number;
+    }>;
+    /** A pessoa escolheu o item: marque como visto e abra onde ele está. A central relê depois. */
+    open(item: SpineInboxItem): void | Promise<void>;
+}
+/** As fontes registradas (multi). Uma fábrica pode devolver `null` (recurso desligado): fica de fora. */
+declare const SPINE_INBOX_SOURCES: InjectionToken<readonly (SpineInboxSource | null)[]>;
+/**
+ * Registra uma fonte na central de notificações. A fábrica roda num contexto de injeção (`inject()` vale) e pode
+ * devolver `null` para não registrar nada.
+ *
+ * ```ts
+ * provideSpineInboxSource(() => {
+ *   const api = inject(AprovacoesApi);
+ *   const router = inject(Router);
+ *   return {
+ *     id: 'aprovacoes', label: 'Aprovações', icon: 'check-circle',
+ *     load: async () => { const r = await api.pendentes(); return { total: r.total, items: r.itens.map(toItem) }; },
+ *     open: (item) => void router.navigateByUrl(`/aprovacoes/${item.id}`),
+ *   };
+ * })
+ * ```
+ */
+declare function provideSpineInboxSource(factory: () => SpineInboxSource | null): Provider;
+
+/** Um item na lista do sino, com a fonte dele. */
+interface SpineInboxEntry {
+    /** `fonte:item`, único na lista. */
+    readonly key: string;
+    readonly source: SpineInboxSource;
+    readonly item: SpineInboxItem;
+}
+/** De quanto em quanto tempo a central relê, com a aba do navegador à vista. */
+declare const SPINE_INBOX_POLL_MS = 60000;
+/**
+ * A central de notificações (o sino do cabeçalho): junta as novidades das fontes registradas
+ * (`provideSpineInboxSource`), a mais recente primeiro. Relê enquanto alguém acompanha (`watch`): de minuto em minuto
+ * com a aba à vista e ao voltar para ela. Quem muda o que conta como novidade (ler uma conversa, por exemplo) chama
+ * `refresh()`.
+ */
+declare class SpineInboxService {
+    private readonly browser;
+    private readonly sources;
+    /** Alguma fonte registrada: sem nenhuma, o sino não aparece. */
+    readonly enabled: boolean;
+    readonly entries: _angular_core.WritableSignal<readonly SpineInboxEntry[]>;
+    /** Itens com novidade, somando as fontes (o número do sino). */
+    readonly total: _angular_core.WritableSignal<number>;
+    readonly loading: _angular_core.WritableSignal<boolean>;
+    /** Nenhuma fonte respondeu na última leitura. */
+    readonly failed: _angular_core.WritableSignal<boolean>;
+    private request;
+    private watchers;
+    private timer;
+    private readonly onVisible;
+    /** Relê todas as fontes. Uma fonte que falha não derruba as outras. */
+    refresh(): Promise<void>;
+    /** A pessoa escolheu um item: a fonte abre (e marca como visto); depois a central relê. */
+    open(entry: SpineInboxEntry): Promise<void>;
+    /**
+     * Passa a reler sozinha enquanto `destroyRef` viver (o sino no cabeçalho): lê agora, de minuto em minuto com a aba à
+     * vista e ao voltar para a aba. Vários acompanhando dividem o mesmo relógio.
+     */
+    watch(destroyRef: DestroyRef): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SpineInboxService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<SpineInboxService>;
+}
+
+/**
+ * O sino do cabeçalho: a central de notificações (`SpineInboxService`). O número é quantos itens têm novidade; o
+ * painel lista as novidades das fontes, a mais recente primeiro, e escolher uma abre onde ela está. Sem fonte
+ * registrada, não desenha nada.
+ */
+declare class SpineInboxButtonComponent {
+    protected readonly inbox: SpineInboxService;
+    private readonly messages;
+    protected readonly text: {
+        title: string;
+        button: _trismegisto_primitives.PluralMessage;
+        empty: string;
+        error: string;
+        retry: string;
+        news: _trismegisto_primitives.PluralMessage;
+    };
+    protected readonly buttonLabel: _angular_core.Signal<string>;
+    constructor();
+    protected choose(entry: SpineInboxEntry): void;
+    protected newsText(count: number): string;
+    protected iso(entry: SpineInboxEntry): string;
+    /** "há 5 min", "ontem", "há 3 dias" (Intl, no idioma do catálogo). */
+    protected ago(entry: SpineInboxEntry): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SpineInboxButtonComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SpineInboxButtonComponent, "spine-inbox-button", never, {}, {}, never, never, true, never>;
+}
+
 /** Tipos de sugestão, como o Argos guarda (`web.app_suggestions.kind`). */
 declare const SPINE_SUGGESTION_KINDS: readonly ["melhoria", "nova_funcionalidade", "problema", "outro"];
 type SpineSuggestionKind = (typeof SPINE_SUGGESTION_KINDS)[number];
@@ -2822,10 +3050,7 @@ interface SpineSuggestion {
     kind: SpineSuggestionKind;
     title: string;
     description: string;
-    screen: {
-        path: string | null;
-        label: string | null;
-    };
+    screen: SpineSuggestionScreen;
     status: SpineSuggestionStatus;
     position: number;
     votes: number;
@@ -2838,6 +3063,9 @@ interface SpineSuggestion {
     } | null;
     /** Desde quando está no status atual (o último evento para ele; sem evento, a criação). */
     status_at?: string;
+    /** Com quem está a vez na conversa (null = em dia). */
+    waiting_on?: SpineSuggestionWaiting | null;
+    waiting_since?: string | null;
     created_at: string;
     updated_at: string;
     /** Só no auto-serviço: quem pediu, com a foto (null = pessoa removida). */
@@ -2864,10 +3092,7 @@ interface SpineAppSuggestion {
     title: string;
     /** Texto puro (a descrição inteira, até 4000). */
     description: string;
-    screen: {
-        path: string | null;
-        label: string | null;
-    };
+    screen: SpineSuggestionScreen;
     status: SpineSuggestionStatus;
     votes: number;
     /** Quem consulta apoia. */
@@ -2904,17 +3129,124 @@ interface SpineAppSuggestionsQuery {
 interface SpineSuggestionDraft {
     kind: SpineSuggestionKind;
     title: string;
-    description: string;
+    /** Texto puro (o formato antigo; o servidor ainda aceita). */
+    description?: string;
+    /** A descrição em rich text (o editor do modal); o servidor saneia e deriva o texto puro. */
+    description_html?: string;
+    /** Tela do menu (`router_id` e a rota) ou `new: true` com o nome da tela que ainda não existe em `label`. */
     screen: {
         path: string | null;
         label: string | null;
+        router_id?: string | null;
+        new?: boolean;
     };
 }
+/** Por que a pessoa vê a sugestão (o servidor decide; uma sugestão pode ter vários). */
+declare const SPINE_SUGGESTION_REASONS: readonly ["autor", "relator", "envolvido", "responsavel", "grupo"];
+type SpineSuggestionReason = (typeof SPINE_SUGGESTION_REASONS)[number];
+/** Com quem está a vez na conversa: quem pediu (a equipe respondeu) ou a equipe (quem pediu escreveu). */
+declare const SPINE_SUGGESTION_WAITING: readonly ["solicitante", "responsaveis"];
+type SpineSuggestionWaiting = (typeof SPINE_SUGGESTION_WAITING)[number];
+/** Cor do selo "Aguardando…": a vez de quem pede chama atenção; a da equipe, não. */
+declare const SPINE_SUGGESTION_WAITING_COLORS: Record<SpineSuggestionWaiting, TagColor>;
+declare const SPINE_SUGGESTION_VISIBLE_SORTS: readonly ["activity", "recent", "votes"];
+type SpineSuggestionVisibleSort = (typeof SPINE_SUGGESTION_VISIBLE_SORTS)[number];
+/** A tela de uma sugestão: a do menu (`router_id`, rota e o caminho legível) ou uma nova (`new`, o nome no `label`). */
+interface SpineSuggestionScreen {
+    path: string | null;
+    label: string | null;
+    router_id?: string | null;
+    new?: boolean;
+}
+/**
+ * Uma sugestão que a pessoa VÊ (`/me/suggestions/visible` e o detalhe): as dela, as do grupo dela e as em que ela está
+ * envolvida, com os motivos (`reasons`), se ela pode conversar (`can_comment`, quem tem motivo pessoal) e com quem está
+ * a vez (`waiting_on`).
+ */
+interface SpineVisibleSuggestion {
+    id: string;
+    key: string;
+    kind: SpineSuggestionKind;
+    title: string;
+    description: string;
+    /** A descrição em rich text (saneada pelo servidor); vazia sem descrição. */
+    description_html?: string;
+    screen: SpineSuggestionScreen;
+    status: SpineSuggestionStatus;
+    status_at?: string;
+    votes: number;
+    voted: boolean;
+    mine: boolean;
+    reasons: SpineSuggestionReason[];
+    can_comment: boolean;
+    waiting_on: SpineSuggestionWaiting | null;
+    waiting_since: string | null;
+    comments_count: number;
+    last_comment: {
+        comment: string;
+        created_at: string;
+    } | null;
+    /** Mensagens de outras pessoas que quem consulta ainda não leu. */
+    unread: number;
+    archived: boolean;
+    merged_from: Array<{
+        id: string;
+        key: string;
+        title: string;
+    }>;
+    groups: Array<{
+        id: string;
+        name: string;
+    }>;
+    author: SpineSuggestionPerson | null;
+    assignees: SpineSuggestionPerson[];
+    created_at: string;
+    updated_at: string;
+    last_activity_at?: string;
+}
+/** Contagens do conjunto visível inteiro (sem os filtros), para os filtros rápidos da página. */
+type SpineVisibleCounts = Record<SpineSuggestionReason, number> & {
+    waiting_me: number;
+    unread: number;
+};
+interface SpineVisibleQuery {
+    limit: number;
+    offset: number;
+    reason?: SpineSuggestionReason | '';
+    status?: SpineSuggestionStatus | '';
+    kind?: SpineSuggestionKind | '';
+    waiting?: SpineSuggestionWaiting | '';
+    screen?: string;
+    newScreen?: boolean;
+    q?: string;
+    sort?: SpineSuggestionVisibleSort;
+}
+/** Mensagem da conversa (comentário público): `from_requester` = escrita por quem pediu ou um envolvido. */
+interface SpineSuggestionMessage extends SpineSuggestionComment {
+    from_requester?: boolean;
+}
 /**
  * Sugestões de melhoria da pessoa — `argos-admin /me/suggestions`. Sempre da aplicação LOGADA (o servidor tira o client
  * do access-token da sessão) e com o token da sessão (o servidor recusa x-app-token). Sem `SPINE_ADMIN_API` não há
  * para onde mandar: o botão da barra da página nem aparece (`SpineSuggestButtonComponent`).
  */
+/** Uma sugestão acompanhada com novidade (`/me/suggestions/updates`): a central de notificações. */
+interface SpineSuggestionUpdate {
+    id: string;
+    key: string;
+    title: string;
+    status: SpineSuggestionStatus;
+    /** Quantas novidades desde a última leitura (comentários públicos e mudanças de status de outras pessoas). */
+    count: number;
+    /** A mais recente: o comentário (até 200) ou o status novo, e quem fez. */
+    last: {
+        kind: 'comment' | 'status';
+        status: SpineSuggestionStatus | null;
+        comment: string | null;
+        at: string;
+        author: SpineSuggestionPerson | null;
+    };
+}
 declare class SpineSuggestionsService {
     private readonly http;
     private readonly auth;
@@ -2935,14 +3267,36 @@ declare class SpineSuggestionsService {
         suggestions: SpineAppSuggestion[];
         total: number;
     }>;
-    /** Os comentários públicos de uma sugestão (o detalhe só de leitura), do mais novo. */
+    /** Os comentários públicos de uma sugestão (a conversa), do mais novo. */
     comments(id: string, page: {
         limit: number;
         offset: number;
     }): Promise<{
-        comments: SpineSuggestionComment[];
+        comments: SpineSuggestionMessage[];
+        total: number;
+    }>;
+    /**
+     * As que a pessoa vê (página "Sugestões do app"): as dela, as agrupadas, as em que está envolvida e as do grupo dela,
+     * com filtros e paginação no servidor; `counts` é do conjunto inteiro (os números dos filtros rápidos).
+     */
+    visible(query: SpineVisibleQuery): Promise<{
+        suggestions: SpineVisibleSuggestion[];
         total: number;
+        counts: SpineVisibleCounts | null;
     }>;
+    /** Uma que a pessoa vê, pelo id (404 se não vê). */
+    get(id: string): Promise<SpineVisibleSuggestion>;
+    /** Pela chave ("SUG-12"): o link "?sugestao=SUG-12" abre a sugestão na página. */
+    lookup(key: string): Promise<SpineVisibleSuggestion>;
+    /** Escreve na conversa (quem pediu ou um envolvido): a vez passa para os responsáveis. */
+    reply(id: string, comment: string): Promise<SpineSuggestionMessage>;
+    /** As que a pessoa acompanha com novidade, a mais recente primeiro; `total` = quantas têm novidade. */
+    updates(limit?: number): Promise<{
+        updates: SpineSuggestionUpdate[];
+        total: number;
+    }>;
+    /** Marca a conversa como lida por quem consulta (zera o `unread`). */
+    markRead(id: string): Promise<void>;
     /** As ainda abertas da tela, de qualquer pessoa: o modal oferece apoiar em vez de repetir. */
     byScreen(path: string): Promise<SpineSuggestion[]>;
     vote(id: string): Promise<void>;
@@ -2951,6 +3305,514 @@ declare class SpineSuggestionsService {
     static ɵprov: _angular_core.ɵɵInjectableDeclaration<SpineSuggestionsService>;
 }
 
+/**
+ * A página "Sugestões do app" de quem pede: uma página do PRÓPRIO spine (ver `registerSpineBuiltinPage`), em todo app
+ * com sugestões ligadas, sem cadastro de rota por client. Abre como qualquer tela do workspace (aba, painel, F5, link).
+ */
+declare const SPINE_SUGGESTIONS_PAGE_PATH = "/sugestoes";
+/** Chave sintética da página no distribuidor de telas (não é UUID: não colide com router do banco). */
+declare const SPINE_SUGGESTIONS_PAGE_ID = "spine:sugestoes";
+/** "?sugestao=SUG-12": abrir a página com ela abre a sugestão no painel (o mesmo parâmetro do quadro da equipe). */
+declare const SPINE_SUGGESTION_PAGE_PARAM = "sugestao";
+/** "&aba=conversa": junto com `sugestao`, abre a gaveta na Conversa (sem ele, em Detalhes). */
+declare const SPINE_SUGGESTION_TAB_PARAM = "aba";
+declare const SPINE_SUGGESTION_TAB_CONVERSATION = "conversa";
+/** Sugestões ligadas: o recurso não foi desligado (`SpineFeatures.suggestions`) e há para onde mandar (`SPINE_ADMIN_API`). */
+declare function spineSuggestionsEnabled(): boolean;
+/**
+ * Registra a página no bootstrap (antes da primeira navegação: o F5 em /sugestoes passa pelo `ViewGuard`). Vai no
+ * `provideShell`; com as sugestões desligadas, não registra nada e o endereço cai no fallback de sempre.
+ */
+declare function provideSpineSuggestionsPage(): EnvironmentProviders;
+
+/** Uma tela que dá para escolher no "Sugerir melhoria": a rota, o `router_id` e o caminho legível ("Módulo › Tela"). */
+interface SuggestionScreenOption {
+    path: string;
+    routerId: string | null;
+    /** O nome da tela (o último nível). */
+    name: string;
+    /** O caminho inteiro, como a barra da página mostra ("Vendas › Pedidos › Consulta"): é o que vai para o `screen.label`. */
+    label: string;
+    icon: string;
+}
+/** Valor da opção "Nova tela" no seletor (não é rota: nenhuma rota começa sem "/"). */
+declare const NEW_SCREEN_VALUE = "nova-tela";
+/**
+ * As telas que a pessoa alcança, da árvore de rotas que ela já recebe (`spineRoutesOf(view)`), na ordem do menu: cada
+ * nó com endereço e nome, com o caminho dos ancestrais com endereço (o mesmo "Módulo › … › Tela" da barra da página).
+ * Um endereço aparece uma vez só (o primeiro). Nó com endereço e filhos (módulo que também é página) entra.
+ */
+declare function suggestionScreens(routes: readonly Route[] | null | undefined): SuggestionScreenOption[];
+/** O módulo (primeiro nível) de um caminho legível: "Vendas › Pedidos" → "Vendas". */
+declare function screenModule(label: string | null | undefined): string;
+/** O nome da tela (último nível) de um caminho legível: "Vendas › Pedidos › Consulta" → "Consulta". */
+declare function screenName(label: string | null | undefined): string;
+
+/** De que lado da conversa a tela está: a de quem pede (página) ou a da equipe (detalhe da tarefa). */
+type SpineChatSide = 'solicitante' | 'equipe';
+/** Uma mensagem da conversa de uma sugestão, do jeito que o chat desenha (a página e o detalhe convertem para isto). */
+interface SpineChatMessage {
+    id: string;
+    text: string;
+    created_at: string;
+    author: SpineSuggestionPerson | null;
+    /** Escrita como quem pede (pela página); `false` = como equipe (pelo detalhe da tarefa). */
+    from_requester: boolean;
+    /** Comentário interno da equipe (só aparece do lado da equipe). */
+    internal?: boolean;
+    /** A mudança de status que o comentário acompanha. */
+    status?: SpineSuggestionStatus | null;
+}
+/** Uma linha do chat já resolvida: lado, cabeçalho, agrupamento e o divisor de dia antes dela. */
+interface ChatRow {
+    message: SpineChatMessage;
+    mine: boolean;
+    author: string;
+    grouped: boolean;
+    day: string | null;
+}
+/**
+ * A conversa de uma sugestão como chat (`hm-message-scroller` + `hm-message` + `hm-bubble`), com o campo de resposta
+ * embaixo. Usado nos dois lados: a página de quem pede (`side="solicitante"`) e o detalhe da tarefa da equipe
+ * (`side="equipe"`).
+ *
+ * **Quem fica à direita** é quem está com a tela aberta, no papel desta tela: a mensagem é da pessoa (`me`) E foi
+ * escrita do mesmo lado (`from_requester` casa com `side`). A mesma pessoa no outro papel (quem administra e também
+ * pediu, por exemplo) aparece à esquerda, como qualquer outro participante, com o papel no cabeçalho — a conversa
+ * mostra de que lado cada mensagem foi escrita, não só quem a escreveu.
+ *
+ * - Mensagens do mais ANTIGO ao mais novo; o histórico mais antigo carrega pelo topo (`loadHistory`) sem tirar a
+ *   pessoa do lugar. Divisor de dia ("Hoje", "Ontem", a data) antes da primeira de cada dia.
+ * - Mensagens seguidas da mesma pessoa, no mesmo papel e em poucos minutos se agrupam (sem repetir o cabeçalho).
+ * - Comentário interno (só a equipe vê) em balão de destaque, com um cadeado pequeno no começo (sem selo embaixo: não
+ *   gasta uma linha); a mudança de status que o comentário acompanha, com o selo do status.
+ * - O campo, numa linha só: Enter envia, Shift+Enter quebra a linha. Conteúdo extra do campo (o "Só para a equipe" do detalhe) entra
+ *   por projeção com o atributo `spineChatComposer`. Sem `canWrite`, no lugar do campo vai o conteúdo projetado com
+ *   `spineChatReadOnly`.
+ */
+declare class SpineSuggestionChatComponent {
+    private readonly messages;
+    protected readonly text: {
+        button: string;
+        buttonHint: string;
+        modalTitle: string;
+        intro: string;
+        kind: string;
+        kinds: Record<"melhoria" | "nova_funcionalidade" | "problema" | "outro", string>;
+        statuses: Record<"em_analise" | "planejada" | "em_desenvolvimento" | "concluida" | "recusada", string>;
+        legacyStatuses: Record<"nova", string>;
+        title: string;
+        titlePlaceholder: string;
+        titleRequired: string;
+        description: string;
+        descriptionHint: string;
+        screen: string;
+        screenHint: string;
+        send: string;
+        cancel: string;
+        sent: string;
+        sendError: string;
+        similarHeading: string;
+        similarHint: string;
+        vote: string;
+        voted: string;
+        votes: _trismegisto_primitives.PluralMessage;
+        voteError: string;
+        yours: string;
+        mine: string;
+        mineEmpty: string;
+        mineError: string;
+        loadMore: string;
+        statusFilter: string;
+        allStatuses: string;
+        adminReply: string;
+        sentAt: string;
+        boardLabel: string;
+        search: string;
+        kindFilter: string;
+        allKinds: string;
+        refresh: string;
+        boardEmpty: string;
+        boardEmptyHint: string;
+        boardFiltered: string;
+        loadError: string;
+        moveError: string;
+        removedAuthor: string;
+        noScreen: string;
+        noDescription: string;
+        requestedBy: string;
+        requestedAt: string;
+        status: string;
+        statusSaved: string;
+        statusError: string;
+        history: string;
+        historyEmpty: string;
+        eventStatus: string;
+        eventComment: string;
+        someone: string;
+        comment: string;
+        commentHint: string;
+        commentSend: string;
+        commentSent: string;
+        commentError: string;
+        commentRequired: string;
+        viewLabel: string;
+        viewBoard: string;
+        viewArchive: string;
+        kpis: string;
+        kpiOpen: string;
+        kpiStatusCount: string;
+        kpiDone: string;
+        kpiDoneToday: string;
+        kpiDoneNoneToday: string;
+        kpiOverdueTrend: string;
+        kpiOverdueSteady: string;
+        kpiSoon: string;
+        kpiMineHint: string;
+        kpiPriority: string;
+        kpiPriorityNone: string;
+        kpiPriorityPart: string;
+        filters: string;
+        moreFilters: string;
+        moreFiltersActive: string;
+        allBoardStatuses: string;
+        newTaskIn: string;
+        newTaskOptions: string;
+        columnOldest: string;
+        columnOverdue: _trismegisto_primitives.PluralMessage;
+        columnEmpty: string;
+        columnEmptyFiltered: string;
+        columnEmptyHints: Record<"em_analise" | "planejada" | "em_desenvolvimento" | "concluida", string>;
+        duration: Record<"days" | "hours" | "minutes", string>;
+        createdOn: string;
+        dueWithin: string;
+        dueLateDays: _trismegisto_primitives.PluralMessage;
+        screenFilter: string;
+        allScreens: string;
+        authorFilter: string;
+        allAuthors: string;
+        sort: string;
+        sorts: Record<"position" | "votes" | "recent", string>;
+        sortHint: string;
+        clearFilters: string;
+        topVoted: string;
+        comments: _trismegisto_primitives.PluralMessage;
+        statusSince: string;
+        openScreen: string;
+        statusChange: string;
+        statusComment: string;
+        statusCommentHint: string;
+        statusApply: string;
+        archiveLabel: string;
+        archiveSearch: string;
+        archiveEmpty: string;
+        archiveEmptyHint: string;
+        archiveCount: _trismegisto_primitives.PluralMessage;
+        closedOn: Record<"concluida" | "recusada", string>;
+        pagination: string;
+        reopen: string;
+        reopened: string;
+        reopenError: string;
+        newTask: string;
+        addTaskPlaceholder: string;
+        taskCreated: string;
+        createError: string;
+        saveError: string;
+        kpiMine: string;
+        kpiOverdue: string;
+        assigneeFilter: string;
+        allAssignees: string;
+        assigneeMine: string;
+        assigneeNone: string;
+        labelFilter: string;
+        allLabels: string;
+        priorityFilter: string;
+        allPriorities: string;
+        dueFilter: string;
+        dueAny: string;
+        dueOverdueFilter: string;
+        dueSoonFilter: string;
+        priority: string;
+        priorities: Record<"urgente" | "alta" | "media" | "baixa", string>;
+        dueOn: string;
+        dueToday: string;
+        dueTomorrow: string;
+        dueLate: string;
+        checklistSpoken: string;
+        moreAssignees: string;
+        cardMenu: string;
+        menuStatus: string;
+        menuAssignMe: string;
+        menuCopyLink: string;
+        menuCopyKey: string;
+        menuLabel: string;
+        menuNoLabels: string;
+        menuPriority: string;
+        menuArchive: string;
+        menuRestore: string;
+        menuDelete: string;
+        labelColorName: string;
+        linkCopied: string;
+        keyCopied: string;
+        copyError: string;
+        deleteHeading: string;
+        deleteMessage: string;
+        deleteConfirm: string;
+        deleted: string;
+        archivedToast: string;
+        restoredToast: string;
+        assignedToMe: string;
+        archivedTag: string;
+        taskLabel: string;
+        close: string;
+        editTitle: string;
+        editDescription: string;
+        save: string;
+        checklist: string;
+        checklistAdd: string;
+        checklistPlaceholder: string;
+        checklistOnCard: string;
+        checklistEmpty: string;
+        checklistRemove: string;
+        checklistUp: string;
+        checklistDown: string;
+        tabComments: string;
+        tabActivity: string;
+        commentsEmpty: string;
+        activityEmpty: string;
+        commentInternal: string;
+        internalTag: string;
+        activity: Record<"created" | "title" | "description" | "kind" | "priority" | "start_date" | "start_date_removed" | "due_date" | "due_date_removed" | "cover" | "cover_removed" | "checklist_on_card" | "screen" | "assignee_added" | "assignee_removed" | "watcher_added" | "watcher_removed" | "label_added" | "label_removed" | "checklist_added" | "checklist_done" | "checklist_undone" | "checklist_renamed" | "checklist_removed" | "archived" | "restored" | "merged" | "merged_here" | "unmerged" | "unmerged_here" | "other", string>;
+        assignees: string;
+        assignMe: string;
+        addAssignee: string;
+        watchers: string;
+        addWatcher: string;
+        removePerson: string;
+        peopleSearch: string;
+        peopleEmpty: string;
+        nobody: string;
+        reporter: string;
+        originUser: string;
+        originTeam: string;
+        startDate: string;
+        dueDate: string;
+        labels: string;
+        addLabel: string;
+        createLabel: string;
+        labelColor: string;
+        noLabels: string;
+        screenOrigin: string;
+        votesField: string;
+        createdAt: string;
+        updatedAt: string;
+        lastChange: string;
+        lastChangeNoActor: string;
+        key: string;
+        copyKey: string;
+        newTaskHeading: string;
+        createTask: string;
+        draftHint: string;
+        assignMeOnCreate: string;
+        appSuggestions: string;
+        listView: string;
+        tabAll: string;
+        tabMine: string;
+        appSearch: string;
+        thisScreen: string;
+        appSorts: Record<"votes" | "recent", string>;
+        appEmpty: string;
+        appEmptyHint: string;
+        appEmptyFiltered: string;
+        appError: string;
+        support: string;
+        supported: string;
+        ownSupportHint: string;
+        publicComments: string;
+        publicCommentsEmpty: string;
+        commentsError: string;
+        moreComments: string;
+        appPagination: string;
+        menuMerge: string;
+        mergeHeading: string;
+        mergeIntro: string;
+        mergeSearch: string;
+        mergeNone: string;
+        mergeHasMerged: string;
+        mergePreview: string;
+        mergeCalculating: string;
+        mergePreviewError: string;
+        reportersCount: _trismegisto_primitives.PluralMessage;
+        mergeConfirmHeading: string;
+        mergeConfirmMessage: string;
+        mergeConfirm: string;
+        mergedToast: string;
+        mergeError: string;
+        mergedTag: string;
+        mergedInto: string;
+        mergedIntoHint: string;
+        openMerged: string;
+        unmerge: string;
+        unmergeLabel: string;
+        unmergedToast: string;
+        reporters: string;
+        reporterAuthor: string;
+        reporterVia: string;
+        mergedHere: string;
+        mergedFrom: string;
+        mergedFromHint: string;
+        buttonMenu: string;
+        openPage: string;
+        screenPick: string;
+        screenPickHint: string;
+        screenPickPlaceholder: string;
+        newScreenOption: string;
+        newScreenName: string;
+        newScreenHint: string;
+        newScreenRequired: string;
+        newScreenTag: string;
+        waiting: Record<"solicitante" | "responsaveis", string>;
+        waitingFilter: string;
+        waitingAny: string;
+        waitingClear: string;
+        waitingSaved: string;
+        menuWaiting: string;
+        groupFilter: string;
+        allGroups: string;
+        requestingGroups: string;
+        noGroups: string;
+        unread: _trismegisto_primitives.PluralMessage;
+        fromRequester: string;
+        cardChecklist: _trismegisto_primitives.PluralMessage;
+        requestedByName: string;
+        tabSummary: string;
+        chatAuthor: string;
+        chatSendHint: string;
+        inbox: {
+            label: string;
+            comment: string;
+            status: string;
+        };
+        page: {
+            title: string;
+            description: string;
+            allTitle: string;
+            statusPart: string;
+            reasons: Record<"autor" | "relator" | "envolvido" | "responsavel" | "grupo", string>;
+            reasonHints: Record<"autor" | "relator" | "envolvido" | "responsavel" | "grupo", string>;
+            reasonFilter: string;
+            allReasons: string;
+            needsYou: string;
+            sorts: Record<"activity" | "recent" | "votes", string>;
+            empty: string;
+            emptyHint: string;
+            emptyFiltered: string;
+            error: string;
+            count: _trismegisto_primitives.PluralMessage;
+            pickOne: string;
+            notFound: string;
+            conversation: string;
+            conversationEmpty: string;
+            conversationError: string;
+            olderMessages: string;
+            reply: string;
+            replyPlaceholder: string;
+            replySend: string;
+            replyError: string;
+            readOnly: string;
+            team: string;
+            you: string;
+            groups: string;
+            details: string;
+            listLabel: string;
+            filtersLabel: string;
+            waitingYou: string;
+            waitingTeam: string;
+        };
+    };
+    private readonly preferences;
+    private readonly scroller;
+    /** As mensagens, do mais antigo ao mais novo. */
+    readonly items: _angular_core.InputSignal<readonly SpineChatMessage[]>;
+    /** O papel desta tela: as mensagens da pessoa escritas deste lado ficam à direita. */
+    readonly side: _angular_core.InputSignal<SpineChatSide>;
+    /** O `user_id` de quem está com a tela aberta. */
+    readonly me: _angular_core.InputSignal<string>;
+    readonly label: _angular_core.InputSignal<string>;
+    readonly empty: _angular_core.InputSignal<string>;
+    readonly hasMore: _angular_core.InputSignal<boolean>;
+    readonly loading: _angular_core.InputSignal<boolean>;
+    readonly canWrite: _angular_core.InputSignal<boolean>;
+    readonly composerLabel: _angular_core.InputSignal<string>;
+    readonly placeholder: _angular_core.InputSignal<string>;
+    readonly sendLabel: _angular_core.InputSignal<string>;
+    readonly sending: _angular_core.InputSignal<boolean>;
+    readonly error: _angular_core.InputSignal<string>;
+    /** O texto do campo (em mão dupla: quem usa limpa depois de enviar). */
+    readonly draft: _angular_core.ModelSignal<string>;
+    readonly loadHistory: _angular_core.OutputEmitterRef<void>;
+    /** Enviar: o texto aparado (nunca vazio). */
+    readonly send: _angular_core.OutputEmitterRef<string>;
+    protected readonly statusColors: Record<"em_analise" | "planejada" | "em_desenvolvimento" | "concluida" | "recusada", _trismegisto_angular.TagColor>;
+    protected readonly timeFormat: Intl.DateTimeFormatOptions;
+    protected readonly rows: _angular_core.Signal<ChatRow[]>;
+    /** Depois de enviar: a pessoa quer ver a própria mensagem, mesmo se estava lendo lá em cima. */
+    scrollToEnd(): void;
+    protected onKey(event: Event): void;
+    protected submit(): void;
+    protected statusOf(m: SpineChatMessage): SpineSuggestionStatus | null;
+    /** "Ana Souza (Equipe)": do outro lado, o papel junto do nome — inclusive a própria pessoa no outro papel. */
+    private authorText;
+    private dayKey;
+    /** "Hoje", "Ontem" ou a data por extenso (no idioma do catálogo e no fuso da pessoa). */
+    private dayLabel;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SpineSuggestionChatComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SpineSuggestionChatComponent, "spine-suggestion-chat", never, { "items": { "alias": "items"; "required": false; "isSignal": true; }; "side": { "alias": "side"; "required": true; "isSignal": true; }; "me": { "alias": "me"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "empty": { "alias": "empty"; "required": false; "isSignal": true; }; "hasMore": { "alias": "hasMore"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "canWrite": { "alias": "canWrite"; "required": false; "isSignal": true; }; "composerLabel": { "alias": "composerLabel"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "sendLabel": { "alias": "sendLabel"; "required": false; "isSignal": true; }; "sending": { "alias": "sending"; "required": false; "isSignal": true; }; "error": { "alias": "error"; "required": false; "isSignal": true; }; "draft": { "alias": "draft"; "required": false; "isSignal": true; }; }, { "draft": "draftChange"; "loadHistory": "loadHistory"; "send": "send"; }, never, ["[spineChatComposer]", "[spineChatReadOnly]"], true, never>;
+}
+
+/** Um selo da linha: o nome e, se quiser, a cor (1..8, a paleta categórica do tema); sem cor, uma estável pelo id. */
+interface SpineTagRowItem {
+    id: string;
+    name: string;
+    color?: number;
+}
+/** Cor categórica estável para um id (o mesmo grupo sempre na mesma cor, em qualquer tela). */
+declare function spineTagColor(id: string): number;
+/**
+ * Selos numa linha só, no modelo dos rótulos do quadro (fundo claro da cor e o ponto na cor cheia): cabem os que cabem
+ * na largura e o resto vira "+N", com os nomes na dica e para o leitor de tela. Mede de novo quando a largura muda
+ * (ResizeObserver) e quando a lista muda; sem medida (servidor, teste sem layout), mostra todos.
+ *
+ * Os que não cabem continuam no DOM, fora do fluxo e invisíveis (`visibility: hidden`), só para a largura deles poder
+ * ser medida; ficam `aria-hidden` — quem lê a tela ouve os nomes no "+N".
+ */
+declare class SpineTagRowComponent {
+    private readonly text;
+    private readonly host;
+    private readonly browser;
+    private readonly injector;
+    private readonly destroyRef;
+    readonly items: _angular_core.InputSignal<readonly SpineTagRowItem[]>;
+    readonly label: _angular_core.InputSignal<string>;
+    /** Texto quando não há nenhum (vazio = nada). */
+    readonly empty: _angular_core.InputSignal<string>;
+    protected readonly tags: _angular_core.Signal<{
+        color: number;
+        id: string;
+        name: string;
+    }[]>;
+    /** Quantos cabem; começa com todos (sem medida, todos aparecem). */
+    protected readonly visible: _angular_core.WritableSignal<number>;
+    protected readonly hiddenCount: _angular_core.Signal<number>;
+    protected readonly hiddenNames: _angular_core.Signal<string>;
+    protected readonly moreText: _angular_core.Signal<string>;
+    constructor();
+    /** Quantos selos cabem na largura, reservando o "+N" quando nem todos cabem. */
+    private measure;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SpineTagRowComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SpineTagRowComponent, "spine-tag-row", never, { "items": { "alias": "items"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "empty": { "alias": "empty"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
 /**
  * Modal de documentação das telas: índice (com busca) à esquerda e leitura à direita. Montado uma vez
  * pelo `spine-layout`; abrir, fechar e o que se lê vêm todos do `SpineDocsService`.
@@ -2996,6 +3858,6 @@ declare const SPINE_MARKDOWN_PURIFY_CONFIG: Config;
 /** HTML limpo pelo perfil do spine, ou `null` quando não há DOM (SSR: melhor não renderizar). */
 declare function sanitizeSpineMarkdownHtml(html: string): string | null;
 
-export { AiAgentComponent, AppLauncherComponent, HeaderComponent, LayoutComponent, SPINE_BRAND, SPINE_GLOBAL_PREFERENCE_KEYS, SPINE_IDLE_WARNING_SECONDS, SPINE_MARKDOWN_PURIFY_CONFIG, SPINE_PREFERENCES_SAVE_DELAY_MS, SPINE_RATING_COMMENT_MAX, SPINE_RATING_SCORE_MAX, SPINE_SETTINGS_ALIASES, SPINE_SETTINGS_KEYS, SPINE_SETTINGS_SECTIONS, SPINE_SUGGESTION_KINDS, SPINE_SUGGESTION_KIND_COLORS, SPINE_SUGGESTION_KIND_ICONS, SPINE_SUGGESTION_LIMITS, SPINE_SUGGESTION_PUBLIC_SORTS, SPINE_SUGGESTION_PUBLIC_STATUSES, SPINE_SUGGESTION_STATUSES, SPINE_SUGGESTION_STATUS_COLORS, SPINE_SUGGESTION_STATUS_ICONS, SettingsPanelComponent, ShortcutService, ShortcutsCheatsheetComponent, SidebarComponent, SpineAccountPreferencesService, SpineAccountSecurityService, SpineAppTokensService, SpineBrandComponent, SpineConnectionBannerComponent, SpineDocsComponent, SpineDocsService, SpineIdleService, SpineIdleWarningComponent, SpineInitialSetupComponent, SpineInitialSetupService, SpineLogoutService, SpineMarkdownComponent, SpineMyGroupsService, SpineNewsComponent, SpineNewsService, SpineNoticesService, SpinePageActionsDirective, SpinePageActionsSlot, SpineRatingStarsComponent, SpineRatingsService, SpineSettingsService, SpineStartPageService, SpineSuggestionsService, accountErrorCode, argosAccountApi, buildMcpConfig, effectiveIdleMinutes, idleLimits, isInternalPath, provideSettingsSection, ratingTargetKey, resolveSettingsSection, sanitizeSpineMarkdownHtml, spineScoreBand, spineStarFills, stable };
-export type { AccountActivityEntry, AccountActivityPage, AccountBadges, AccountMethod, AccountOverview, AccountPreferences, AccountReauth, AccountSession, AppToken, AppTokenList, AppTokenOptions, CreatedAppToken, DocsEntry, DocsGroup, DocsView, GroupMember, GroupRole, ManagedGroup, RealmUser, ShortcutActions, SpineAccountPreferencesDoc, SpineAccountPreferencesStatus, SpineAppSuggestion, SpineAppSuggestionsQuery, SpineGlobalPreferencesDoc, SpineIdleLimits, SpineInitialSetupMode, SpineInitialSetupStep, SpineNewsAuthor, SpineNewsDetail, SpineNewsFilter, SpineNewsKind, SpineNewsPage, SpineNewsSummary, SpineNotice, SpineNoticePermission, SpineRating, SpineRatingAverage, SpineRatingScope, SpineRatingTarget, SpineScoreBand, SpineSettingsSection, SpineStarFill, SpineSuggestion, SpineSuggestionComment, SpineSuggestionDraft, SpineSuggestionKind, SpineSuggestionPerson, SpineSuggestionPublicSort, SpineSuggestionPublicStatus, SpineSuggestionStatus };
+export { AiAgentComponent, AppLauncherComponent, HeaderComponent, LayoutComponent, NEW_SCREEN_VALUE, SPINE_BRAND, SPINE_GLOBAL_PREFERENCE_KEYS, SPINE_IDLE_WARNING_SECONDS, SPINE_INBOX_POLL_MS, SPINE_INBOX_SOURCES, SPINE_MARKDOWN_PURIFY_CONFIG, SPINE_PREFERENCES_SAVE_DELAY_MS, SPINE_RATING_COMMENT_MAX, SPINE_RATING_SCORE_MAX, SPINE_SETTINGS_ALIASES, SPINE_SETTINGS_KEYS, SPINE_SETTINGS_SECTIONS, SPINE_SUGGESTIONS_PAGE_ID, SPINE_SUGGESTIONS_PAGE_PATH, SPINE_SUGGESTION_KINDS, SPINE_SUGGESTION_KIND_COLORS, SPINE_SUGGESTION_KIND_ICONS, SPINE_SUGGESTION_LIMITS, SPINE_SUGGESTION_PAGE_PARAM, SPINE_SUGGESTION_PUBLIC_SORTS, SPINE_SUGGESTION_PUBLIC_STATUSES, SPINE_SUGGESTION_REASONS, SPINE_SUGGESTION_STATUSES, SPINE_SUGGESTION_STATUS_COLORS, SPINE_SUGGESTION_STATUS_ICONS, SPINE_SUGGESTION_TAB_CONVERSATION, SPINE_SUGGESTION_TAB_PARAM, SPINE_SUGGESTION_VISIBLE_SORTS, SPINE_SUGGESTION_WAITING, SPINE_SUGGESTION_WAITING_COLORS, SPINE_TAB, SettingsPanelComponent, ShortcutService, ShortcutsCheatsheetComponent, SidebarComponent, SpineAccountPreferencesService, SpineAccountSecurityService, SpineAppTokensService, SpineBrandComponent, SpineConnectionBannerComponent, SpineDocsComponent, SpineDocsService, SpineIdleService, SpineIdleWarningComponent, SpineInboxButtonComponent, SpineInboxService, SpineInitialSetupComponent, SpineInitialSetupService, SpineLogoutService, SpineMarkdownComponent, SpineMyGroupsService, SpineNewsComponent, SpineNewsService, SpineNoticesService, SpinePageActionsDirective, SpinePageActionsSlot, SpineRatingStarsComponent, SpineRatingsService, SpineSettingsService, SpineStartPageService, SpineSuggestionChatComponent, SpineSuggestionsService, SpineTagRowComponent, SpineWorkspaceNavService, accountErrorCode, argosAccountApi, buildMcpConfig, effectiveIdleMinutes, idleLimits, isInternalPath, provideSettingsSection, provideSpineInboxSource, provideSpineSuggestionsPage, ratingTargetKey, resolveSettingsSection, sanitizeSpineMarkdownHtml, screenModule, screenName, spineNormalizeUrl, spineParamsOf, spinePathOf, spineScoreBand, spineStarFills, spineSuggestionsEnabled, spineTagColor, stable, suggestionScreens };
+export type { AccountActivityEntry, AccountActivityPage, AccountBadges, AccountMethod, AccountOverview, AccountPreferences, AccountReauth, AccountSession, AppToken, AppTokenList, AppTokenOptions, CreatedAppToken, DocsEntry, DocsGroup, DocsView, GroupMember, GroupRole, ManagedGroup, RealmUser, ShortcutActions, SpineAccountPreferencesDoc, SpineAccountPreferencesStatus, SpineAppSuggestion, SpineAppSuggestionsQuery, SpineChatMessage, SpineChatSide, SpineGlobalPreferencesDoc, SpineIdleLimits, SpineInboxEntry, SpineInboxItem, SpineInboxSource, SpineInitialSetupMode, SpineInitialSetupStep, SpineNewsAuthor, SpineNewsDetail, SpineNewsFilter, SpineNewsKind, SpineNewsPage, SpineNewsSummary, SpineNotice, SpineNoticePermission, SpineOpenTabOptions, SpineRating, SpineRatingAverage, SpineRatingScope, SpineRatingTarget, SpineScoreBand, SpineSettingsSection, SpineStarFill, SpineSuggestion, SpineSuggestionComment, SpineSuggestionDraft, SpineSuggestionKind, SpineSuggestionMessage, SpineSuggestionPerson, SpineSuggestionPublicSort, SpineSuggestionPublicStatus, SpineSuggestionReason, SpineSuggestionScreen, SpineSuggestionStatus, SpineSuggestionUpdate, SpineSuggestionVisibleSort, SpineSuggestionWaiting, SpineTab, SpineTabParams, SpineTagRowItem, SpineVisibleCounts, SpineVisibleQuery, SpineVisibleSuggestion, SuggestionScreenOption };
 //# sourceMappingURL=trismegisto-spine-layout.d.ts.map