@trismegisto/spine 2.0.0

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

@@ -0,0 +1,948 @@
+import { HttpParams } from '@angular/common/http';
+import * as _angular_core from '@angular/core';
+import { WritableSignal } from '@angular/core';
+import * as _trismegisto_spine_audit from '@trismegisto/spine/audit';
+import * as _trismegisto_primitives from '@trismegisto/primitives';
+import { PluralMessage, formatMessage, PaginationState } from '@trismegisto/primitives';
+import { SegmentedOption, FilterBarField, StateScreenSituation, DataGridColumn, FilterBarValue, TagColor } from '@trismegisto/angular';
+
+/**
+ * Leitura da auditoria (`audit.events`) do argos admin-server, nos dois escopos:
+ * - `admin`  → `GET {adminApi}/admin/audit/*` (painel central, todos os apps);
+ * - `client` → `GET {adminApi}/auto-service/:clientId/audit/*` (só os apps do projeto do client; o
+ *   servidor recorta, `app_id` de fora → 403).
+ * Endpoints: `actions`, `events`, `events/:id`, `traces/:traceId`, `stats` e `tops/:kind` (rankings paginados).
+ * Unidade: a leitura padrão é por AÇÃO (uma linha por trace: o evento raiz + agregados dos spans);
+ * `unit=events` nas agregações mantém a contagem por evento (registro).
+ * Formatos e filtros fixados pelo contrato do admin-server; tudo aqui é TypeScript puro (tipos +
+ * montagem da consulta).
+ */
+
+type AuditOutcome = 'success' | 'failure' | 'denied';
+type AuditMethod = 'read' | 'write' | 'delete' | 'stream';
+type AuditLevel = 'public' | 'private' | 'protected' | 'optional';
+type AuditPermissionResult = 'allowed' | 'forbidden' | 'unauthorized' | 'public';
+type AuditActorType = 'user' | 'app_token' | 'api_token' | 'public' | 'unauthenticated';
+declare const AUDIT_METHODS: readonly AuditMethod[];
+declare const AUDIT_OUTCOMES: readonly AuditOutcome[];
+/** Um evento como vem na lista (`GET .../audit/events`). Datas em ISO-8601 UTC. */
+interface AuditEvent {
+    event_id: string;
+    occurred_at: string;
+    duration_ms: number | null;
+    trace_id: string | null;
+    span_id: string | null;
+    parent_span_id: string | null;
+    /** `true` = a ação de entrada (feita pela pessoa); `false` = chamada entre apps dentro da cadeia. */
+    entry: boolean;
+    realm_id: string | null;
+    actor_type: AuditActorType | string | null;
+    user_id: string | null;
+    user_name: string | null;
+    token_id: string | null;
+    client_ip: string | null;
+    app_id: string | null;
+    app_name: string | null;
+    client_id: string | null;
+    route_id: string | null;
+    route_name: string | null;
+    operation_id: string | null;
+    operation_identifier: string | null;
+    operation_method: AuditMethod | string | null;
+    operation_level: AuditLevel | string | null;
+    operation_label: string | null;
+    target_type: string | null;
+    target_id: string | null;
+    permission_result: AuditPermissionResult | string | null;
+    outcome: AuditOutcome;
+    status: number | null;
+    message: string | null;
+}
+/** Unidade da leitura: `actions` (uma por trace, padrão) ou `events` (cada registro). */
+type AuditUnit = 'actions' | 'events';
+declare const AUDIT_UNITS: readonly AuditUnit[];
+/**
+ * Uma AÇÃO (`GET .../audit/actions`): os campos do evento raiz (entry=true) do trace, com os agregados
+ * dos spans do mesmo trace dentro da janela. `outcome` = o pior dos spans (denied > failure > success);
+ * `root_outcome` = o do próprio raiz. `orphan` = trace sem raiz na janela (a linha é o 1º span interno).
+ * No escopo `client`, spans de apps de fora não entram nos agregados, só em `hidden_count`.
+ */
+interface AuditAction extends AuditEvent {
+    root_outcome?: AuditOutcome;
+    orphan?: boolean;
+    span_count: number;
+    hidden_count?: number;
+    apps?: string[];
+    failures?: number;
+    denied?: number;
+}
+interface AuditActionPage {
+    items: AuditAction[];
+    next_cursor: string | null;
+}
+/** O evento completo (`GET .../audit/events/:eventId?occurred_at=`). */
+interface AuditEventDetail extends AuditEvent {
+    details?: unknown;
+    received_at?: string | null;
+    service_instance?: string | null;
+    sdk?: string | null;
+}
+interface AuditPage {
+    items: AuditEvent[];
+    next_cursor: string | null;
+}
+/** A cadeia (trace) recortada ao escopo do projeto; `hidden_count` = eventos de apps de fora. */
+interface AuditTrace {
+    items: AuditEvent[];
+    hidden_count?: number;
+}
+interface AuditStats {
+    total: number;
+    /** Com `tops=false` na consulta, `by_app`/`top_operations`/`top_users` vêm vazios (use `tops/:kind`). */
+    by_outcome: {
+        success: number;
+        failure: number;
+        denied: number;
+    };
+    by_app: {
+        app_id: string;
+        app_name: string | null;
+        total: number;
+        failures: number;
+        denied: number;
+    }[];
+    top_operations: {
+        operation_identifier: string | null;
+        operation_label: string | null;
+        app_name: string | null;
+        total: number;
+        failures: number;
+    }[];
+    top_users: {
+        user_id: string | null;
+        user_name: string | null;
+        total: number;
+    }[];
+    timeline: {
+        bucket: string;
+        total: number;
+        failures: number;
+        denied: number;
+    }[];
+}
+/** Os rankings paginados de `GET .../audit/tops/:kind`. */
+type AuditTopKind = 'apps' | 'operations' | 'users';
+declare const AUDIT_TOP_KINDS: readonly AuditTopKind[];
+/** Itens por página dos cards de ranking (o servidor aceita até 50). */
+declare const AUDIT_TOP_PAGE_SIZE = 5;
+/** Um item de ranking: os campos de identificação variam com o `kind`; contagens sempre presentes. */
+interface AuditTopItem {
+    total: number;
+    failures: number;
+    denied: number;
+    /** `apps` e `operations`. */
+    app_id?: string | null;
+    app_name?: string | null;
+    /** `operations`. */
+    operation_identifier?: string | null;
+    operation_label?: string | null;
+    /** `users`. */
+    user_id?: string | null;
+    user_name?: string | null;
+}
+/** Uma página de ranking; `total` = quantos itens (grupos) existem na consulta. */
+interface AuditTopPage {
+    items: AuditTopItem[];
+    total: number;
+}
+/** De onde a tela lê: o painel central (`admin`) ou o projeto de um client (`client`). */
+type SpineAuditScope = 'admin' | 'client';
+/**
+ * Base dos endpoints da auditoria para o escopo (sem barra no fim). `null` quando falta o necessário
+ * (sem `adminApi`, ou escopo `client` sem `clientId`).
+ */
+declare function auditApiBase(adminApi: string | null | undefined, scope: SpineAuditScope, clientId?: string | null): string | null;
+/** Lista de apps para o filtro: todos (`admin`, `GET /admin/apps`) ou os do projeto do client. */
+declare function auditAppsUrl(adminApi: string | null | undefined, scope: SpineAuditScope, clientId?: string | null): string | null;
+/** Filtros da query string (todos opcionais). `app_id` repete o parâmetro. */
+interface AuditQuery {
+    from?: string;
+    to?: string;
+    app_id?: readonly string[];
+    user_id?: string;
+    user?: string;
+    operation?: string;
+    method?: AuditMethod | string;
+    level?: AuditLevel | string;
+    outcome?: AuditOutcome | string;
+    permission_result?: AuditPermissionResult | string;
+    actor_type?: AuditActorType | string;
+    entry?: boolean;
+    trace_id?: string;
+    route_id?: string;
+    target_type?: string;
+    target_id?: string;
+    status?: number | string;
+    /** Agregações (stats/tops/daily): padrão do servidor = `actions`. Ignorado nas listas. */
+    unit?: AuditUnit;
+}
+/** Monta a query string: vazio/`null` some, lista repete a chave (`app_id=a&app_id=b`). */
+declare function auditParams(query: AuditQuery, page?: {
+    limit?: number;
+    cursor?: string | null;
+    offset?: number;
+}): HttpParams;
+/** Escolhas rápidas de período da tela. */
+type AuditPeriod = '1h' | '6h' | '24h' | '7d' | '30d';
+declare const AUDIT_PERIOD_MS: Readonly<Record<AuditPeriod, number>>;
+/** Janela máxima aceita pelo servidor (acima: 400 `range_too_large`). */
+declare const AUDIT_MAX_WINDOW_MS: number;
+/**
+ * Valor da faixa de filtros da tela (`hm-filter-bar`), por chave. `dates` é `{ start, end }` em
+ * AAAA-MM-DD (dia local); `app` é lista (multisseleção; aceita um id só); `entry` é booleano; o resto
+ * é texto.
+ */
+interface AuditFilterInput {
+    dates?: {
+        start: string | null;
+        end: string | null;
+    } | null;
+    app?: string | readonly string[] | null;
+    user?: string | null;
+    user_id?: string | null;
+    operation?: string | null;
+    method?: string | null;
+    level?: string | null;
+    outcome?: string | null;
+    permission_result?: string | null;
+    actor_type?: string | null;
+    status?: string | number | null;
+    trace_id?: string | null;
+    entry?: boolean | null;
+}
+type BuiltAuditQuery = {
+    ok: true;
+    query: AuditQuery;
+} | {
+    ok: false;
+    reason: 'range_too_large';
+};
+/**
+ * Período + filtros da tela → consulta do contrato. As datas da faixa (dia local inteiro) vencem a
+ * escolha rápida; o fim nunca passa de `now`. A janela vira `from`/`to` absolutos, então as páginas
+ * seguintes (cursor) e o resumo enxergam exatamente o mesmo intervalo.
+ */
+declare function buildAuditQuery(period: AuditPeriod, filters: AuditFilterInput, now: Date): BuiltAuditQuery;
+/**
+ * Lê as datas do servidor, que vêm em ISO UTC com MICROssegundos (`2026-10-05T13:18:40.564281Z`): o
+ * formato de data do ECMAScript só garante 3 casas, então a fração é cortada em milissegundos antes.
+ */
+declare function parseAuditDate(iso: string | null | undefined): Date | null;
+/** Maior `limit` aceito por `GET .../audit/events`. */
+declare const AUDIT_MAX_PAGE_SIZE = 200;
+/** Busca uma fatia da lista (`cursor` `null` = do começo). */
+type AuditPageFetcher = (cursor: string | null, limit: number) => Promise<AuditPage>;
+/** Uma página resolvida por `AuditCursorPager.page`. `offset` pode ser menor que o pedido (pedido além do fim). */
+interface AuditPagerResult {
+    items: AuditEvent[];
+    offset: number;
+    hasMore: boolean;
+}
+/**
+ * Paginação numerada ("página N de M") sobre a lista por cursor (keyset) do servidor, que não tem
+ * OFFSET. Guarda o cursor de cada posição já vista (posição 0 = sem cursor); para abrir uma página
+ * nunca vista, anda a partir da posição conhecida mais próxima em saltos de até 200 (o cursor só
+ * depende do último evento lido, não do `limit`). Vale para UMA consulta (`from`/`to` + filtros
+ * fixos): consulta nova = pager novo.
+ */
+declare class AuditCursorPager {
+    private readonly cursors;
+    /** Quantos eventos a consulta tem, quando a lista já chegou ao fim (`next_cursor` nulo). */
+    private endAt;
+    /** Total exato, conhecido depois de alguma página chegar ao fim da lista. */
+    get end(): number | null;
+    page(offset: number, size: number, fetch: AuditPageFetcher, retry?: boolean): Promise<AuditPagerResult>;
+}
+/**
+ * Total do rodapé: o exato quando a lista já chegou ao fim; senão o do resumo (`stats.total`, mesma
+ * consulta), nunca menor do que o que já se sabe existir (página atual + "tem mais").
+ */
+declare function auditPagerTotal(statsTotal: number | null | undefined, end: number | null, loaded: AuditPagerResult | null): number;
+/** Pior resultado (denied > failure > success) — o `outcome` de uma ação. */
+declare function worstOutcome(outcomes: readonly (string | null | undefined)[]): AuditOutcome;
+/** Um span na linha do tempo de uma ação (`buildSpanTimeline`). */
+interface AuditSpanRow {
+    event: AuditEvent;
+    /** Profundidade na hierarquia (parent_span_id → span_id); 0 = raiz(es). */
+    depth: number;
+    /** Início relativo ao 1º span, em ms. */
+    offsetMs: number;
+    /** Posição/largura da barra, em % da duração total (largura mínima para continuar visível). */
+    left: number;
+    width: number;
+}
+interface AuditSpanTimeline {
+    rows: AuditSpanRow[];
+    /** Do início do 1º span ao fim do último, em ms. */
+    totalMs: number;
+}
+/**
+ * Spans de um trace → linha do tempo: ordem em árvore (pai antes dos filhos, irmãos por início), com
+ * profundidade pela cadeia parent_span_id → span_id. Span cujo pai não está na lista (de fora do escopo,
+ * fora da janela) vira raiz. Fim do span = início + duration_ms (sem duração = instante).
+ */
+declare function buildSpanTimeline(items: readonly AuditEvent[]): AuditSpanTimeline;
+/** Código de erro do envelope do admin-server (`{ error, detail }`), quando houver. */
+declare function auditErrorCode(err: unknown): {
+    status: number;
+    code: string;
+    detail: string;
+};
+
+/**
+ * HTTP da auditoria (só leitura), igual nos dois escopos: cada método recebe a `base` já resolvida
+ * por `auditApiBase` (`{adminApi}/admin/audit` ou `{adminApi}/auto-service/:clientId/audit`). O
+ * recorte do escopo `client` é do servidor — nada aqui decide o que a pessoa pode ver.
+ */
+declare class SpineAuditService {
+    private readonly http;
+    private readonly auth;
+    private get headers();
+    events(base: string, query: AuditQuery, page?: {
+        limit?: number;
+        cursor?: string | null;
+    }): Promise<AuditPage>;
+    /** Uma linha por AÇÃO (raiz do trace + agregados dos spans), mesmos filtros/cursor de `events`. */
+    actions(base: string, query: AuditQuery, page?: {
+        limit?: number;
+        cursor?: string | null;
+    }): Promise<AuditActionPage>;
+    event(base: string, eventId: string, occurredAt: string): Promise<AuditEventDetail>;
+    /** `occurredAt` (opcional) = o do evento de origem: o servidor limita a busca da cadeia a ±1 dia dele. */
+    trace(base: string, traceId: string, occurredAt?: string | null): Promise<AuditTrace>;
+    /** Resumo (KPIs + linha do tempo). `tops: false` pula os rankings — a tela os pagina por `tops()`. */
+    stats(base: string, query: AuditQuery, opts?: {
+        tops?: boolean;
+    }): Promise<AuditStats>;
+    /** Um ranking paginado (`apps` | `operations` | `users`) com os mesmos filtros/janela do resumo. */
+    tops(base: string, kind: AuditTopKind, query: AuditQuery, page: {
+        offset: number;
+        limit: number;
+    }): Promise<AuditTopPage>;
+    /** Apps para o filtro (`{ apps: [{ id, name }] }` — `/admin/apps` ou `/auto-service/:clientId/apps`). */
+    apps(url: string): Promise<{
+        apps?: {
+            id: string;
+            name: string;
+        }[];
+    }>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SpineAuditService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<SpineAuditService>;
+}
+
+/** Uma linha de ranking já pronta para mostrar (o card não sabe de que tipo é). */
+interface AuditTopRow {
+    key: string;
+    name: string;
+    /** Texto secundário ao lado do nome (ex.: o app de uma operação). */
+    suffix?: string | null;
+    /** Dica (tooltip) do item — ex.: a descrição da operação. */
+    hint?: string | null;
+    total: number;
+    failures: number;
+    denied: number;
+    /** Sem como virar filtro (ex.: usuário sem nome nem id). */
+    disabled?: boolean;
+}
+/**
+ * Card de ranking da Auditoria ("Operações", "Usuários", "Por aplicação") com paginação compacta
+ * no servidor: `x–y de N` + anterior/próxima. Durante a troca de página as linhas atuais continuam
+ * (esmaecidas, `aria-busy`), sem esqueleto. A barra é proporcional ao `max` (o 1º item da 1ª página),
+ * então as páginas seguintes não "enchem" de novo. Clicar num item emite `picked` (vira filtro).
+ */
+declare class SpineAuditTopCardComponent {
+    readonly heading: _angular_core.InputSignal<string>;
+    readonly rows: _angular_core.InputSignal<readonly AuditTopRow[]>;
+    /** Quantos itens o ranking tem no total (todas as páginas). */
+    readonly total: _angular_core.InputSignal<number>;
+    readonly offset: _angular_core.InputSignal<number>;
+    readonly pageSize: _angular_core.InputSignal<number>;
+    /** Referência da barra (o maior total do ranking); 0 = o maior da página. */
+    readonly max: _angular_core.InputSignal<number>;
+    readonly loading: _angular_core.InputSignal<boolean>;
+    readonly failed: _angular_core.InputSignal<boolean>;
+    readonly picked: _angular_core.OutputEmitterRef<AuditTopRow>;
+    /** Novo `offset` pedido (anterior/próxima). */
+    readonly offsetChange: _angular_core.OutputEmitterRef<number>;
+    private readonly messages;
+    protected readonly text: {
+        title: string;
+        intro: string;
+        tabApps: string;
+        period: string;
+        periodLastHour: string;
+        period24h: string;
+        period7d: string;
+        period30d: string;
+        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;
+        kpiShare: string;
+        kpis: string;
+        timeline: string;
+        timelineSummary: string;
+        bucketSummary: string;
+        timelineEmpty: string;
+        topOperations: string;
+        topUsers: string;
+        topApps: string;
+        noTop: string;
+        eventCount: PluralMessage;
+        failureCount: PluralMessage;
+        deniedCount: PluralMessage;
+        filterBy: string;
+        eventsCaption: string;
+        colWhen: string;
+        colApp: string;
+        colUser: string;
+        colOperation: string;
+        colMethod: string;
+        colOutcome: string;
+        colStatus: string;
+        colDuration: string;
+        durationMs: string;
+        pageItems: string;
+        pageSize: string;
+        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;
+        openTraceEvent: string;
+        introAdmin: string;
+        period6h: string;
+        refresh: string;
+        autoRefresh: string;
+        updatedAt: string;
+        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;
+        forbiddenAdmin: string;
+        invalidFilter: string;
+        kpiFilterHint: string;
+        topsRange: string;
+        topsPrevious: string;
+        topsNext: string;
+        topsError: string;
+        filterByTrace: string;
+        unitLabel: string;
+        unitActions: string;
+        unitEvents: string;
+        kpiTotalActions: string;
+        kpiTotalActionsDescription: string;
+        timelineSummaryActions: string;
+        bucketSummaryActions: string;
+        timelineEmptyActions: string;
+        actionsCaption: string;
+        pageItemsActions: string;
+        pageErrorActions: string;
+        emptyTitleActions: string;
+        colSpans: string;
+        spansApps: string;
+        spansHidden: PluralMessage;
+        actionDetailHeading: string;
+        orphanNote: string;
+        orphanTag: string;
+        spansHeading: string;
+        spansSummary: string;
+        spanRow: string;
+    };
+    private readonly locale;
+    protected readonly fmt: typeof formatMessage;
+    protected readonly headingId: string;
+    private readonly reference;
+    protected readonly range: _angular_core.Signal<string>;
+    protected go(direction: -1 | 1): void;
+    /** Fatia (em % da própria barra) de falhas/negados dentro do total da linha. */
+    protected share(part: number, total: number): number;
+    protected bar(total: number): number;
+    protected number(n: number): string;
+    protected plural(message: PluralMessage, count: number): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SpineAuditTopCardComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SpineAuditTopCardComponent, "spine-audit-top-card", never, { "heading": { "alias": "heading"; "required": true; "isSignal": true; }; "rows": { "alias": "rows"; "required": true; "isSignal": true; }; "total": { "alias": "total"; "required": false; "isSignal": true; }; "offset": { "alias": "offset"; "required": false; "isSignal": true; }; "pageSize": { "alias": "pageSize"; "required": false; "isSignal": true; }; "max": { "alias": "max"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "failed": { "alias": "failed"; "required": false; "isSignal": true; }; }, { "picked": "picked"; "offsetChange": "offsetChange"; }, never, never, true, never>;
+}
+
+/** Eventos por página da tabela, de saída (o servidor aceita até 200 — `AUDIT_MAX_PAGE_SIZE`). */
+declare const AUDIT_PAGE_SIZE = 10;
+/** Opções do seletor de eventos por página (todas dentro do `limit` máximo do servidor). */
+declare const AUDIT_PAGE_SIZES: readonly number[];
+/** Intervalo da atualização automática (opcional, desligada por padrão). */
+declare const AUDIT_AUTO_REFRESH_MS = 30000;
+interface AuditApp {
+    id: string;
+    name: string;
+}
+interface DetailField {
+    label: string;
+    value: string;
+    code?: boolean;
+}
+interface TimelineBar {
+    key: string;
+    summary: string;
+    ok: number;
+    fail: number;
+    denied: number;
+}
+type ErrorKind = 'range' | 'forbidden' | 'invalid' | 'generic';
+/** Estado de um card de ranking (página atual + total no servidor). */
+interface TopState {
+    items: readonly AuditTopItem[];
+    total: number;
+    offset: number;
+    /** O maior total do ranking (1º item da 1ª página) — referência da barra nas páginas seguintes. */
+    max: number;
+    loading: boolean;
+    failed: boolean;
+}
+/**
+ * A tela de Auditoria — a MESMA no auto-serviço e no painel central do argos admin. Só muda o escopo:
+ * - `scope="client"` + `clientId`: `{adminApi}/auto-service/:clientId/audit/*`, apps do projeto do client
+ *   (recorte feito no servidor);
+ * - `scope="admin"`: `{adminApi}/admin/audit/*`, todos os apps (guard `admin:audit:*` no servidor).
+ * `adminApi` vem do input ou do `SPINE_ADMIN_API` (que o `provideAutoService` já fornece).
+ *
+ * Unidade: por padrão a tela lê AÇÕES (`GET .../actions`, uma linha por trace, coluna "Spans", detalhe
+ * com os spans numa linha do tempo); o alternador "Ações | Eventos" volta à leitura por registro. KPIs,
+ * linha do tempo e rankings seguem a unidade escolhida (`unit=` nas agregações).
+ *
+ * Conteúdo: período rápido (ou datas da faixa de filtros, que vencem), filtros, KPIs (falhas/negados
+ * clicáveis viram filtro), linha do tempo, 3 rankings paginados no servidor (`tops/:kind`), a tabela
+ * paginada no servidor (cursor) e o detalhe/cadeia (trace) de um evento.
+ *
+ * Recarga sem piscar: trocar de página (ou atualizar) mantém as linhas atuais à vista com um indicador
+ * por cima — a grade só mostra esqueleto na 1ª carga. Toda resposta carrega um número de sequência e a
+ * que chega fora de ordem (página/consulta já trocada) é descartada.
+ *
+ * Importe só de código carregado sob demanda (rota lazy, `import()`): o ponto `@trismegisto/spine/audit`
+ * existe para a tela não entrar no bundle inicial de quem só usa o resto do spine.
+ */
+declare class SpineAuditComponent {
+    /** `admin` = painel central (todos os apps); `client` = apps do projeto do `clientId`. */
+    readonly scope: _angular_core.InputSignal<SpineAuditScope>;
+    /** Obrigatório com `scope="client"`. */
+    readonly clientId: _angular_core.InputSignal<string | null>;
+    /** Base do argos admin-server; sem ele, vale o `SPINE_ADMIN_API`. */
+    readonly adminApi: _angular_core.InputSignal<string | null>;
+    private readonly service;
+    private readonly tokenApi;
+    private readonly messages;
+    protected readonly text: {
+        title: string;
+        intro: string;
+        tabApps: string;
+        period: string;
+        periodLastHour: string;
+        period24h: string;
+        period7d: string;
+        period30d: string;
+        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;
+        kpiShare: string;
+        kpis: string;
+        timeline: string;
+        timelineSummary: string;
+        bucketSummary: string;
+        timelineEmpty: string;
+        topOperations: string;
+        topUsers: string;
+        topApps: string;
+        noTop: string;
+        eventCount: PluralMessage;
+        failureCount: PluralMessage;
+        deniedCount: PluralMessage;
+        filterBy: string;
+        eventsCaption: string;
+        colWhen: string;
+        colApp: string;
+        colUser: string;
+        colOperation: string;
+        colMethod: string;
+        colOutcome: string;
+        colStatus: string;
+        colDuration: string;
+        durationMs: string;
+        pageItems: string;
+        pageSize: string;
+        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;
+        openTraceEvent: string;
+        introAdmin: string;
+        period6h: string;
+        refresh: string;
+        autoRefresh: string;
+        updatedAt: string;
+        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;
+        forbiddenAdmin: string;
+        invalidFilter: string;
+        kpiFilterHint: string;
+        topsRange: string;
+        topsPrevious: string;
+        topsNext: string;
+        topsError: string;
+        filterByTrace: string;
+        unitLabel: string;
+        unitActions: string;
+        unitEvents: string;
+        kpiTotalActions: string;
+        kpiTotalActionsDescription: string;
+        timelineSummaryActions: string;
+        bucketSummaryActions: string;
+        timelineEmptyActions: string;
+        actionsCaption: string;
+        pageItemsActions: string;
+        pageErrorActions: string;
+        emptyTitleActions: string;
+        colSpans: string;
+        spansApps: string;
+        spansHidden: PluralMessage;
+        actionDetailHeading: string;
+        orphanNote: string;
+        orphanTag: string;
+        spansHeading: string;
+        spansSummary: string;
+        spanRow: string;
+    };
+    private readonly locale;
+    protected readonly fmt: typeof formatMessage;
+    /** Base dos endpoints do escopo; muda → tudo recomeça (filtros, página, detalhe). */
+    protected readonly base: _angular_core.Signal<string | null>;
+    private readonly appsUrl;
+    protected readonly period: WritableSignal<AuditPeriod>;
+    /** Ações (uma linha por trace) ou eventos (cada registro). */
+    protected readonly unit: WritableSignal<AuditUnit>;
+    protected readonly byActions: _angular_core.Signal<boolean>;
+    protected readonly unitOptions: readonly SegmentedOption[];
+    /** Textos que mudam com a unidade. */
+    protected readonly unitText: _angular_core.Signal<{
+        kpiTotal: string;
+        kpiTotalDescription: string;
+        timelineSummary: string;
+        bucketSummary: string;
+        timelineEmpty: string;
+        caption: string;
+        pageItems: string;
+        pageError: string;
+        emptyTitle: string;
+    }>;
+    protected readonly filterValue: WritableSignal<Readonly<Record<string, _trismegisto_primitives.FilterBarFieldValue>>>;
+    protected readonly apps: WritableSignal<readonly AuditApp[]>;
+    protected readonly stats: WritableSignal<AuditStats | null>;
+    protected readonly events: WritableSignal<readonly AuditEvent[]>;
+    protected readonly loading: WritableSignal<boolean>;
+    protected readonly pageLoading: WritableSignal<boolean>;
+    protected readonly pageFailed: WritableSignal<boolean>;
+    protected readonly pageState: WritableSignal<PaginationState>;
+    protected readonly pageSizes: readonly number[];
+    /** A página mostrada (posição + "tem mais") e o total exato quando a lista já chegou ao fim. */
+    private readonly loaded;
+    private readonly listEnd;
+    /** Total do rodapé da tabela. */
+    protected readonly total: _angular_core.Signal<number>;
+    protected readonly errorKind: WritableSignal<ErrorKind | null>;
+    private readonly errorDetail;
+    protected readonly lastUpdated: WritableSignal<Date | null>;
+    protected readonly autoRefresh: WritableSignal<boolean>;
+    /** Esqueleto da grade só quando ainda não há linha nenhuma para mostrar (1ª carga). */
+    protected readonly gridSkeleton: _angular_core.Signal<boolean>;
+    /** Recarga com linhas à vista: elas ficam, com o indicador por cima. */
+    protected readonly gridBusy: _angular_core.Signal<boolean>;
+    protected readonly tops: Readonly<Record<AuditTopKind, WritableSignal<TopState>>>;
+    protected readonly topPageSize = 5;
+    protected readonly detailOpen: WritableSignal<boolean>;
+    protected readonly selected: WritableSignal<AuditEventDetail | null>;
+    protected readonly detailLoading: WritableSignal<boolean>;
+    protected readonly detailFailed: WritableSignal<boolean>;
+    protected readonly trace: WritableSignal<AuditTrace | null>;
+    /** A ação aberta (linha da tabela por ações): agregados que o detalhe do evento raiz não traz. */
+    protected readonly selectedAction: WritableSignal<AuditAction | null>;
+    /** O detalhe mostra a ação (o raiz dela), não um span qualquer da cadeia. */
+    protected readonly showingAction: _angular_core.Signal<boolean>;
+    /** Resultado do cabeçalho do detalhe: o da ação (pior dos spans) ou o do evento. */
+    protected readonly headOutcome: _angular_core.Signal<_trismegisto_spine_audit.AuditOutcome | undefined>;
+    /** Os spans da cadeia numa linha do tempo (hierarquia por parent_span_id). */
+    protected readonly spanTimeline: _angular_core.Signal<AuditSpanTimeline | null>;
+    protected readonly traceLoading: WritableSignal<boolean>;
+    protected readonly traceFailed: WritableSignal<boolean>;
+    /** Consulta da última carga — a troca de página usa a mesma (mesma janela absoluta). */
+    private query;
+    /** Cursores da consulta atual (consulta nova = pager novo). */
+    private pager;
+    /** Descartam respostas velhas (consulta/página/ranking/detalhe já trocados). */
+    private seq;
+    private pageSeq;
+    private detailSeq;
+    private readonly topSeq;
+    protected readonly periodOptions: readonly SegmentedOption[];
+    /** Há mais de um app à vista: coluna, filtro e ranking "por aplicação" aparecem. */
+    protected readonly multiApp: _angular_core.Signal<boolean>;
+    /** As datas da faixa estão valendo (a escolha rápida fica sem efeito). */
+    protected readonly customDates: _angular_core.Signal<boolean>;
+    protected readonly hasFilters: _angular_core.Signal<boolean>;
+    protected readonly selectedOutcome: _angular_core.Signal<string | null>;
+    protected readonly storageKey: _angular_core.Signal<string>;
+    protected readonly filterFields: _angular_core.Signal<FilterBarField[]>;
+    protected readonly errorSituation: _angular_core.Signal<StateScreenSituation>;
+    protected readonly errorText: _angular_core.Signal<string>;
+    protected readonly empty: _angular_core.Signal<boolean>;
+    protected readonly columns: _angular_core.Signal<DataGridColumn<AuditEvent>[]>;
+    protected readonly rowId: (e: AuditEvent) => string;
+    protected readonly timelineBars: _angular_core.Signal<TimelineBar[]>;
+    protected readonly timelineEdges: _angular_core.Signal<{
+        from: string;
+        to: string;
+    } | null>;
+    protected readonly hasTimeline: _angular_core.Signal<boolean>;
+    protected readonly topOperationRows: _angular_core.Signal<AuditTopRow[]>;
+    protected readonly topUserRows: _angular_core.Signal<AuditTopRow[]>;
+    protected readonly topAppRows: _angular_core.Signal<AuditTopRow[]>;
+    protected readonly detailFields: _angular_core.Signal<DetailField[]>;
+    protected readonly detailsJson: _angular_core.Signal<string>;
+    constructor();
+    private readonly router;
+    private urlConsumed;
+    /** Filtros/evento da query string (`from`, `to` ISO; `app_id` repetível; demais filtros pelo nome). */
+    private readUrlState;
+    protected setPeriod(value: string): void;
+    protected setUnit(value: string): void;
+    protected setFilters(value: FilterBarValue): void;
+    private firstPage;
+    protected clearFilters(): void;
+    /** Clique num item de ranking ou atalho: vira filtro (soma aos que já estão). */
+    protected filterBy(key: keyof AuditFilterInput, value: string | readonly string[] | null | undefined): void;
+    protected pickTop(kind: AuditTopKind, row: AuditTopRow): void;
+    /** KPI "Falhas"/"Negados" clicável: liga/desliga o filtro de resultado. */
+    protected toggleOutcome(outcome: 'failure' | 'denied', on: boolean): void;
+    /** Recarrega resumo, rankings e a página atual com a janela recalculada (`now` novo, cursores descartados). */
+    reload(): Promise<void>;
+    /** Rodapé da tabela mudou de página ou de itens por página: busca só aquela página, mesma consulta. */
+    changePage(state: PaginationState): Promise<void>;
+    /** Card de ranking pediu outra página (mesma consulta da última carga). */
+    loadTop(kind: AuditTopKind, offset: number): Promise<void>;
+    private fetcher;
+    private showPage;
+    private clearData;
+    /** Clique numa linha da tabela: por ação abre o raiz e já carrega os spans; por evento, só o evento. */
+    protected openRow(row: AuditEvent): void;
+    /** Abre uma ação: o detalhe do evento raiz + a linha do tempo dos spans (trace) carregada junto. */
+    openAction(action: AuditAction): Promise<void>;
+    /** Abre o detalhe com o resumo da linha e completa com o evento inteiro. Da cadeia, mantém a cadeia. */
+    openEvent(event: AuditEvent, keepTrace?: boolean): Promise<void>;
+    showTrace(): Promise<void>;
+    /** "Filtrar a tabela por este trace" (do detalhe): fecha o detalhe e aplica o filtro. */
+    protected filterByTrace(traceId: string | null): void;
+    protected onDetailOpenChange(open: boolean): void;
+    private closeDetail;
+    private loadApps;
+    private setError;
+    protected number(n: number): string;
+    protected plural(message: PluralMessage, count: number): string;
+    protected share(part: number): string;
+    protected dateTime(iso: string | null | undefined): string;
+    protected time(iso: string): string;
+    protected clock(d: Date): string;
+    /** Rótulo do intervalo da linha do tempo: hora no dia, dia+hora até 3 dias, só o dia acima. */
+    private bucketTime;
+    protected duration(ms: number | null | undefined): string;
+    protected userName(e: {
+        user_name: string | null;
+        user_id?: string | null;
+    }): string;
+    /** Rótulo acessível de uma linha da linha do tempo dos spans. */
+    protected spanAria(row: AuditSpanRow): string;
+    /** Dica da célula "Spans": aplicações envolvidas (+ spans de fora do escopo). */
+    protected spansHint(a: AuditAction): string;
+    /** Nome da operação = o identificador (a descrição é complemento: dica e detalhe). */
+    protected operationName(e: {
+        operation_label: string | null;
+        operation_identifier: string | null;
+    }): string;
+    protected methodLabel(method: string | null | undefined): string;
+    protected levelLabel(level: string | null | undefined): string;
+    protected permissionLabel(result: string | null | undefined): string;
+    protected actorLabel(actor: string | null | undefined): string;
+    protected outcomeLabel(outcome: string | null | undefined): string;
+    protected outcomeColor(outcome: string | null | undefined): TagColor;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SpineAuditComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SpineAuditComponent, "spine-audit", never, { "scope": { "alias": "scope"; "required": true; "isSignal": true; }; "clientId": { "alias": "clientId"; "required": false; "isSignal": true; }; "adminApi": { "alias": "adminApi"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+export { AUDIT_AUTO_REFRESH_MS, AUDIT_MAX_PAGE_SIZE, AUDIT_MAX_WINDOW_MS, AUDIT_METHODS, AUDIT_OUTCOMES, AUDIT_PAGE_SIZE, AUDIT_PAGE_SIZES, AUDIT_PERIOD_MS, AUDIT_TOP_KINDS, AUDIT_TOP_PAGE_SIZE, AUDIT_UNITS, AuditCursorPager, SpineAuditComponent, SpineAuditService, SpineAuditTopCardComponent, auditApiBase, auditAppsUrl, auditErrorCode, auditPagerTotal, auditParams, buildAuditQuery, buildSpanTimeline, parseAuditDate, worstOutcome };
+export type { AuditAction, AuditActionPage, AuditActorType, AuditEvent, AuditEventDetail, AuditFilterInput, AuditLevel, AuditMethod, AuditOutcome, AuditPage, AuditPageFetcher, AuditPagerResult, AuditPeriod, AuditPermissionResult, AuditQuery, AuditSpanRow, AuditSpanTimeline, AuditStats, AuditTopItem, AuditTopKind, AuditTopPage, AuditTopRow, AuditTrace, AuditUnit, BuiltAuditQuery, SpineAuditScope };
+//# sourceMappingURL=trismegisto-spine-audit.d.ts.map