@trismegisto/spine 2.0.0

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

@@ -0,0 +1 @@
+{"version":3,"file":"trismegisto-spine-layout.d.ts","sources":["../../../projects/ui/layout/src/onboarding/onboarding.service.ts","../../../projects/ui/layout/src/news/news.service.ts","../../../projects/ui/layout/src/shortcuts/shortcut.service.ts","../../../projects/ui/layout/src/workspace/spine-workspace-nav.service.ts","../../../projects/ui/layout/src/layout.component.ts","../../../projects/ui/layout/src/header/header.component.ts","../../../projects/ui/layout/src/header/app-launcher.component.ts","../../../projects/ui/layout/src/header/brand.component.ts","../../../projects/ui/layout/src/brand.token.ts","../../../projects/ui/layout/src/sidebar/sidebar.component.ts","../../../projects/ui/layout/src/connection/connection-banner.component.ts","../../../projects/ui/layout/src/onboarding/onboarding-overlay.component.ts","../../../projects/ui/layout/src/shortcuts/shortcuts-cheatsheet.component.ts","../../../projects/ui/layout/src/settings/settings.service.ts","../../../projects/ui/layout/src/settings/settings-panel.component.ts","../../../projects/ui/layout/src/settings/app-tokens.service.ts","../../../projects/ui/layout/src/docs/docs.service.ts","../../../projects/ui/layout/src/news/news.component.ts","../../../projects/ui/layout/src/docs/docs-modal.component.ts","../../../projects/ui/layout/src/docs/markdown.component.ts"],"mappings":"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","names":[]}

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

@@ -0,0 +1,68 @@
+import * as i0 from '@angular/core';
+import { Type, OnInit, ChangeDetectorRef } from '@angular/core';
+import { HermesLoadingState, ModalSize } from '@trismegisto/angular';
+import { Observable } from 'rxjs';
+
+interface ModalConfig<TData = any> {
+    title?: string;
+    size?: 'sm' | 'md' | 'lg' | 'xl';
+    closable?: boolean;
+    text?: string;
+    component?: Type<ModalContent>;
+    data?: TData;
+    showActions?: boolean;
+}
+interface ModalContent<TResult = any> {
+    getResult(): TResult;
+    isValid?(): boolean;
+}
+
+declare class ModalService {
+    private _visible;
+    readonly visible$: Observable<boolean>;
+    private _state;
+    readonly state$: Observable<HermesLoadingState>;
+    private _config;
+    get config(): ModalConfig | null;
+    private _result$;
+    open<TResult = any, TData = any>(config: ModalConfig<TData>): Observable<TResult | null>;
+    confirm(result: any): void;
+    close(): void;
+    setState(state: HermesLoadingState): void;
+    private dismiss;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ModalService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ModalService>;
+}
+
+/** `ModalConfig.size` manteve os valores do spine antigo (sm/md/lg/xl) por compatibilidade
+ * de API com quem já chama `modalService.open(...)`; o DS novo só tem 3 tamanhos. */
+declare function toHermesSize(size: ModalConfig['size']): ModalSize;
+declare class ModalComponent implements OnInit {
+    private modalService;
+    private cdr;
+    /** Rótulos dos botões padrão, do catálogo do Hermes (pt-BR/en/es). */
+    protected readonly dialogText: {
+        confirm: string;
+        cancel: string;
+    };
+    private content;
+    visible: boolean;
+    config: ModalConfig | null;
+    state: HermesLoadingState;
+    protected readonly HermesLoadingState: typeof HermesLoadingState;
+    protected readonly toHermesSize: typeof toHermesSize;
+    private contentRef;
+    constructor(modalService: ModalService, cdr: ChangeDetectorRef);
+    ngOnInit(): void;
+    get canConfirm(): boolean;
+    private loadComponent;
+    confirm(): void;
+    dismiss(): void;
+    onLoadingStateChange(state: HermesLoadingState): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ModalComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ModalComponent, "spine-modal", never, {}, {}, never, never, true, never>;
+}
+
+export { ModalComponent, ModalService };
+export type { ModalConfig, ModalContent };
+//# sourceMappingURL=trismegisto-spine-modal.d.ts.map

package/types/trismegisto-spine-modal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"trismegisto-spine-modal.d.ts","sources":["../../../projects/ui/modal/src/modal.types.ts","../../../projects/ui/modal/src/modal.service.ts","../../../projects/ui/modal/src/modal.component.ts"],"mappings":";;;;;AAEM,UAAW,WAAW;;;;;AAK1B,gBAAY,IAAI,CAAC,YAAY;;;AAG9B;AAEK,UAAW,YAAY;;;AAG5B;;ACTD,cACa,YAAY;;AAEvB,uBAA0B,UAAU;;AAGpC,qBAAwB,UAAU,CAAC,kBAAkB;;AAGrD,kBAAqB,WAAW;;6CAMS,WAAW,UAAU,UAAU;AAYxE;AAMA;AAMA,oBAAgB,kBAAkB;AAIlC;yCA1CW,YAAY;6CAAZ,YAAY;AAgDxB;;ACjDD;AACqF;AACrF,iBAAS,YAAY,OAAO,WAAW,WAAW,SAAS;AAS3D,cAMa,cAAe,YAAW,MAAM;AAe/B;AAAoC;;;;;AAbe;;AAI/D;AACA,YAAQ,WAAW;WACZ,kBAAkB;AAEzB,kDAAqC,kBAAA;AACrC,4CAA+B,YAAA;;AAIX,8BAAc,YAAY,OAAe,iBAAiB;AAE9E;;AAwBA;AAUA;AAMA;AAIA,gCAA4B,kBAAkB;yCA7DnC,cAAc;2CAAd,cAAc;AAgE1B;;","names":[]}

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

@@ -0,0 +1,62 @@
+import { Observable } from 'rxjs';
+import * as i0 from '@angular/core';
+import { OnInit, ChangeDetectorRef } from '@angular/core';
+import { AlertVariant } from '@trismegisto/angular';
+
+declare enum AlertType {
+    INFO = "info",
+    WARNING = "warning",
+    SUCCESS = "success",
+    DANGER = "danger"
+}
+interface Notification {
+    timer: number;
+    expirer?: number;
+    hermesAlertType: AlertType;
+    message: string;
+    hermesAlertAppLevel?: boolean;
+    hermesAlertClosable?: boolean;
+}
+
+type NotificationInput = Omit<Notification, 'hermesAlertType' | 'expirer'> & {
+    hermesAlertType: AlertType | number;
+};
+declare class NotificationService {
+    private readonly text;
+    private _notifications;
+    readonly notifications$: Observable<Notification[]>;
+    /** Relógio da expiração: só corre enquanto há notificação na tela (antes era um `setInterval` eterno,
+     *  nunca limpo — acordava a página a cada segundo e sobrevivia ao injetor). */
+    private timer;
+    constructor();
+    /**
+     * O `status` do envelope `{ status, message, data }` dos GraphQL decide o tipo do toast — o mesmo
+     * contrato em todo app: 2xx sucesso, 3xx atenção (concluiu com ressalva), 4xx/5xx erro, o resto
+     * informação. Por faixa (antes era só 200/300/400/500 exatos — continuam dando o mesmo resultado).
+     */
+    resolveAlertType(status: number): AlertType;
+    addNotification(notification: NotificationInput): void;
+    processErrorNotification(): void;
+    private expireNotifications;
+    private stopClock;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NotificationService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<NotificationService>;
+}
+
+/** `AlertType.DANGER` (nome do spine antigo, preservado na API pública) mapeia pra `'error'`
+ * no `AlertVariant` do DS novo — os outros 3 valores já coincidem 1:1. */
+declare function toAlertVariant(type: AlertType): AlertVariant;
+declare class NotificationComponent implements OnInit {
+    notificationService: NotificationService;
+    private cdr;
+    notifications: Notification[];
+    protected readonly toAlertVariant: typeof toAlertVariant;
+    constructor(notificationService: NotificationService, cdr: ChangeDetectorRef);
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NotificationComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NotificationComponent, "spine-notification", never, {}, {}, never, never, true, never>;
+}
+
+export { AlertType, NotificationComponent, NotificationService };
+export type { Notification, NotificationInput };
+//# sourceMappingURL=trismegisto-spine-notification.d.ts.map

package/types/trismegisto-spine-notification.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"trismegisto-spine-notification.d.ts","sources":["../../../projects/ui/notification/src/notification.types.ts","../../../projects/ui/notification/src/notification.service.ts","../../../projects/ui/notification/src/notification.component.ts"],"mappings":";;;;;AAAA,aAAY,SAAS;AACnB;AACA;AACA;AACA;AACD;UAEgB,YAAY;;;qBAGV,SAAS;;;;AAI3B;;ACRK,KAAM,iBAAiB,GAAG,IAAI,CAAC,YAAY;AAC/C,qBAAiB,SAAS;;AAG5B,cACa,mBAAmB;AAC9B;;AAEA,6BAAgC,UAAU,CAAC,YAAY;AAEvD;AAC+E;;;AAO/E;;;;AAIG;AACH,sCAAkC,SAAS;AAO3C,kCAA8B,iBAAiB;AAa/C;AASA;AASA;yCAxDW,mBAAmB;6CAAnB,mBAAmB;AA4D/B;;ACjED;AAC0E;AAC1E,iBAAS,cAAc,OAAO,SAAS,GAAG,YAAY;AAItD,cAOa,qBAAsB,YAAW,MAAM;AAK/B,yBAAqB,mBAAmB;AAAE;mBAJ9C,YAAY;AAE3B,8CAAiC,cAAA;AAEd,qCAAqB,mBAAmB,OAAe,iBAAiB;AAE3F;yCAPW,qBAAqB;2CAArB,qBAAqB;AAajC;;","names":[]}

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

@@ -0,0 +1,205 @@
+import { Route } from '@trismegisto/spine';
+import * as i0 from '@angular/core';
+import { InjectionToken, Type } from '@angular/core';
+import { HttpInterceptor, HttpRequest, HttpHandler, HttpEvent } from '@angular/common/http';
+import { Observable } from 'rxjs';
+import { CanActivate, Router, ActivatedRouteSnapshot, RouterStateSnapshot, Route as Route$1 } from '@angular/router';
+import { ViewService, AuthorizationService } from '@orfeu/angular/core';
+
+declare class LoggerService {
+    private _logger;
+    get logger(): Route[];
+    setLogger(logger: Route[]): void;
+    /** A página atual (último nó da cadeia do painel focado). */
+    get page(): Route | null;
+    /** `router_id` da página atual -- a identidade da TELA no spine (componente, documento, descrição). */
+    get routerId(): string | null;
+    /**
+     * A ROTA da página atual (`web.routes.route_id`, o `routed_id` do nó) -- o que vai em `x-route-id`
+     * e vira `audit.events.route_id`/`route_name`. Só quando o último nó é uma página de verdade (tem
+     * router): grupo puramente organizacional não é tela. Antes de 2026-10-05 ia o router_id aqui, e a
+     * auditoria não achava o nome (o argos-auth-server ainda traduz router_id → rota, por compatibilidade).
+     */
+    get routeId(): string | null;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LoggerService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<LoggerService>;
+}
+
+/** Must match `@orfeu/node`/`orfeu` (Python)'s `ROUTE_ID_HEADER` (`x-route-id`). */
+declare const ROUTE_ID_HEADER = "X-Route-Id";
+/** Must match `@orfeu/node`/`orfeu` (Python)'s `CLIENT_ID_HEADER` (`x-client-id`): which app (client) the action came from. */
+declare const CLIENT_ID_HEADER = "X-Client-Id";
+/**
+ * Attaches the current screen's ROUTE id — `web.routes.route_id` of the page node (`routed_id`), NOT the
+ * `router_id` the spine uses to identify the screen (see `LoggerService.routeId`) — and the app's `clientId`
+ * from `SpineConfig` as headers on every outgoing HTTP
+ * request, read from `LoggerService` (updated by `ViewGuard` on every
+ * navigation — see view.guard.ts). This is a caller-supplied correlation tag
+ * consumed by Orfeu's structured operation logs to correlate an
+ * operation_id with the route that triggered it; it is never verified
+ * server-side and never used for permission checks.
+ *
+ * Applied globally (registered once by `provideShell`, not per-service) so
+ * every app gets the correlation for free — an extra header a third-party
+ * API doesn't recognize is harmless, so there's no need to scope this to
+ * only Orfeu-guarded backends.
+ */
+declare class RouteIdInterceptor implements HttpInterceptor {
+    private loggerService;
+    private readonly clientId;
+    constructor(loggerService: LoggerService);
+    intercept(req: HttpRequest<unknown>, next: HttpHandler): Observable<HttpEvent<unknown>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RouteIdInterceptor, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<RouteIdInterceptor>;
+}
+
+/**
+ * Gate de navegação REAL (deep link, F5, `router.navigateByUrl` do painel focado — ver
+ * `SpineWorkspaceNavService`). Não desenha mais nada nem alimenta breadcrumb/sidebar: isso agora
+ * é responsabilidade de cada painel do workspace (`resolveSpineRoute`, chamado direto por quem
+ * precisa da cadeia). O guard só confirma que a URL resolve contra a view atual — senão redireciona
+ * pro fallback navegável ou pra `/no-permission` — e existe numa única rota coringa (ver
+ * `private.routes.ts`), não mais em 6 níveis de rota aninhada.
+ *
+ * Duas saídas de acesso, nesta ordem:
+ * - **`/blocked`** — autenticado, mas sem nenhum grupo vinculado a esta aplicação (o token sai
+ *   com `badges` vazio: o argos só dá crachá por grupo do project do client). Vale mesmo que o
+ *   app tenha rotas públicas: quem não é de nenhum grupo do app não entra nele;
+ * - **`/no-permission`** — tem grupo, mas a view não trouxe rota nenhuma (os grupos não têm
+ *   permissão e o app não tem rota pública).
+ */
+declare class ViewGuard implements CanActivate {
+    private router;
+    private viewService;
+    private auth;
+    constructor(router: Router, viewService: ViewService, auth: AuthorizationService);
+    canActivate(_route: ActivatedRouteSnapshot, state: RouterStateSnapshot): boolean;
+    canActivateChild(_route: ActivatedRouteSnapshot, state: RouterStateSnapshot): boolean;
+    canLoad(route: Route$1): boolean;
+    private checkRoute;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ViewGuard, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ViewGuard>;
+}
+
+/**
+ * Manual de uma tela, declarado no `document` da própria `ComponentRoute` (mesma chave, o router_id).
+ * Os textos são Markdown buscado só quando alguém abre a documentação: nos apps, um `import()` do `.md`
+ * com o loader `text`, de modo que o conteúdo vai no chunk lazy da tela e não no carregamento inicial.
+ */
+interface RouteDocument {
+    /** Nome da tela no índice da documentação; se faltar, usa-se o rótulo da rota na árvore do usuário. */
+    title?: string;
+    /** Seção do índice em que a tela aparece; se faltar, usa-se o módulo de topo que a contém. */
+    group?: string;
+    /** Texto para quem usa a tela no dia a dia (normalmente o `README.md` dela). */
+    load: () => Promise<string>;
+    /**
+     * Especificação técnica, para desenvolvimento (normalmente o `ESPECIFICACAO.md`). Só aparece com
+     * `SpineConfig.technicalDocs` ativo — por padrão, apenas em `isDevMode()`.
+     */
+    loadTechnical?: () => Promise<string>;
+}
+/**
+ * Uma tela do app. A chave é o ROUTER (`web.router.router_id` do client -- a posição da tela na
+ * navegação, o `router_id` do nó 'page' da view), nunca o `web.routes.route_id` (a rota é só
+ * nome/ícone/path, reaproveitável em vários routers). Tela de template (ex.: auto-serviço) usa
+ * `source_template_router_id` -- o router do TEMPLATE, igual em todos os clients vinculados.
+ */
+interface ComponentRoute {
+    /** `router_id` (web.router do client) da tela. */
+    id?: string;
+    /** Componente da tela, via `import()` dinâmico (code-splitting por tela). */
+    load?: () => Promise<Type<any>>;
+    /** Documentação da tela, exibida pelo botão de documentação da barra da página. */
+    document?: RouteDocument;
+    /** @deprecated use `id`. Mantido para os mapas antigos (o valor sempre foi o router_id); `id` vence
+     *  quando os dois vêm. */
+    route_id?: string;
+    /** @deprecated use `load`. */
+    component?: () => Promise<Type<any>>;
+    source_template_router_id?: string;
+}
+/** `id` (router_id) da entrada, aceitando o formato antigo (`route_id`). */
+declare function componentRouterId(route: ComponentRoute): string | undefined;
+/** @deprecated use `componentRouterId` (o id da entrada é o router_id da tela). */
+declare const componentRouteId: typeof componentRouterId;
+/** Carregador da entrada, aceitando o formato antigo (`component`). */
+declare function componentRouteLoader(route: ComponentRoute): (() => Promise<Type<any>>) | undefined;
+declare const COMPONENT_ROUTES: InjectionToken<ComponentRoute[]>;
+
+/**
+ * O import dinâmico falhou porque o arquivo da tela não existe mais no servidor — saiu um build novo
+ * enquanto a aba estava aberta e os chunks antigos foram trocados. Mensagens dos navegadores:
+ * Chrome/Edge "Failed to fetch dynamically imported module", Firefox "error loading dynamically
+ * imported module", Safari "Importing a module script failed", webpack "Loading chunk N failed" /
+ * `ChunkLoadError`.
+ */
+declare function isChunkLoadError(err: unknown): boolean;
+declare class ComponentDistributorService {
+    private components;
+    /**
+     * `router_id` da última falha (sem entrada registrada ou import quebrado) — lido por
+     * `NoContentComponent` pra montar a descrição (ver comentário dela). Sinal só, não por
+     * instância: se dois painéis erram ao mesmo tempo, o texto de um pode piscar o código do
+     * outro por um instante — aceitável, é só o que a mensagem de suporte mostra, nenhuma decisão
+     * de roteamento depende disto.
+     */
+    readonly lastMissingRouterId: i0.WritableSignal<string>;
+    /** @deprecated use `lastMissingRouterId` (sempre foi o router_id). */
+    get lastMissingRouteId(): i0.WritableSignal<string>;
+    constructor(routes: ComponentRoute[][] | null);
+    /** Todas as entradas registradas (app + pacotes plugáveis) -- lidas pela documentação. */
+    get entries(): readonly ComponentRoute[];
+    getComponent(routerId: string, source_template_router_id?: string | null): Promise<Type<any>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ComponentDistributorService, [{ optional: true; }]>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ComponentDistributorService>;
+}
+
+/**
+ * Lógica pura de resolução da árvore de rotas vinda do backend (`ViewService.currentView`) —
+ * compartilhada entre `ViewGuard` (gate de navegação real) e `resolveSpineRoute` (resolução por
+ * painel do workspace, sem depender do `Router`). Extraída daqui porque as duas precisavam do
+ * mesmo algoritmo de busca e tinham cópias divergentes antes desta reescrita.
+ */
+/** Acha uma rota cujo `route_redirect` bate com `urlAtLevel`, atravessando ancestrais
+ *  "transparentes" (sem `route_redirect` próprio — só agrupam os filhos). */
+declare function findRouteThrough(routes: Route[], urlAtLevel: string): Route | null;
+/** Primeira rota navegável (DFS), atravessando grupos transparentes — usada como fallback
+ *  quando a URL alvo não bate com nada na view atual. */
+declare function findFirstNavigable(routes: Route[]): string | null;
+/**
+ * Resolve a cadeia INTEIRA de rotas (header→navigation→menu→item→submenu→page, até onde a URL
+ * for funda) pra uma URL qualquer, lendo só `currentRoutes`/`getLevel`/`getUrlAtLevel` — as
+ * mesmas três primitivas que `ViewGuard` já usava, sem tocar no `Router`. `chain[0]` é o nível 1
+ * (header), não existe nível 0 — mantém a mesma convenção 1-based do `ViewGuard` original.
+ */
+declare function resolveRouteChain(currentRoutes: Route[], getLevel: (url: string) => number, getUrlAtLevel: (url: string, level: number) => string, url: string): Route[] | null;
+/**
+ * `resolveRouteChain`, mas descendo sozinho quando o nó final tem filhos e nenhum conteúdo
+ * próprio — o mesmo comportamento que o `RouterComponent` antigo tinha (cada nível, ao pousar
+ * numa rota com `routes.length > 0`, `router.navigate([routes[0].route_redirect])`), perdido na
+ * reescrita porque não existe mais uma cadeia de guardas por nível. Sem isto, clicar num nó
+ * puramente organizacional (ex.: "Solicitações", que só agrupa Configuração/Inventário/etc. e não
+ * tem `route_id` de página nenhuma) cai em "Nenhum conteúdo disponível" — achado real, 2026-09-28.
+ */
+declare function resolveEffectiveRouteChain(currentRoutes: Route[], getLevel: (url: string) => number, getUrlAtLevel: (url: string, level: number) => string, url: string): Route[] | null;
+
+/**
+ * Traduz uma URL na cadeia de rotas do backend (header→navigation→menu→item→submenu→page) e no
+ * componente da folha — sem passar pelo `Router` do Angular. É o que torna o painel do workspace
+ * possível — o `Router` tem uma URL só; um painel não-focado precisa resolver a dele de forma
+ * independente. Anda-se na árvore `Route[]` que o backend manda (`ViewService.currentView`), a
+ * mesma que `ViewGuard` lia.
+ */
+interface ResolvedSpineRoute {
+    /** A cadeia inteira, nível 1 (header) até onde a URL alcançar. `chain.at(-1)` é sempre o nível
+     *  'page' — é dele que `component` vem. Níveis intermediários (`item`/`submenu`) com mais de um
+     *  irmão são o que vira aba de submenu/multipágina no painel. */
+    readonly chain: Route[];
+    readonly component: Type<unknown>;
+}
+declare function resolveSpineRoute(currentRoutes: Route[], getLevel: (url: string) => number, getUrlAtLevel: (url: string, level: number) => string, distributor: ComponentDistributorService, url: string): Promise<ResolvedSpineRoute | null>;
+
+export { CLIENT_ID_HEADER, COMPONENT_ROUTES, ComponentDistributorService, LoggerService, ROUTE_ID_HEADER, RouteIdInterceptor, ViewGuard, componentRouteId, componentRouteLoader, componentRouterId, findFirstNavigable, findRouteThrough, isChunkLoadError, resolveEffectiveRouteChain, resolveRouteChain, resolveSpineRoute };
+export type { ComponentRoute, ResolvedSpineRoute, RouteDocument };
+//# sourceMappingURL=trismegisto-spine-routing.d.ts.map

package/types/trismegisto-spine-routing.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"trismegisto-spine-routing.d.ts","sources":["../../../projects/ui/routing/src/logger.service.ts","../../../projects/ui/routing/src/route-id.interceptor.ts","../../../projects/ui/routing/src/view.guard.ts","../../../projects/ui/routing/src/component-routes.token.ts","../../../projects/ui/routing/src/component-distributor.service.ts","../../../projects/ui/routing/src/route-chain.ts","../../../projects/ui/routing/src/resolve-route.ts"],"mappings":";;;;;;;;AAIA,cACa,aAAa;;AAIxB,kBAAc,KAAK;AAEnB,sBAAkB,KAAK;;AAGvB,gBAAY,KAAK;;AAMjB;AAIA;;;;;AAKG;AACH;yCAzBW,aAAa;6CAAb,aAAa;AA6BzB;;AC5BD;AACA,cAAa,eAAe;AAC5B;AACA,cAAa,gBAAgB;AAE7B;;;;;;;;;;;;;;AAcG;AACH,cACa,kBAAmB,YAAW,eAAe;AAG5C;AAFZ;AAEoB,+BAAe,aAAa;AAEhD,mBAAe,WAAW,iBAAiB,WAAW,GAAG,UAAU,CAAC,SAAS;yCALlE,kBAAkB;6CAAlB,kBAAkB;AAe9B;;ACpCD;;;;;;;;;;;;;;AAcG;AACH,cACa,SAAU,YAAW,WAAW;AAEzC;AACA;AACA;wBAFgB,MAAM,eACD,WAAW,QAClB,oBAAoB;wBAGhB,sBAAsB,SAAS,mBAAmB;6BAI7C,sBAAsB,SAAS,mBAAmB;AAI3E,mBAAeA,OAAO;AAItB;yCAnBW,SAAS;6CAAT,SAAS;AAgErB;;ACpFD;;;;AAIG;UACc,aAAa;;;;;;AAM5B,gBAAY,OAAO;AACnB;;;AAGG;AACH,0BAAsB,OAAO;AAC9B;AAED;;;;;AAKG;UACc,cAAc;;;;iBAIhB,OAAO,CAAC,IAAI;;eAEd,aAAa;AAExB;AAC0B;;;sBAGR,OAAO,CAAC,IAAI;;AAO/B;AAED;AACA,iBAAgB,iBAAiB,QAAQ,cAAc;AAIvD;AACA,cAAa,gBAAgB,SAAA,iBAAoB;AAEjD;AACA,iBAAgB,oBAAoB,QAAQ,cAAc,UAAU,OAAO,CAAC,IAAI;AAOhF,cAAa,gBAAgB,EAAA,cAAA,CAAA,cAAA;;ACpB7B;;;;;;AAMG;AACH,iBAAgB,gBAAgB;AAyBhC,cACa,2BAA2B;;AAItC;;;;;;AAMG;kCACyBC,EAAA,CAAA,cAAA;;AAG5B,8BAAsBA,EAAA,CAAA,cAAA;AAO4B,wBAAQ,cAAc;;AAKxE,4BAAwB,cAAc;AAShC,+EAA2E,OAAO,CAAC,IAAI;yCAnClF,2BAA2B;6CAA3B,2BAA2B;AA2DvC;;ACtID;;;;;AAKG;AAEH;AAC6E;AAC7E,iBAAgB,gBAAgB,SAAS,KAAK,yBAAyB,KAAK;AAY5E;AACyD;AACzD,iBAAgB,kBAAkB,SAAS,KAAK;AAYhD;;;;;AAKG;AACH,iBAAgB,iBAAiB,gBAChB,KAAK,4GAInB,KAAK;AAqBR;;;;;;;AAOG;AACH,iBAAgB,0BAA0B,gBACzB,KAAK,4GAInB,KAAK;;AC7ER;;;;;;AAMG;UACc,kBAAkB;AACjC;;AAEiE;AACjE,oBAAgB,KAAK;AACrB,wBAAoB,IAAI;AACzB;AAED,iBAAsB,iBAAiB,gBACtB,KAAK,2GAGP,2BAA2B,gBAEvC,OAAO,CAAC,kBAAkB;;","names":["NgRoute","_angular_core"]}

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

@@ -0,0 +1,143 @@
+import { PackageInfo } from '@trismegisto/spine';
+export { APP_PACKAGE_INFO, PackageInfo } from '@trismegisto/spine';
+import { Routes, Router } from '@angular/router';
+import { ComponentRoute } from '@trismegisto/spine/routing';
+import * as i0 from '@angular/core';
+import { EnvironmentProviders, OnInit } from '@angular/core';
+import { AuthorizationService, ViewService } from '@orfeu/angular/core';
+
+declare const APP_ROUTES: Routes;
+
+declare const PUBLIC_ROUTES: Routes;
+
+/**
+ * Quem desenha o conteúdo agora é o `hm-workspace` (ver `LayoutComponent`/
+ * `layout/src/workspace/`), nunca um `<router-outlet>` aninhado — a árvore de 6 níveis
+ * (header/navigation/menu/item/submenu/page) que existia aqui foi substituída por
+ * `resolveSpineRoute`, chamada por painel. Estas rotas só precisam existir pro `Router` real
+ * "reconhecer" a URL (deep link, F5, `router.navigateByUrl` do painel focado) e pro `ViewGuard`
+ * confirmar que ela resolve contra a view atual antes do painel tentar renderizá-la — `component`
+ * é só `EmptyRouteComponent` (o Angular exige um dos cinco em toda rota, `NG04014` senão; o
+ * `<router-outlet>` que o recebe fica escondido, ver `LayoutComponent`).
+ */
+declare const PRIVATE_ROUTES: Routes;
+
+/**
+ * Componentes que o próprio shell traz, ligados pelo `router_id` (web.router) da árvore de rotas do argos.
+ *
+ * As telas do antigo módulo "Sistema" (Sobre › Recursos/Informações; Preferências › Geral,
+ * Autenticação, Exibição, Notificações) saíram em 2026-09-29: viraram o painel de configurações
+ * (`@trismegisto/spine/layout` › `SettingsPanelComponent`, menu do perfil ou Ctrl+,). Os router_ids delas
+ * (d6a30f9c, 86b87583, 2d71fb9b, 48ebca20, 662a7a61, e7d9982b, bf8a9f69) não têm mais componente —
+ * o módulo precisa sair da árvore de rotas no seed do argos.
+ *
+ * O Início (`HomeComponent`) mudou pra `@trismegisto/spine/auto-service` -- ver a entrada legada abaixo.
+ */
+declare const BASE_COMPONENTS: ComponentRoute[];
+
+interface ShellOptions {
+    appComponents?: ComponentRoute[];
+    packageInfo?: PackageInfo;
+}
+declare function provideShell(options?: ShellOptions): EnvironmentProviders;
+
+/**
+ * Rota de retorno do Argos (`/callback?code&state` ou `?error`). Tudo passa pelo `handleCallback()` do
+ * `@orfeu/angular`, que confere state e verifier, troca o code e navega para a URL pedida antes do login
+ * (ou para a 1ª rota do `/view`).
+ *
+ * - `?error=login_required` (e afins) da reautorização silenciosa (`prompt=none`): o próprio
+ *   `handleCallback()` segue para o login interativo, mantendo a URL de retorno — a pessoa não fica parada aqui.
+ * - Callback inválido (state/nonce divergente, `?error`, sem code): NUNCA desloga. Com uma sessão viva
+ *   (callback repetido, voltar do navegador), segue para a URL de retorno; sem sessão, mostra a página de
+ *   erro com "Entrar novamente".
+ */
+declare class CallbackComponent {
+    protected readonly text: {
+        offline: string;
+        reconnecting: string;
+        reauthorizing: string;
+        reauthorizationRequired: string;
+        signInAgain: string;
+        callbackFailedHeading: string;
+        callbackFailedText: string;
+    };
+    private readonly route;
+    private readonly router;
+    private readonly auth;
+    /** `true` quando o callback falhou e não há sessão para onde voltar. */
+    protected readonly failed: i0.WritableSignal<boolean>;
+    /** Promessa do tratamento em andamento (exposta para os testes aguardarem). */
+    readonly done: Promise<void>;
+    constructor();
+    private handle;
+    protected signIn(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CallbackComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CallbackComponent, "app-callback", never, {}, {}, never, never, true, never>;
+}
+
+declare class LoginComponent implements OnInit {
+    private router;
+    private auth;
+    private view;
+    constructor(router: Router, auth: AuthorizationService, view: ViewService);
+    ngOnInit(): void;
+    bootstrap(): Promise<void>;
+    /** Primeira rota navegável (DFS), atravessando grupos "transparentes" sem route_redirect. */
+    private findFirstNavigable;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LoginComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<LoginComponent, "app-login", never, {}, {}, never, never, true, never>;
+}
+
+declare class LoggedOutComponent {
+    private authorizationService;
+    constructor(authorizationService: AuthorizationService);
+    goToLogin(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LoggedOutComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<LoggedOutComponent, "loggedout", never, {}, {}, never, never, true, never>;
+}
+
+declare class NoRightsComponent implements OnInit {
+    private viewService;
+    protected readonly text: {
+        blockedText: string;
+        blockedAction: string;
+        noRightsText: string;
+    };
+    constructor(viewService: ViewService);
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NoRightsComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NoRightsComponent, "no-rights", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * "Acesso bloqueado" (`/blocked`): a pessoa entrou, mas não faz parte de nenhum grupo vinculado a
+ * esta aplicação — o `ViewGuard` manda pra cá quando o token vem sem nenhum crachá (`badges`
+ * vazio), mesmo que o app tenha rotas públicas.
+ *
+ * Diferente de `/no-permission` (tem grupo, mas nenhuma rota liberada). A única ação útil aqui é
+ * sair — pra entrar com outra conta, ou depois que o administrador incluir a pessoa num grupo.
+ */
+declare class BlockedComponent implements OnInit {
+    protected readonly text: {
+        blockedText: string;
+        blockedAction: string;
+        noRightsText: string;
+    };
+    private readonly auth;
+    private readonly viewService;
+    constructor();
+    ngOnInit(): void;
+    protected logout(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BlockedComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BlockedComponent, "blocked", never, {}, {}, never, never, true, never>;
+}
+
+declare class LoadingPageComponent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<LoadingPageComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<LoadingPageComponent, "loading-page", never, {}, {}, never, never, true, never>;
+}
+
+export { APP_ROUTES, BASE_COMPONENTS, BlockedComponent, CallbackComponent, LoadingPageComponent, LoggedOutComponent, LoginComponent, NoRightsComponent, PRIVATE_ROUTES, PUBLIC_ROUTES, provideShell };
+export type { ShellOptions };
+//# sourceMappingURL=trismegisto-spine-shell.d.ts.map

package/types/trismegisto-spine-shell.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"trismegisto-spine-shell.d.ts","sources":["../../../projects/ui/shell/src/app.routes.ts","../../../projects/ui/shell/src/public.routes.ts","../../../projects/ui/shell/src/private.routes.ts","../../../projects/ui/shell/src/base-components.ts","../../../projects/ui/shell/src/provide-shell.ts","../../../projects/ui/shell/src/public/callback.component.ts","../../../projects/ui/shell/src/public/login.component.ts","../../../projects/ui/shell/src/public/loggedout/loggedout.component.ts","../../../projects/ui/shell/src/templates/no-rights/no-rights.component.ts","../../../projects/ui/shell/src/templates/blocked/blocked.component.ts","../../../projects/ui/shell/src/templates/loading-page/loading-page.component.ts"],"mappings":";;;;;;;;AAMA,cAAa,UAAU,EAAE,MAUxB;;ACVD,cAAa,aAAa,EAAE,MAa3B;;ACfD;;;;;;;;;AASG;AACH,cAAa,cAAc,EAAE,MAO5B;;ACnBD;;;;;;;;;;AAUG;AACH,cAAa,eAAe,EAAE,cAAc;;UCP3B,YAAY;AAC3B,oBAAgB,cAAc;kBAChB,WAAW;AAC1B;AAED,iBAAgB,YAAY,WAAU,YAAiB,GAAG,oBAAoB;;ACF9E;;;;;;;;;;AAUG;AACH,cAoBa,iBAAiB;;;;;;;;;AAC6B;AACzD;AACA;AACA;;AAGA,+BAAyBA,EAAA,CAAA,cAAA;;AAEzB,mBAAe,OAAO;;;;yCATX,iBAAiB;2CAAjB,iBAAiB;AAuC7B;;AC3ED,cAMa,cAAe,YAAW,MAAM;AAEzC;AACA;AACA;wBAFgB,MAAM,QACR,oBAAoB,QACpB,WAAW;AAG3B;iBAEe,OAAA;;AAYf;yCArBW,cAAc;2CAAd,cAAc;AAgC1B;;ACtCD,cAOa,kBAAkB;AACjB;AAAQ,sCAAsB,oBAAoB;;yCADnD,kBAAkB;2CAAlB,kBAAkB;AAG9B;;ACRD,cAOa,iBAAkB,YAAW,MAAM;AAGlC;;;;;AAF4C;AAEpC,6BAAa,WAAW;AAK5C;yCARW,iBAAiB;2CAAjB,iBAAiB;AAe7B;;ACtBD;;;;;;;AAOG;AACH,cAkBa,gBAAiB,YAAW,MAAM;;;;;AACW;AACxD;AACA;;AAOA;;yCAVW,gBAAgB;2CAAhB,gBAAgB;AAmB5B;;ACjDD,cAOa,oBAAoB;yCAApB,oBAAoB;2CAApB,oBAAoB;AAAG;;","names":["_angular_core"]}

package/types/trismegisto-spine-side-panel.d.ts

@@ -0,0 +1,66 @@
+import * as i0 from '@angular/core';
+import { Type, OnInit, ChangeDetectorRef } from '@angular/core';
+import { ModalContent } from '@trismegisto/spine/modal';
+export { ModalContent as SidePanelContent } from '@trismegisto/spine/modal';
+import { HermesLoadingState, ModalSize } from '@trismegisto/angular';
+import { Observable } from 'rxjs';
+
+interface SidePanelConfig<TData = any> {
+    title?: string;
+    size?: 'sm' | 'md' | 'lg' | 'xl' | 'full';
+    closable?: boolean;
+    text?: string;
+    component?: Type<ModalContent>;
+    data?: TData;
+    showActions?: boolean;
+}
+
+declare class SidePanelService {
+    private _visible;
+    readonly visible$: Observable<boolean>;
+    private _state;
+    readonly state$: Observable<HermesLoadingState>;
+    private _config;
+    get config(): SidePanelConfig | null;
+    private _result$;
+    open<TResult = any, TData = any>(config: SidePanelConfig<TData>): Observable<TResult | null>;
+    confirm(result: any): void;
+    close(): void;
+    setState(state: HermesLoadingState): void;
+    private dismiss;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SidePanelService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SidePanelService>;
+}
+
+/** `SidePanelConfig.size` manteve os valores do spine antigo (sm/md/lg/xl/full) por
+ * compatibilidade de API; o `hm-drawer` novo só tem 3 tamanhos. */
+declare function toHermesSize(size: SidePanelConfig['size']): ModalSize;
+declare class SidePanelComponent implements OnInit {
+    private sidePanelService;
+    private cdr;
+    /** Rótulos dos botões padrão, do catálogo do Hermes (pt-BR/en/es). */
+    protected readonly dialogText: {
+        confirm: string;
+        cancel: string;
+    };
+    private content;
+    visible: boolean;
+    config: SidePanelConfig | null;
+    state: HermesLoadingState;
+    protected readonly HermesLoadingState: typeof HermesLoadingState;
+    protected readonly toHermesSize: typeof toHermesSize;
+    private contentRef;
+    constructor(sidePanelService: SidePanelService, cdr: ChangeDetectorRef);
+    ngOnInit(): void;
+    get canConfirm(): boolean;
+    private loadComponent;
+    confirm(): void;
+    dismiss(): void;
+    onLoadingStateChange(state: HermesLoadingState): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SidePanelComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SidePanelComponent, "spine-side-panel", never, {}, {}, never, never, true, never>;
+}
+
+export { SidePanelComponent, SidePanelService };
+export type { SidePanelConfig };
+//# sourceMappingURL=trismegisto-spine-side-panel.d.ts.map

package/types/trismegisto-spine-side-panel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"trismegisto-spine-side-panel.d.ts","sources":["../../../projects/ui/side-panel/src/side-panel.types.ts","../../../projects/ui/side-panel/src/side-panel.service.ts","../../../projects/ui/side-panel/src/side-panel.component.ts"],"mappings":";;;;;;;AAGM,UAAW,eAAe;;;;;AAK9B,gBAAY,IAAI,CAAC,YAAY;;;AAG9B;;ACLD,cACa,gBAAgB;;AAE3B,uBAA0B,UAAU;;AAGpC,qBAAwB,UAAU,CAAC,kBAAkB;;AAGrD,kBAAqB,eAAe;;6CAMK,eAAe,UAAU,UAAU;AAY5E;AAMA;AAMA,oBAAgB,kBAAkB;AAIlC;yCA1CW,gBAAgB;6CAAhB,gBAAgB;AAgD5B;;AChDD;AACmE;AACnE,iBAAS,YAAY,OAAO,eAAe,WAAW,SAAS;AAU/D,cAMa,kBAAmB,YAAW,MAAM;AAenC;AAA4C;;;;;AAbO;;AAI/D;AACA,YAAQ,eAAe;WAChB,kBAAkB;AAEzB,kDAAqC,kBAAA;AACrC,4CAA+B,YAAA;;AAIX,kCAAkB,gBAAgB,OAAe,iBAAiB;AAEtF;;AAwBA;AAUA;AAMA;AAIA,gCAA4B,kBAAkB;yCA7DnC,kBAAkB;2CAAlB,kBAAkB;AAgE9B;;","names":[]}