@engramind/client 0.0.0-stage → 0.1.1

package/dist/react.d.ts

@@ -0,0 +1,1687 @@
+import * as react from 'react';
+import { ReactNode, CSSProperties } from 'react';
+import { LucideIcon } from 'lucide-react';
+import { z } from 'zod';
+import * as _tanstack_react_query from '@tanstack/react-query';
+import { QueryKey } from '@tanstack/react-query';
+import { BackgroundVariant } from '@xyflow/react';
+
+declare class EngramindError extends Error {
+    readonly status: number;
+    readonly code: string;
+    readonly details?: unknown;
+    /** Segundos de `Retry-After` (429). */
+    readonly retryAfter: number | null;
+    constructor(status: number, message: string, code: string, details?: unknown, retryAfter?: number | null);
+}
+
+type HttpMethod = "get" | "post" | "put" | "patch" | "delete";
+type Params$1 = Record<string, string | number | boolean | undefined | null>;
+/**
+ * Fonte de dados dos componentes: o caminho é o mesmo do REST do Engramind sem o `/v1`
+ * (`channels`, `memories/m_1/pin`). O navegador nunca chama o Engramind direto: a fonte padrão
+ * (`createHttpDataSource`) chama o proxy montado pelo app.
+ */
+interface EngramindDataSource {
+    request<T>(method: HttpMethod, path: string, options?: {
+        params?: Params$1;
+        body?: unknown;
+        signal?: AbortSignal;
+    }): Promise<T>;
+}
+interface HttpDataSourceOptions {
+    /** Prefixo das rotas do proxy no app (ex.: `/api/engramind`). */
+    basePath: string;
+    /** Desembrulha a resposta (padrão: `{ success, data }` → `data`; outro JSON passa como está). */
+    unwrap?: (json: unknown) => unknown;
+    headers?: Record<string, string> | (() => Record<string, string>);
+    fetch?: typeof fetch;
+    credentials?: RequestCredentials;
+}
+/** Erro de uma resposta do proxy: `{ success: false, error, code, details }` ou `{ error: { code, message } }`. */
+declare function errorFromResponse(status: number, json: unknown, retryAfter?: string | null): EngramindError;
+declare function createHttpDataSource(options: HttpDataSourceOptions): EngramindDataSource;
+/** Código estável de um erro (`ENGRAMIND_CHANNEL_SHARED`...). */
+declare function apiErrorCode(error: unknown): string | undefined;
+/** Mensagem pt-BR de um erro, com um texto padrão. */
+declare function apiErrorMessage(error: unknown, fallback?: string): string;
+/** Status HTTP de um erro. */
+declare const apiErrorStatus: (error: unknown) => number | undefined;
+
+/** Título e dica de um canal quando a ponta do slug não é legível (ex.: id da central). */
+interface ChannelLabel {
+    /** Texto destacado no lugar da ponta final do slug (ex.: a sigla `OPE`). */
+    title: string;
+    /** Dica ao passar o mouse no título (ex.: o nome do repositório). */
+    hint: string;
+}
+/** Partes exibidas do nome de um canal: prefixo discreto, título e a dica (quando houver rótulo). */
+declare function channelNameParts(slug: string, labels?: ReadonlyMap<string, ChannelLabel>): {
+    prefix: string;
+    title: string;
+    hint: string | null;
+};
+/**
+ * Slug do canal para exibir numa linha (chips, legendas, trilha, opções de filtro): canal de central com
+ * a ponta trocada pela sigla (`agentes/desenvolvedor/central/OPE`); sem rótulo, o slug como está.
+ * Helper único (OPE-113): todo lugar que mostra um canal usa este.
+ */
+declare function channelDisplayName(slug: string, labels?: ReadonlyMap<string, ChannelLabel>): string;
+/** Dica do canal exibido: nome do repositório e o slug inteiro (quando há rótulo); senão o slug. */
+declare function channelDisplayHint(slug: string, labels?: ReadonlyMap<string, ChannelLabel>): string;
+
+/** Evento ao vivo entregue pelo SSE da lib (`event: engramind`). */
+interface LiveEvent {
+    /** `id` do webhook (ausente nos eventos gerados pelo próprio app). */
+    id?: string;
+    type: string;
+    channel?: string | null;
+    memoryIds?: string[];
+    keys?: string[];
+    agent?: string | null;
+    app?: string | null;
+    consumption?: string;
+    operation?: string;
+    titleIds?: string[];
+    contextVersion?: string;
+    at?: string;
+}
+/**
+ * Consumo agrupado (um por `consumption`): o formato que a rede anima. `channels` são os canais que
+ * entregaram memórias (um evento por canal), `delivered` idem.
+ */
+interface ConsumptionEvent {
+    /** Agente que leu (`app/agente`). */
+    agent: string;
+    kind: "context" | "search";
+    channels: string[];
+    delivered: string[];
+    memoryIds: string[];
+    titleIds?: string[];
+    version?: string;
+    /** Id do consumo no Engramind (`cns_…`). */
+    consumption?: string;
+    operation?: string;
+}
+
+/** Tipos da rede "universo de partículas" do Engramind (OPE-109), independentes da origem dos dados. */
+type MemoryStatus = "active" | "permanent" | "archived";
+interface NetworkMemory {
+    id: string;
+    channel: string;
+    title: string;
+    text: string;
+    category: string;
+    status: MemoryStatus;
+    version: number;
+    createdAt: string;
+    updatedAt: string;
+    /** `retrieval_count` do Engramind (buscas). */
+    retrievals: number;
+    /** `injected_count` do Engramind (entradas no contexto). */
+    injections: number;
+    lastRetrievedAt: string | null;
+    verifiedAt: string | null;
+    /** `stale_candidate`: candidata a esquecimento pelo consolidador. */
+    stale: boolean;
+    author: string | null;
+    /** Agente autor (`app/agente`, `author.agent` do Engramind); `null` = gravada sem agente (dono, Mentor, app). */
+    authorAgent?: string | null;
+    /** Memória escrita pelo dono (listas dos agentes em `/integracoes/ia`). */
+    fromOwner?: boolean;
+    /** Quem gravou, quando não foi o dono (Mentor, agente): o selo de origem da antiga lista. */
+    originLabel?: string;
+}
+interface NetworkAgent {
+    /** `app/agente`. */
+    id: string;
+    app: string;
+    /** Nome sem o prefixo "Agente". */
+    name: string;
+}
+interface NetworkChannel {
+    slug: string;
+    name: string;
+    archived: boolean;
+}
+type SubscriptionMode = "inject" | "search" | "manage";
+interface NetworkLink {
+    id: string;
+    agent: string;
+    channel: string;
+    mode: SubscriptionMode;
+}
+
+type UniverseRef = {
+    kind: "channel";
+    slug: string;
+} | {
+    kind: "agent";
+    id: string;
+};
+
+declare const PARTICLE_MIN_PX = 10;
+declare const PARTICLE_MAX_PX = 34;
+/** Fixada nunca some: brilho mínimo visível. */
+declare const PINNED_MIN_BRIGHTNESS = 0.25;
+/** Padrão do Engramind para `consolidation.stale_after_days` (quando a configuração não vem). */
+declare const DEFAULT_STALE_AFTER_DAYS = 90;
+/** "Agente Opex" → "Opex" (os nodes mostram o nome sem o prefixo). */
+declare function agentDisplayName(name: string): string;
+/** Relevância: consultas + injeções somadas. */
+declare const memoryUses: (memory: Pick<NetworkMemory, "retrievals" | "injections">) => number;
+/**
+ * Último uso: o maior entre a última recuperação no Engramind (`last_retrieved_at`) e a criação. A verificação
+ * do consolidador (`verified_at`) não é consumo e não conta.
+ */
+declare function lastUseOf(memory: Pick<NetworkMemory, "id" | "lastRetrievedAt" | "createdAt">): string;
+/** Data de uso real (sem cair na criação): `null` = "nunca usada". */
+declare function lastRealUseOf(memory: Pick<NetworkMemory, "id" | "lastRetrievedAt">): string | null;
+/** Tamanho pela soma de consultas e injeções, em escala logarítmica suave relativa ao universo. */
+declare function particleSize(uses: number, maxUses: number): number;
+/**
+ * Brilho de 1 (usada agora) a 0 (cinza), linear até o prazo `stale_after_days` do consolidador.
+ * Candidata a esquecimento → 0; inativa → 0; fixada nunca fica abaixo do mínimo visível.
+ */
+declare function particleBrightness(input: {
+    status: MemoryStatus;
+    stale: boolean;
+    lastUse: string;
+}, staleAfterDays: number, now?: number): number;
+/** Cor final da partícula: a cor do canal apagada em direção ao cinza conforme perde brilho. */
+declare function particleColor(base: string, brightness: number): string;
+/** Cor do canal com mais memórias do universo (e de todo universo de um canal só). */
+declare const PRIMARY_CHANNEL_COLOR = "var(--color-primary)";
+declare function stableHash(text: string): number;
+/**
+ * Token `--chart-N` do tema. O shadcn/ui traz `--chart-1..5`: o `--chart-6` cai numa variação do
+ * `--chart-3` quando o app não o define (sem cor fixa).
+ */
+declare const chartToken: (index: number) => string;
+/**
+ * Cor de cada canal: a cor base (`--chart-2..6`) vem só do slug (o mesmo canal tem sempre a mesma
+ * cor). Quando mais de um canal cai na mesma base, os seguintes (em ordem de slug) ganham variações de
+ * tom da mesma cor.
+ */
+declare function channelColors(slugs: readonly string[]): Map<string, string>;
+/** Só as cores dos canais de um universo, a partir do mapa de TODOS os canais (a cor não muda entre universos). */
+declare function pickChannelColors(all: ReadonlyMap<string, string>, slugs: readonly string[]): Map<string, string>;
+/**
+ * Cores de um universo: cada canal com a sua cor estável (do mapa `base` ou do slug) e o canal com mais
+ * memórias (todas, inclusive inativas; empate pelo slug, a ordem da legenda "Por canal") com o roxo
+ * primário. Canais do mapa sem memórias entram com a cor estável. Sem memórias, nenhum fica roxo.
+ */
+declare function universeChannelColors(base: ReadonlyMap<string, string> | undefined, memories: readonly Pick<NetworkMemory, "channel">[]): Map<string, string>;
+/**
+ * Nome do canal em duas partes: o prefixo até a última `/` (linha discreta) e a ponta final (o
+ * título destacado). Canais com o mesmo começo (`agentes/desenvolvedor/…`) passam a se distinguir.
+ */
+declare function splitChannelSlug(slug: string): {
+    prefix: string;
+    leaf: string;
+};
+/** O alvo da assinatura (exato ou prefixo `eng/projeto-*`) alcança o canal? */
+declare function subscriptionReaches(target: string, isPrefix: boolean, slug: string): boolean;
+interface SubscriptionInput {
+    id: string;
+    agent: string;
+    target: string;
+    isPrefix: boolean;
+    mode: SubscriptionMode;
+    /** Canais ativos que o alvo alcança (`reaches` do Engramind). */
+    reaches: readonly string[];
+}
+/**
+ * Um link por canal casado em cada assinatura: os ativos pelo `reaches` do Engramind e, com
+ * "Mostrar arquivados", os arquivados casados localmente. Só canais visíveis; prefixo sem canal não gera link.
+ */
+declare function subscriptionLinks(subscriptions: readonly SubscriptionInput[], channels: readonly NetworkChannel[], includeArchived: boolean): NetworkLink[];
+interface Point {
+    x: number;
+    y: number;
+}
+interface Rect {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+/** Zoom mínimo do enquadramento inicial no celular: os nomes continuam legíveis. */
+declare const MOBILE_FIT_MIN_ZOOM = 0.5;
+/**
+ * Enquadramento com zoom mínimo (celular): se caber o retângulo inteiro com zoom ≥ `minZoom`, devolve
+ * `null` (enquadra normalmente); senão, centraliza no meio do retângulo com `minZoom` (o resto fica a
+ * um arrastar). Sem tamanho medido do quadro, `null`.
+ */
+declare function minZoomCenter(bounds: Rect, size: {
+    width: number;
+    height: number;
+}, minZoom: number): {
+    x: number;
+    y: number;
+    zoom: number;
+} | null;
+/**
+ * Tamanho visível do card da memória: o natural (largura fixa, altura do conteúdo) limitado ao quadro
+ * menos `margin` de cada lado. Sem quadro medido, o natural.
+ */
+declare function memoryCardSize(natural: {
+    width: number;
+    height: number;
+}, canvas: {
+    width: number;
+    height: number;
+}, margin?: number): {
+    width: number;
+    height: number;
+};
+/**
+ * Posição (canto superior esquerdo, em px da tela) do card que substitui a partícula: centralizado
+ * sobre ela e empurrado para dentro do canvas, com `margin` de folga em todas as bordas.
+ */
+declare function clampCardRect(anchor: Point, card: {
+    width: number;
+    height: number;
+}, canvas: {
+    width: number;
+    height: number;
+}, margin?: number): Point;
+declare const UNIVERSE_FIRST_RADIUS = 150;
+declare const UNIVERSE_RING_GAP = 58;
+declare const UNIVERSE_SLOT = 46;
+/**
+ * Universo: órbitas concêntricas em volta do centro (0,0) pela idade (criação): as mais novas nas
+ * órbitas internas, as mais antigas (e as de data inválida) nas externas.
+ */
+declare function layoutUniverse(memories: readonly Pick<NetworkMemory, "id" | "createdAt">[]): Map<string, Point>;
+/** Vagas de um anel (≈ `UNIVERSE_SLOT` px entre vizinhas). */
+declare const universeRingCapacity: (ring: number) => number;
+/**
+ * Quantas memórias em cada anel: o número de anéis é o mínimo que comporta todas, e elas são
+ * distribuídas proporcionalmente às vagas de cada anel (maior resto), para o último anel não ficar
+ * quase vazio (50 memórias: ~12/17/21 em vez de 20/28/2).
+ */
+declare function universeRingCounts(total: number): number[];
+/** Deslocamento do hover: as demais partículas se afastam levemente da focada. */
+declare function repelOffset(from: Point, focus: Point, strength?: number, radius?: number): Point;
+/** Link partícula ↔ centro destacado: só no universo do agente, quando ele escreveu a memória. */
+declare function isAuthoredByCenter(memory: Pick<NetworkMemory, "authorAgent">, center: {
+    kind: "channel" | "agent";
+    id: string;
+}): boolean;
+/** Janela em que uma memória nova conta como "acabou de ser criada" (partícula de criação). */
+declare const AGENT_WRITE_WINDOW_MS: number;
+interface AgentWrite {
+    id: string;
+    agent: string;
+    channel: string;
+}
+/**
+ * Criações por agente entre os ids que acabaram de aparecer: só memórias com agente autor
+ * (`authorAgent`) criadas há pouco. Ids que só apareceram agora por outro motivo (Mostrar arquivados,
+ * filtro de app, memória movida) não contam.
+ */
+declare function agentWritesOf(fresh: readonly string[], memories: readonly Pick<NetworkMemory, "id" | "authorAgent" | "channel" | "createdAt">[], now?: number): AgentWrite[];
+/** Pesos da fusão da busca do Engramind (`search.vector_weight`, `search.text_weight`, `search.rrf_k`). */
+interface SearchFusion {
+    vectorWeight: number;
+    textWeight: number;
+    k: number;
+}
+declare const DEFAULT_SEARCH_FUSION: SearchFusion;
+/** Acertos de um ramo sozinho que ainda destacam: as primeiras posições (as mais próximas pelo sentido). */
+declare const SEARCH_SINGLE_BRANCH_TOP = 3;
+/**
+ * Ids que a busca destaca. O ramo vetorial do Engramind não tem limiar: devolve as memórias mais
+ * próximas até o `limit`, mesmo sem relação com o termo, e com poucas memórias elas são todas. No modo
+ * `hybrid`, destacam as que os dois ramos encontraram (sentido e texto) e as que um ramo sozinho pôs
+ * nas `SEARCH_SINGLE_BRANCH_TOP` primeiras posições: score ≥ `max(peso) / (k + top)`. Como o acerto dos
+ * dois ramos vale no mínimo `(pesoV + pesoT) / (k + limit)`, ele sempre passa. No modo `text`, todas.
+ */
+declare function relevantSearchIds(results: readonly {
+    score: number;
+    memory: {
+        id: string;
+    };
+}[], mode: "hybrid" | "text", fusion?: SearchFusion): string[];
+interface UniverseStats {
+    active: number;
+    inactive: number;
+    pinned: number;
+    uses: number;
+    lastUse: string | null;
+    forgotten: number;
+    byChannel: {
+        slug: string;
+        count: number;
+    }[];
+}
+/** Números do card de estatísticas de um universo (canal ou agente). */
+declare function universeStats(memories: readonly NetworkMemory[], brightness: ReadonlyMap<string, number>): UniverseStats;
+/** Alcance de cada agente: memórias somadas dos canais ligados a ele. */
+declare function agentReach(links: readonly NetworkLink[], countByChannel: ReadonlyMap<string, number>): Map<string, number>;
+
+/**
+ * Layout da visão inicial da rede do Engramind (OPE-113, puro). Duas distribuições, escolhidas na
+ * legenda do diagrama:
+ * - `by-agent` ("Canais junto dos agentes", padrão): o canal de um agente só orbita esse agente; o
+ *   canal compartilhado fica entre os agentes que o usam (no centroide deles);
+ * - `agents-center` ("Agentes no centro"): agentes num círculo no meio e canais em anéis em volta, cada
+ *   canal no ângulo médio dos agentes que o usam.
+ * Os cards (os mesmos de sempre) crescem com as memórias (`overviewScale`) e nunca se sobrepõem: um
+ * afastamento determinístico separa o que encostar, e o círculo cresce enquanto sobrar sobreposição.
+ * Os links são curvas suaves de centro a centro: minimizam cruzamentos, sem garantia absoluta.
+ */
+type OverviewLayoutMode = "by-agent" | "agents-center";
+declare const OVERVIEW_LAYOUT_MODES: readonly ["by-agent", "agents-center"];
+declare const DEFAULT_OVERVIEW_LAYOUT: OverviewLayoutMode;
+declare const OVERVIEW_LAYOUT_LABEL: Record<OverviewLayoutMode, string>;
+/** Caixa dos cards em escala 1 (pílula do agente até 180 px; card do canal até 288 px, `max-w-72`). */
+declare const OVERVIEW_AGENT_BOX: {
+    width: number;
+    height: number;
+};
+declare const OVERVIEW_CHANNEL_BOX: {
+    width: number;
+    height: number;
+};
+/** Faixa de escala dos cards pela quantidade de memórias (log). */
+declare const OVERVIEW_SCALE_MIN = 0.85;
+declare const OVERVIEW_SCALE_MAX = 1.6;
+/** Folga mínima entre dois cards. */
+declare const OVERVIEW_PADDING = 16;
+/** Folga do enquadramento inicial em cada lado (fração do tamanho). */
+declare const OVERVIEW_FIT_MARGIN = 0.1;
+/** Curvatura dos links (fração do comprimento, para o lado). */
+declare const OVERVIEW_LINK_BEND = 0.12;
+interface OverviewLayoutInput {
+    agents: readonly {
+        id: string;
+        app: string;
+    }[];
+    channels: readonly {
+        slug: string;
+    }[];
+    /** Assinaturas visíveis (agente → canal). */
+    links: readonly {
+        agent: string;
+        channel: string;
+    }[];
+    /** Memórias por agente (alcance) e por canal: o tamanho dos cards. */
+    agentCounts?: ReadonlyMap<string, number>;
+    channelCounts?: ReadonlyMap<string, number>;
+    mode?: OverviewLayoutMode;
+}
+interface OverviewLayout {
+    agents: Map<string, Point>;
+    channels: Map<string, Point>;
+    /** Escala de cada card (`agent:<id>` / `channel:<slug>`). */
+    scales: Map<string, number>;
+    /** Caixa de cada card já escalada. */
+    boxes: Map<string, {
+        width: number;
+        height: number;
+    }>;
+    mode: OverviewLayoutMode;
+}
+/** Escala do card pela quantidade de memórias, em log entre `OVERVIEW_SCALE_MIN` e `OVERVIEW_SCALE_MAX`. */
+declare function overviewScale(count: number, max: number): number;
+/** Distribui agentes e canais (ver o topo do arquivo). Mesmo resultado para a mesma entrada. */
+declare function layoutOverview(input: OverviewLayoutInput): OverviewLayout;
+/** Menor distância entre os centros de duas caixas, na direção `angle`, para não se tocarem (com a folga). */
+declare function clearDistance(a: {
+    width: number;
+    height: number;
+}, b: {
+    width: number;
+    height: number;
+}, angle: number): number;
+/** Link agente → canal: curva quadrática suave de centro a centro. */
+declare function overviewLinkPath(source: Point, target: Point, bend?: number): string;
+/** Meio da curva do link (rótulo do modo). */
+declare function overviewLinkMidpoint(source: Point, target: Point, bend?: number): Point;
+/** Enquadramento inicial: a caixa de todos os cards escalados, com `OVERVIEW_FIT_MARGIN` de folga. */
+declare function overviewInitialBounds(layout: Pick<OverviewLayout, "agents" | "channels" | "boxes">): Rect | null;
+
+/**
+ * Textos da lib (pt-BR). O app sobrescreve qualquer chave pelo `messages` do `EngramindProvider`; chave
+ * ausente usa o texto padrão. `{nome}` é trocado pelo valor correspondente.
+ */
+declare const DEFAULT_MESSAGES: {
+    readonly "network.channelNotFound": "Canal não encontrado: voltando à rede.";
+    readonly "network.agentNotFound": "Agente não encontrado: voltando à rede.";
+    readonly "network.appNotFound": "App não encontrado: voltando à rede.";
+    readonly "network.searchFailed": "Não foi possível buscar as memórias.";
+    readonly "network.backToNetwork": "Voltar à rede";
+    readonly "network.noApps.title": "Nenhum app no Engramind";
+    readonly "network.noApps.description": "Crie um app e os agentes dele para ver a rede.";
+    readonly "network.noAgents.title": "Este app não tem agentes ativos";
+    readonly "network.noAgents.description": "Crie ou ative um agente deste app na configuração do Engramind.";
+    readonly "network.noLinkedChannels.title": "Os agentes deste app não assinam nenhum canal com memórias";
+    readonly "network.noLinkedChannels.description": "Canais sem memórias ficam fora da rede. Assine um canal ou grave uma memória num canal assinado.";
+    readonly "network.configure": "Configurar";
+    readonly "network.layout": "Distribuição da rede";
+    readonly "network.newMemory": "Nova memória";
+    readonly "network.agentEmpty": "Nenhuma memória nos canais deste agente";
+    readonly "network.agentNoChannels": "Este agente não assina nenhum canal";
+    readonly "state.configure.title": "Reconfigure o Engramind";
+    readonly "state.configure.description": "O Engramind recusou o token do app. Peça um novo token ao gestor e reconfigure o servidor do app.";
+    readonly "state.noAccess.title": "Sem acesso";
+    readonly "state.noAccess.description": "O token do app não alcança este registro.";
+    readonly "state.retry": "Tentar novamente";
+    readonly "config.agents.title": "Agentes";
+    readonly "config.channels.title": "Canais";
+    readonly "config.tokens.title": "Tokens de agente";
+    readonly "config.webhook.title": "Webhook do app";
+    readonly "config.empty.agents": "Nenhum agente neste app.";
+    readonly "config.newAgent": "Novo agente";
+    readonly "config.newChannel": "Novo canal";
+    readonly "config.webhook.url": "URL do webhook";
+    readonly "config.webhook.save": "Salvar webhook";
+    readonly "config.webhook.remove": "Remover webhook";
+    readonly "config.webhook.rotate": "Gerar novo segredo";
+    readonly "config.webhook.saved": "Webhook do app atualizado.";
+    readonly "config.webhook.secretOnce": "Copie o segredo agora: ele não aparece de novo. Configure-o no servidor do app para validar a assinatura.";
+    readonly "config.webhook.configured": "Segredo configurado";
+    readonly "config.webhook.notConfigured": "Sem webhook: a rede atualiza só pelas próprias ações e ao reconsultar.";
+};
+type MessageKey = keyof typeof DEFAULT_MESSAGES;
+type Messages = Record<MessageKey, string>;
+type PartialMessages = Partial<Messages>;
+declare function mergeMessages(overrides?: PartialMessages): Messages;
+
+/**
+ * Navegação dos componentes (`?universo=`, `?app=`, links internos). O app pode passar as funções do
+ * próprio roteador (`navigation` no provider, ex.: Next.js); o padrão usa o History API do navegador.
+ */
+interface EngramindRouter {
+    push(url: string, options?: {
+        scroll?: boolean;
+    }): void;
+    replace(url: string, options?: {
+        scroll?: boolean;
+    }): void;
+}
+interface NavigationAdapter {
+    useRouter: () => EngramindRouter;
+    usePathname: () => string;
+    useSearchParams: () => {
+        get(name: string): string | null;
+        toString(): string;
+    };
+}
+/** Navegação padrão pelo History API (sem roteador). */
+declare const historyNavigation: NavigationAdapter;
+
+/**
+ * `app`: o token do próprio app (o app, os agentes dele e os canais que eles alcançam), sem funções de
+ * gestor. `manager`: só para o gestor da rede (token admin), libera a visão Apps x canais.
+ */
+type EngramindMode = "app" | "manager";
+interface EngramindHrefs {
+    /** Página da rede (os parâmetros `?app=` e `?universo=` são acrescentados). */
+    network: string;
+    /** Página de detalhe de um canal; `null` esconde o link "Abrir página do canal". */
+    channel: ((slug: string) => string) | null;
+}
+interface RenderLinkProps {
+    href: string;
+    children?: ReactNode;
+    className?: string;
+    [key: string]: unknown;
+}
+interface FooterContext {
+    /** Distribuição da visão inicial (só fora dos universos). */
+    layout?: {
+        value: OverviewLayoutMode;
+        onChange: (value: OverviewLayoutMode) => void;
+    };
+}
+/** Para onde levar o "Configurar". */
+type ConfigureTarget = "connection" | "identities";
+interface EngramindConfig {
+    mode: EngramindMode;
+    /** Slug do app do token (modo app); a visão inicial é a rede Agentes x canais dele. */
+    app: string | null;
+    /** Nome exibido do app no modo app (padrão: o slug). */
+    appName?: string;
+    /** URL do SSE da lib montado pelo app (`createSseHandler`); `null` desliga o tempo real. */
+    events: string | null;
+    navigation: NavigationAdapter;
+    renderLink?: (props: RenderLinkProps) => ReactNode;
+    hrefs: EngramindHrefs;
+    /** Ícone de cada agente (`app/agente`); padrão: robô. */
+    agentIcon: (agent: string) => LucideIcon;
+    /** Gravações por agente que o app conhece (selo "gravadas" do node do agente). */
+    agentWrites?: (agent: string) => {
+        total: number;
+        last7d: number;
+    } | null;
+    /** Rótulos legíveis de canais (título e dica no lugar da ponta do slug). */
+    channelLabels: ReadonlyMap<string, ChannelLabel>;
+    messages: Messages;
+    /** Prazo de desuso fixo (sobrepõe o do Engramind). */
+    staleAfterDays?: number;
+    /**
+     * Ação "Configurar": `connection` (token recusado ou sem conexão, card do fim da página) ou `identities`
+     * (nenhum app, app sem agentes ativos).
+     */
+    onConfigure?: (target?: ConfigureTarget) => void;
+    /** Conteúdo extra: o fim da página da rede e o detalhe do canal. */
+    slots: {
+        footer?: (context: FooterContext) => ReactNode;
+        channelDetail?: (slug: string) => ReactNode;
+    };
+    /** Prefixo das chaves do `localStorage` (filtros da rede); vazio usa a chave sem prefixo. */
+    storagePrefix: string;
+}
+declare function useEngramindConfig(): EngramindConfig;
+/** `true` no modo gestor (Apps x canais, apps e configurações globais). */
+declare const useIsManager: () => boolean;
+/** Texto pt-BR (ou o sobrescrito pelo app) de uma chave do dicionário. */
+declare function useT(): (key: keyof Messages, vars?: Record<string, string | number>) => string;
+
+/**
+ * Toasts da lib: delegam ao `notify` do `EngramindProvider` (o app liga ao seu sistema de toasts, como o
+ * `sonner`). Sem `notify`, nada aparece. Mesma forma do `sonner` (`toast.success(...)`).
+ */
+type NotifyKind = "success" | "error" | "info" | "warning";
+type Notify = (kind: NotifyKind, message: string, options?: {
+    description?: string;
+    id?: string | number;
+}) => void;
+
+interface EngramindProviderProps {
+    /** Fonte de dados: o proxy da lib montado pelo app (`createHttpDataSource({ basePath })`). */
+    dataSource: EngramindDataSource;
+    /** `app` (padrão): token do próprio app. `manager`: só para o gestor da rede (token admin). */
+    mode?: EngramindMode;
+    /** URL do SSE da lib (`createSseHandler`); sem ela, a tela atualiza só pelas próprias ações e ao reconsultar. */
+    events?: string | null;
+    /** Slug do app do token (modo app); sem ele, a lib lê de `whoami`. */
+    app?: string | null;
+    /** Nome exibido do app (modo app). */
+    appName?: string;
+    /** Toasts do app (ex.: `sonner`). */
+    notify?: Notify;
+    /** Navegação do roteador do app (ex.: `next/navigation`); padrão: History API. */
+    navigation?: NavigationAdapter;
+    /** Link interno do app (ex.: `next/link`); padrão: `<a>`. */
+    renderLink?: (props: RenderLinkProps) => ReactNode;
+    hrefs?: Partial<EngramindHrefs>;
+    agentIcon?: (agent: string) => LucideIcon;
+    agentWrites?: (agent: string) => {
+        total: number;
+        last7d: number;
+    } | null;
+    channelLabels?: ReadonlyMap<string, ChannelLabel>;
+    /** Textos sobrescritos (chave ausente usa o padrão pt-BR). */
+    messages?: PartialMessages;
+    staleAfterDays?: number;
+    onConfigure?: (target?: ConfigureTarget) => void;
+    slots?: {
+        footer?: (context: FooterContext) => ReactNode;
+        channelDetail?: (slug: string) => ReactNode;
+    };
+    storagePrefix?: string;
+    children: ReactNode;
+}
+/**
+ * Raiz dos componentes do Engramind. O app monta dentro do próprio `QueryClientProvider` (TanStack Query)
+ * e do próprio login: o provider só leva a fonte de dados (o proxy), o SSE e os adaptadores do app.
+ * Uma fonte de dados por página: dois providers com fontes diferentes na mesma tela usam a última montada.
+ */
+declare function EngramindProvider(props: EngramindProviderProps): react.JSX.Element;
+
+/**
+ * Conexão SSE compartilhada por URL (`EventSource`), com contagem de referências. Quando cai, reconecta
+ * com espera crescente (1 s → 30 s) e avisa os ouvintes `onReconnect` (a tela relê o que pode ter perdido).
+ */
+type Listener = (event: LiveEvent) => void;
+type StatusListener = (connected: boolean) => void;
+interface LiveSubscription {
+    onEvent?: Listener;
+    onReconnect?: () => void;
+    onStatus?: StatusListener;
+}
+/** Assina o SSE em `url`; devolve a função que cancela a assinatura. */
+declare function subscribeLive(url: string, subscription: LiveSubscription): () => void;
+
+/**
+ * Rede do Engramind: no modo gestor, a visão inicial Apps x canais e a visão Agentes x canais de um app
+ * (`?app=`); no modo app, a visão inicial é a rede Agentes x canais do próprio app. Universo do canal e
+ * universo do agente (`?universo=`), com a gestão de canais e memórias. As redes escondem os canais sem
+ * nenhuma memória (lista "Sem memórias (N)").
+ */
+declare function EngramindNetwork({ onConfigure }: {
+    onConfigure?: () => void;
+}): react.JSX.Element;
+
+/** Aparência calculada de uma partícula de memória (módulo puro, OPE-109). */
+interface ParticleVisual {
+    id: string;
+    size: number;
+    /** Cor final (a do canal apagada pelo brilho). */
+    color: string;
+    /** Cor do canal, sem o brilho. */
+    baseColor: string;
+    brightness: number;
+    uses: number;
+    /** Data usada no brilho (cai na criação). */
+    lastUse: string;
+    /** Último uso real (`null` = nunca usada). */
+    lastRealUse: string | null;
+    pinned: boolean;
+    archived: boolean;
+}
+/** Crescimento local por consumo ao vivo, até a releitura dos contadores. */
+declare const LIVE_BUMP_PX = 2;
+/**
+ * Escala relativa ao universo visível: cor pelo canal (`channelColors`, de `universeChannelColors`;
+ * sem mapa, o roxo primário), tamanho logarítmico pelo uso e brilho pelo prazo do consolidador. A escala considera todas as memórias do
+ * universo, inclusive as que a busca apaga (o destaque não recalcula nada).
+ */
+declare function buildParticles(memories: readonly NetworkMemory[], options: {
+    channelColors?: ReadonlyMap<string, string>;
+    staleAfterDays: number;
+    bumps?: Record<string, number>;
+    now?: number;
+}): Map<string, ParticleVisual>;
+
+/** Ações do card da memória; a origem dos dados (Engramind bruto ou listas dos agentes) decide como gravar. */
+interface MemoryCardActions {
+    onActive: (memory: NetworkMemory, active: boolean) => void;
+    onPin: (memory: NetworkMemory, pinned: boolean) => void;
+    onEdit: (memory: NetworkMemory) => void;
+    onDelete: (memory: NetworkMemory) => void;
+    onMove?: (memory: NetworkMemory) => void;
+    onHistory?: (memory: NetworkMemory) => void;
+    /** Somente leitura (ex.: canal arquivado). */
+    readOnly?: boolean;
+}
+
+/**
+ * Remoções confirmadas nesta tela (excluir ou mover): o universo não avisa "excluída por outra origem"
+ * quando a memória aberta sai por uma ação daqui. A marca entra só na **confirmação** (cancelar o
+ * diálogo não marca), sai se a ação falhar e é esquecida quando o item deixa o universo.
+ */
+interface LocalRemovals {
+    mark: (id: string) => void;
+    forget: (id: string) => void;
+    has: (id: string) => boolean;
+}
+declare function useLocalRemovals(): LocalRemovals;
+
+interface UniverseCenter {
+    kind: "channel" | "agent";
+    /** Slug do canal ou `app/agente`. */
+    id: string;
+    label: string;
+    archived?: boolean;
+}
+interface MemoryUniverseProps {
+    center: UniverseCenter;
+    memories: NetworkMemory[];
+    staleAfterDays: number;
+    /** Cor estável de cada canal (universo do agente); o universo marca o maior canal com o roxo primário. */
+    channelColors?: Map<string, string>;
+    /** Destaque da busca/filtros (`null` = sem filtro). */
+    isMatch?: ((memory: NetworkMemory) => boolean) | null;
+    actions: MemoryCardActions;
+    /** Assinantes do canal (universo do canal). */
+    subscribers?: number;
+    /** Releitura dos dados: zera o crescimento local do consumo ao vivo. */
+    dataVersion?: number;
+    onCreate?: (() => void) | null;
+    /** Botão de criar no canto (universo com memórias); vazio mostra a ação no estado vazio. */
+    createLabel?: string;
+    emptyTitle?: string;
+    className?: string;
+    /** Memória provisória da lista otimista (`pendente-…`): a definitiva que a substitui não nasce de novo. */
+    isProvisional?: (id: string) => boolean;
+    /** Remoções confirmadas nesta tela (sem o aviso de "outra origem" quando a memória aberta sai). */
+    localRemovals?: LocalRemovals;
+}
+/**
+ * Universo de um canal ou de um agente (OPE-109): o node central e uma partícula por memória, em
+ * órbitas (mais novas mais perto), com a cor do canal (o com mais memórias no roxo primário), tamanho pelo
+ * uso e brilho pelo último uso. Clique ou toque abre o card (passar o mouse só afasta as vizinhas); o
+ * consumo ao vivo pulsa a memória e manda uma partícula ao centro. No universo do agente, o link tem a
+ * cor do canal e é destacado nas memórias que ele escreveu (OPE-113).
+ */
+declare function MemoryUniverse({ center, memories, staleAfterDays, channelColors, isMatch, actions, subscribers, dataVersion, onCreate, createLabel, emptyTitle, className, isProvisional, localRemovals, }: MemoryUniverseProps): react.JSX.Element;
+
+/**
+ * Formatos devolvidos pela API do Engramind (contrato 0.12.0, `docs/openapi.json` do repositório
+ * `nandobfer/engramind`). Só os campos que a lib usa; o resto passa adiante sem tipagem.
+ */
+interface Ref {
+    id: string;
+    slug: string;
+}
+interface EngramindAgent {
+    id: string;
+    slug: string;
+    qualified_slug: string;
+    name: string;
+    description: string | null;
+    app: Ref;
+    created_at: string;
+    disabled_at: string | null;
+}
+interface Category {
+    key: string;
+    label: string;
+    priority: number;
+}
+interface EngramindChannel {
+    id: string;
+    slug: string;
+    name: string;
+    description: string | null;
+    priority: number;
+    version: number;
+    created_at: string;
+    archived_at: string | null;
+}
+interface EngramindSubscription {
+    id: string;
+    agent: Ref & {
+        qualified_slug?: string;
+    };
+    target: string;
+    is_prefix: boolean;
+    mode: "inject" | "search" | "manage";
+    access: string[] | null;
+    priority: number | null;
+    reaches: string[];
+    created_at: string;
+}
+interface Author {
+    app: string | null;
+    app_id: string | null;
+    agent: string | null;
+    agent_id: string | null;
+}
+interface EngramindMemory {
+    id: string;
+    channel: string;
+    channel_id: string;
+    title: string | null;
+    title_state: "pending" | "ready" | "fallback";
+    text: string;
+    category: string;
+    status: "active" | "permanent" | "archived";
+    version: number;
+    author: Author;
+    origin?: {
+        source: string;
+        label?: string | null;
+    } | null;
+    embedding_state: "pending" | "ready" | "failed" | "off";
+    retrieval_count: number;
+    /** Entradas no contexto (gravado em lote; pode atrasar alguns segundos). */
+    injected_count?: number;
+    last_retrieved_at?: string | null;
+    verified_at?: string | null;
+    /** Sem uso há mais de `consolidation.stale_after_days` (candidata a esquecimento). */
+    stale_candidate?: boolean;
+    importance?: number | null;
+    created_at: string;
+    updated_at: string;
+    archived_at: string | null;
+}
+/** `get_consumer_settings`: o que a interface do consumidor precisa sem token admin. */
+interface ConsumerSettings {
+    memory: {
+        text_min: number;
+        text_max: number;
+    };
+    limits: {
+        max_batch: number;
+    };
+    context: {
+        budget_tokens: number;
+        titles_budget_tokens: number;
+        default_format: string;
+        text_max_chars: number;
+    };
+    channels: {
+        channel: string;
+        memory_text_max: number;
+        budget_tokens: number;
+        category_priorities: Record<string, number>;
+        text_max_chars: number;
+    }[];
+    /**
+     * Prazo de desuso e pesos da busca: pedidos ao Engramind para o modo app (ver
+     * `docs/engramind-consumer-settings.md`). Até lá a lib usa os padrões (90 dias, 1/1/60).
+     */
+    consolidation?: {
+        stale_after_days?: number;
+    };
+    search?: {
+        vector_weight?: number;
+        text_weight?: number;
+        rrf_k?: number;
+    };
+}
+
+/**
+ * Painel lateral do canal (menu "⋯" ou botão direito no node): Editar (slug imutável), Assinantes,
+ * o conteúdo extra do app (`slots.channelDetail`, ex.: as configurações do canal no gestor) e
+ * Arquivar / Restaurar / Excluir de vez (só arquivado), com confirmação. No modo app, o Engramind só
+ * deixa o token de app arquivar e restaurar os canais que ele criou (`409 CHANNEL_SHARED` nos outros):
+ * editar e excluir de vez são do gestor e não aparecem.
+ */
+declare function ChannelPanel({ channel, onOpenChange, onDeleted }: {
+    channel: EngramindChannel | null;
+    onOpenChange: (open: boolean) => void;
+    onDeleted?: (slug: string) => void;
+}): react.JSX.Element;
+
+/**
+ * Rótulos legíveis dos canais (título no lugar da ponta do slug e a dica): os de `value` ou os do
+ * `channelLabels` do provider (o app calcula os dele, ex.: a sigla de um repositório).
+ */
+declare function ChannelLabelsProvider({ value, children }: {
+    value?: ReadonlyMap<string, ChannelLabel>;
+    children: React.ReactNode;
+}): react.JSX.Element;
+/** Rótulos dos canais de central (fora do `ChannelLabelsProvider`, um mapa vazio: o slug como está). */
+declare function useChannelLabels(): ReadonlyMap<string, ChannelLabel>;
+/** Nome legível de um canal numa linha (`channelDisplayName`), com o slug e o repositório na dica. */
+declare function ChannelDisplayName({ slug, className }: {
+    slug: string;
+    className?: string;
+}): react.JSX.Element;
+declare const SIZES: {
+    readonly node: {
+        readonly prefix: "text-[10px]";
+        readonly title: "text-sm";
+    };
+    readonly center: {
+        readonly prefix: "text-[10px]";
+        readonly title: "text-sm";
+    };
+    readonly legend: {
+        readonly prefix: "text-[9px]";
+        readonly title: "text-xs";
+    };
+};
+/**
+ * Nome do canal em duas linhas: o prefixo até a última `/` discreto em cima e a ponta final como
+ * título destacado (canal de central: a sigla do repositório, com o nome na dica). O slug inteiro
+ * aparece ao passar o mouse.
+ */
+declare function ChannelName({ slug, size, className, titleClassName }: {
+    slug: string;
+    size?: keyof typeof SIZES;
+    className?: string;
+    titleClassName?: string;
+}): react.JSX.Element;
+
+/**
+ * Skeleton com as dimensões da rede: área do canvas (mesmo fundo), a visão inicial na distribuição
+ * padrão (agentes em volta do centro, cada um com os seus canais em órbita, OPE-113) e o card de
+ * estatísticas (a barra fica fora da carga). No celular, o card aparece recolhido (o botão do canto),
+ * como na rede.
+ */
+declare function NetworkSkeleton({ className }: {
+    className?: string;
+}): react.JSX.Element;
+
+/**
+ * Fim da página da rede: o `slots.footer` do app (ex.: o card "O que é o Engramind" do Opex) ou, sem ele,
+ * um card com a distribuição da visão inicial (Órbita ou Radial; só fora dos universos) e Configurar.
+ */
+declare function NetworkFooter(context: FooterContext): react.JSX.Element | null;
+
+/**
+ * Texto das memórias dos agentes (módulo PURO: tela, rotas, ferramentas e migração). Os limites vêm do
+ * Engramind (`memory.text_min` / `memory.text_max`, este com sobreposição por canal); os schemas
+ * estáticos só seguram o teto absoluto do Engramind (20.000) e a regra fina fica em `memoryInputSchemaFor`.
+ */
+interface MemoryTextLimits {
+    textMin: number;
+    textMax: number;
+}
+/** Padrões do Engramind (usados até a primeira leitura das configurações). */
+declare const DEFAULT_MEMORY_TEXT_LIMITS: MemoryTextLimits;
+declare function memoryTextSchema(limits?: MemoryTextLimits): z.ZodString;
+
+interface MemoryEditorTarget {
+    mode: "create" | "edit";
+    channel: string;
+    initial?: {
+        texto: string;
+        categoria: string | null;
+    };
+}
+/**
+ * O mesmo editor de memória das listas (texto + categoria, limites do Engramind) num diálogo da rede.
+ * `onSave` resolve `true` no sucesso; num conflito de versão o diálogo continua aberto com o texto.
+ */
+declare function MemoryEditorDialog({ target, limits, categories, onSave, onClose }: {
+    target: MemoryEditorTarget | null;
+    limits?: MemoryTextLimits;
+    categories: {
+        key: string;
+        label: string;
+    }[];
+    onSave: (values: {
+        texto: string;
+        categoria: string;
+    }) => Promise<boolean>;
+    onClose: () => void;
+}): react.JSX.Element;
+
+/** Card quadrado e fixo (OPE-113): não depende do zoom da rede; o texto rola dentro. */
+declare const MEMORY_CARD_WIDTH = 360;
+declare const MEMORY_CARD_HEIGHT = 360;
+declare const MEMORY_CARD_MORPH_S = 0.22;
+
+/** Traço do link ao centro: normal e destacado (memória escrita pelo agente do centro). */
+declare const ORBIT_STROKE_WIDTH: {
+    readonly normal: 1;
+    readonly authored: 2.25;
+};
+
+declare const UNIVERSE_PARAM = "universo";
+/** App aberto (`?app=<slug>`): a visão Agentes x canais restrita a ele (OPE-129). */
+declare const APP_PARAM = "app";
+/** `canal:<slug>` / `agente:<app/agente>` ↔ referência do universo (inválido → `null`). */
+declare function parseUniverse(value: string | null | undefined): UniverseRef | null;
+declare const formatUniverse: (ref: UniverseRef) => string;
+
+/** Dimensões compartilhadas pela rede e pelo skeleton (o skeleton acompanha a interface). */
+/** Fundo das redes no padrão do app (tema compartilhado dos canvas React Flow, `@/components/flow/flow-theme`). */
+declare const NETWORK_CANVAS_CLASS = "relative overflow-hidden rounded-xl border bg-background bg-[radial-gradient(ellipse_at_center,color-mix(in_oklab,var(--color-primary)_8%,transparent),transparent_70%)] h-[min(72dvh,44rem)] w-full max-md:h-[70dvh]";
+/** Tema do React Flow pelos tokens do app (variáveis no próprio elemento vencem a folha do `colorMode="dark"`). */
+declare const NETWORK_FLOW_THEME: react.CSSProperties;
+/** Altura menor dos universos dentro dos cards de `/integracoes/ia` (no celular, quase a tela). */
+declare const NETWORK_CANVAS_COMPACT_CLASS = "h-[28rem] max-md:h-[60dvh]";
+declare const NETWORK_STATS_CLASS = "pointer-events-auto absolute right-3 top-3 z-10 max-h-[calc(100%-1.5rem)] w-64 overflow-y-auto rounded-xl border bg-card/90 p-3 text-xs shadow-lg backdrop-blur max-md:left-3 max-md:w-auto";
+/** Card de estatísticas recolhido (celular): um botão no canto com o resumo. */
+declare const NETWORK_STATS_TOGGLE_CLASS = "pointer-events-auto absolute right-3 top-3 z-10 flex h-10 items-center gap-1.5 rounded-xl border bg-card/90 px-3 text-xs font-medium text-foreground shadow-lg backdrop-blur";
+/** Área de toque mínima (40 px) dos botões sobre a rede no celular. */
+declare const NETWORK_TOUCH_BUTTON_CLASS = "max-md:h-10 max-md:px-3";
+/** Skeleton da visão inicial: área livre à esquerda do card de estatísticas, com o grupo de agentes e canais ao centro. */
+declare const NETWORK_SKELETON_AREA_CLASS = "absolute inset-y-0 left-0 right-72 flex items-center justify-center max-md:right-0 max-md:overflow-hidden";
+/** Card do agente na visão inicial: largura e altura fixas (as linhas de contagem não deslocam o layout, OPE-117). */
+declare const AGENT_NODE_SIZE_CLASS = "w-[11.25rem] h-16";
+
+/** Link de volta à rede, com o universo do canal aberto. */
+declare function networkHref(network: string, params: Record<string, string>): string;
+/** Detalhe do canal: assinantes e o conteúdo extra do app (`slots.channelDetail`, ex.: configurações do canal). */
+declare function ChannelDetail({ slug }: {
+    slug: string;
+}): react.JSX.Element;
+
+/** Assinantes do canal: listar, assinar um agente, editar e remover. */
+declare function SubscribersCard({ channel }: {
+    channel: string;
+}): react.JSX.Element;
+
+type AppSettingsTab = "agents" | "channels" | "tokens" | "webhook";
+/**
+ * Configuração do app no Engramind (modo app, só o token do próprio app): Agentes e assinaturas, Canais,
+ * Tokens de agente (o segredo aparece uma única vez) e Webhook. Sem funções de gestor (outros apps,
+ * tokens admin ou de app, configurações globais).
+ */
+declare function EngramindAppSettings({ defaultTab }: {
+    defaultTab?: AppSettingsTab;
+}): react.JSX.Element;
+declare function AppSettingsSkeleton(): react.JSX.Element;
+
+/** Segredo novo do webhook: 32 bytes aleatórios em hexadecimal (64 caracteres, dentro de 32 a 256). */
+declare function generateWebhookSecret(): string;
+/**
+ * Webhook do app (`update_app_webhook`): registrar a URL, gerar ou rotacionar o segredo (mostrado uma
+ * única vez, para o app gravar no servidor dele) e remover. A leitura do estado atual usa `get_app`; se o
+ * Engramind não a liberar para o token de app, a tela mostra só o que foi gravado nesta visita.
+ */
+declare function WebhookCard({ app }: {
+    app: string;
+}): react.JSX.Element;
+
+/**
+ * Canais que os agentes do app alcançam: criar pela assinatura exata (o token de app não cria canal
+ * direto), abrir o painel do canal (assinantes, arquivar e restaurar os que o app criou; o Engramind
+ * recusa os compartilhados com `409 CHANNEL_SHARED`).
+ */
+declare function ChannelsCard({ channels, agents, subscriptions }: {
+    channels: readonly EngramindChannel[];
+    agents: readonly EngramindAgent[];
+    subscriptions: readonly EngramindSubscription[];
+}): react.JSX.Element;
+
+interface QueryBoundaryProps {
+    isLoading: boolean;
+    error: unknown;
+    onRetry: () => void;
+    skeleton: ReactNode;
+    /** Para onde levar quando a conexão precisa ser (re)configurada. */
+    onConfigure?: () => void;
+    children: ReactNode;
+}
+/** Erro de acesso do token de app (registro de outro app ou canal fora das assinaturas). */
+declare const isNoAccessError: (error: unknown) => boolean;
+/**
+ * Carregando (skeleton), erro com "Tentar novamente", "Reconfigure o token" (401 do Engramind), "Sem
+ * acesso" (`403 FOREIGN_APP`/`CHANNEL_NOT_SUBSCRIBED`) e o conteúdo. Fora do ar, proxy mascarado e `429`
+ * (com o `Retry-After` na mensagem) mostram a mensagem pt-BR com "Tentar novamente".
+ */
+declare function QueryBoundary({ isLoading, error, onRetry, skeleton, onConfigure, children }: QueryBoundaryProps): react.JSX.Element;
+
+interface SectionProps {
+    title: string;
+    info?: ReactNode;
+    description?: ReactNode;
+    actions?: ReactNode;
+    children: ReactNode;
+    className?: string;
+    contentClassName?: string;
+}
+/** Card de uma seção das telas do Engramind: título com tooltip, descrição e ações à direita. */
+declare function Section({ title, info, description, actions, children, className, contentClassName }: SectionProps): react.JSX.Element;
+
+/** Selo com tooltip (status, modo, tipo, escopo...). */
+declare function HelpBadge({ value, help, tone, className }: {
+    value: string;
+    help?: string;
+    tone?: "outline" | "success" | "warning" | "destructive" | "secondary";
+    className?: string;
+}): react.JSX.Element;
+
+interface MemoryEditorProps {
+    label: string;
+    initial?: {
+        texto: string;
+        categoria: string | null;
+    };
+    limits?: MemoryTextLimits;
+    categories: {
+        key: string;
+        label: string;
+    }[];
+    onSave: (values: {
+        texto: string;
+        categoria: string;
+    }) => void;
+    onCancel: () => void;
+}
+/** Texto livre da memória + categoria (mesmos limites da API, vindos do Engramind). Ctrl+Enter salva, Esc cancela. */
+declare function MemoryEditor({ label, initial, limits, categories, onSave, onCancel }: MemoryEditorProps): react.JSX.Element;
+
+/**
+ * Base dos hooks do Engramind: tudo passa pela fonte de dados do `EngramindProvider` (o proxy montado
+ * pelo app; o navegador nunca chama o Engramind). Chave: `["engramind", <1º segmento da rota>, rota, parâmetros]`, invalidada
+ * pelo prefixo no tempo real (`useEngramindRealtime`).
+ */
+type Params = Record<string, string | number | boolean | undefined | null>;
+declare const engramindKey: (route: string, params?: Params) => QueryKey;
+declare const areaKey: (area: string) => QueryKey;
+/** Caminho do Opex com os segmentos codificados (`channels/eng%2Fglobal/stats`). */
+declare const route: (...segments: (string | number)[]) => string;
+declare function engramindGet<T>(path: string, params?: Params): Promise<T>;
+declare function engramindSend<T>(method: "post" | "put" | "patch" | "delete", path: string, body?: unknown): Promise<T>;
+/** Consulta simples de uma rota do Engramind. */
+declare function useEngramindQuery<T>(path: string | null, params?: Params, options?: {
+    enabled?: boolean; /** Número, `false` ou função dos dados atuais (ex.: polling só enquanto algo carrega). */
+    refetchInterval?: number | false | ((data: T | undefined) => number | false);
+}): _tanstack_react_query.UseQueryResult<T, Error>;
+declare function useEngramindList<T>(path: string | null, field: string, params?: Params, options?: {
+    enabled?: boolean; /** Lê todas as páginas (listas pequenas, como apps e tokens). */
+    all?: boolean;
+}): {
+    items: T[];
+    data: _tanstack_react_query.InfiniteData<{
+        items: T[];
+        nextCursor: string | null;
+        truncated: boolean;
+    }, unknown>;
+    error: Error;
+    isError: true;
+    isPending: false;
+    isLoading: false;
+    isLoadingError: false;
+    isRefetchError: true;
+    isSuccess: false;
+    isPlaceholderData: false;
+    status: "error";
+    fetchNextPage: (options?: _tanstack_react_query.FetchNextPageOptions) => Promise<_tanstack_react_query.InfiniteQueryObserverResult<_tanstack_react_query.InfiniteData<{
+        items: T[];
+        nextCursor: string | null;
+        truncated: boolean;
+    }, unknown>, Error>>;
+    fetchPreviousPage: (options?: _tanstack_react_query.FetchPreviousPageOptions) => Promise<_tanstack_react_query.InfiniteQueryObserverResult<_tanstack_react_query.InfiniteData<{
+        items: T[];
+        nextCursor: string | null;
+        truncated: boolean;
+    }, unknown>, Error>>;
+    hasNextPage: boolean;
+    hasPreviousPage: boolean;
+    isFetchNextPageError: boolean;
+    isFetchingNextPage: boolean;
+    isFetchPreviousPageError: boolean;
+    isFetchingPreviousPage: boolean;
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<_tanstack_react_query.InfiniteData<{
+        items: T[];
+        nextCursor: string | null;
+        truncated: boolean;
+    }, unknown>, Error>>;
+    fetchStatus: _tanstack_react_query.FetchStatus;
+} | {
+    items: T[];
+    data: _tanstack_react_query.InfiniteData<{
+        items: T[];
+        nextCursor: string | null;
+        truncated: boolean;
+    }, unknown>;
+    error: null;
+    isError: false;
+    isPending: false;
+    isLoading: false;
+    isLoadingError: false;
+    isRefetchError: false;
+    isFetchNextPageError: false;
+    isFetchPreviousPageError: false;
+    isSuccess: true;
+    isPlaceholderData: false;
+    status: "success";
+    fetchNextPage: (options?: _tanstack_react_query.FetchNextPageOptions) => Promise<_tanstack_react_query.InfiniteQueryObserverResult<_tanstack_react_query.InfiniteData<{
+        items: T[];
+        nextCursor: string | null;
+        truncated: boolean;
+    }, unknown>, Error>>;
+    fetchPreviousPage: (options?: _tanstack_react_query.FetchPreviousPageOptions) => Promise<_tanstack_react_query.InfiniteQueryObserverResult<_tanstack_react_query.InfiniteData<{
+        items: T[];
+        nextCursor: string | null;
+        truncated: boolean;
+    }, unknown>, Error>>;
+    hasNextPage: boolean;
+    hasPreviousPage: boolean;
+    isFetchingNextPage: boolean;
+    isFetchingPreviousPage: boolean;
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<_tanstack_react_query.InfiniteData<{
+        items: T[];
+        nextCursor: string | null;
+        truncated: boolean;
+    }, unknown>, Error>>;
+    fetchStatus: _tanstack_react_query.FetchStatus;
+} | {
+    items: T[];
+    data: undefined;
+    error: Error;
+    isError: true;
+    isPending: false;
+    isLoading: false;
+    isLoadingError: true;
+    isRefetchError: false;
+    isFetchNextPageError: false;
+    isFetchPreviousPageError: false;
+    isSuccess: false;
+    isPlaceholderData: false;
+    status: "error";
+    fetchNextPage: (options?: _tanstack_react_query.FetchNextPageOptions) => Promise<_tanstack_react_query.InfiniteQueryObserverResult<_tanstack_react_query.InfiniteData<{
+        items: T[];
+        nextCursor: string | null;
+        truncated: boolean;
+    }, unknown>, Error>>;
+    fetchPreviousPage: (options?: _tanstack_react_query.FetchPreviousPageOptions) => Promise<_tanstack_react_query.InfiniteQueryObserverResult<_tanstack_react_query.InfiniteData<{
+        items: T[];
+        nextCursor: string | null;
+        truncated: boolean;
+    }, unknown>, Error>>;
+    hasNextPage: boolean;
+    hasPreviousPage: boolean;
+    isFetchingNextPage: boolean;
+    isFetchingPreviousPage: boolean;
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<_tanstack_react_query.InfiniteData<{
+        items: T[];
+        nextCursor: string | null;
+        truncated: boolean;
+    }, unknown>, Error>>;
+    fetchStatus: _tanstack_react_query.FetchStatus;
+} | {
+    items: T[];
+    data: undefined;
+    error: null;
+    isError: false;
+    isPending: true;
+    isLoading: true;
+    isLoadingError: false;
+    isRefetchError: false;
+    isFetchNextPageError: false;
+    isFetchPreviousPageError: false;
+    isSuccess: false;
+    isPlaceholderData: false;
+    status: "pending";
+    fetchNextPage: (options?: _tanstack_react_query.FetchNextPageOptions) => Promise<_tanstack_react_query.InfiniteQueryObserverResult<_tanstack_react_query.InfiniteData<{
+        items: T[];
+        nextCursor: string | null;
+        truncated: boolean;
+    }, unknown>, Error>>;
+    fetchPreviousPage: (options?: _tanstack_react_query.FetchPreviousPageOptions) => Promise<_tanstack_react_query.InfiniteQueryObserverResult<_tanstack_react_query.InfiniteData<{
+        items: T[];
+        nextCursor: string | null;
+        truncated: boolean;
+    }, unknown>, Error>>;
+    hasNextPage: boolean;
+    hasPreviousPage: boolean;
+    isFetchingNextPage: boolean;
+    isFetchingPreviousPage: boolean;
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<_tanstack_react_query.InfiniteData<{
+        items: T[];
+        nextCursor: string | null;
+        truncated: boolean;
+    }, unknown>, Error>>;
+    fetchStatus: _tanstack_react_query.FetchStatus;
+} | {
+    items: T[];
+    data: undefined;
+    error: null;
+    isError: false;
+    isPending: true;
+    isLoadingError: false;
+    isRefetchError: false;
+    isFetchNextPageError: false;
+    isFetchPreviousPageError: false;
+    isSuccess: false;
+    isPlaceholderData: false;
+    status: "pending";
+    fetchNextPage: (options?: _tanstack_react_query.FetchNextPageOptions) => Promise<_tanstack_react_query.InfiniteQueryObserverResult<_tanstack_react_query.InfiniteData<{
+        items: T[];
+        nextCursor: string | null;
+        truncated: boolean;
+    }, unknown>, Error>>;
+    fetchPreviousPage: (options?: _tanstack_react_query.FetchPreviousPageOptions) => Promise<_tanstack_react_query.InfiniteQueryObserverResult<_tanstack_react_query.InfiniteData<{
+        items: T[];
+        nextCursor: string | null;
+        truncated: boolean;
+    }, unknown>, Error>>;
+    hasNextPage: boolean;
+    hasPreviousPage: boolean;
+    isFetchingNextPage: boolean;
+    isFetchingPreviousPage: boolean;
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isLoading: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<_tanstack_react_query.InfiniteData<{
+        items: T[];
+        nextCursor: string | null;
+        truncated: boolean;
+    }, unknown>, Error>>;
+    fetchStatus: _tanstack_react_query.FetchStatus;
+} | {
+    items: T[];
+    data: _tanstack_react_query.InfiniteData<{
+        items: T[];
+        nextCursor: string | null;
+        truncated: boolean;
+    }, unknown>;
+    isError: false;
+    error: null;
+    isPending: false;
+    isLoading: false;
+    isLoadingError: false;
+    isRefetchError: false;
+    isSuccess: true;
+    isPlaceholderData: true;
+    isFetchNextPageError: false;
+    isFetchPreviousPageError: false;
+    status: "success";
+    fetchNextPage: (options?: _tanstack_react_query.FetchNextPageOptions) => Promise<_tanstack_react_query.InfiniteQueryObserverResult<_tanstack_react_query.InfiniteData<{
+        items: T[];
+        nextCursor: string | null;
+        truncated: boolean;
+    }, unknown>, Error>>;
+    fetchPreviousPage: (options?: _tanstack_react_query.FetchPreviousPageOptions) => Promise<_tanstack_react_query.InfiniteQueryObserverResult<_tanstack_react_query.InfiniteData<{
+        items: T[];
+        nextCursor: string | null;
+        truncated: boolean;
+    }, unknown>, Error>>;
+    hasNextPage: boolean;
+    hasPreviousPage: boolean;
+    isFetchingNextPage: boolean;
+    isFetchingPreviousPage: boolean;
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<_tanstack_react_query.InfiniteData<{
+        items: T[];
+        nextCursor: string | null;
+        truncated: boolean;
+    }, unknown>, Error>>;
+    fetchStatus: _tanstack_react_query.FetchStatus;
+};
+interface MutationOptions<V> {
+    /** Áreas (1º segmento) a invalidar no sucesso. */
+    invalidate: string[];
+    success?: string | ((variables: V) => string);
+    /** Não mostra o toast de erro (o chamador mostra no formulário). */
+    silentError?: boolean;
+    /** Outras chaves a invalidar (ex.: o detalhe da integração). */
+    alsoInvalidate?: readonly QueryKey[];
+}
+/** Mutação numa rota do Engramind, com toast pt-BR e invalidação das áreas afetadas. */
+declare function useEngramindMutation<V, T = unknown>(request: (variables: V) => Promise<T>, options: MutationOptions<V>): _tanstack_react_query.UseMutationResult<T, Error, V, unknown>;
+/** Áreas a invalidar por tipo de evento. `memory.consumed` não invalida nada (só anima a rede). */
+declare function areasForEvent(type: string): string[];
+/**
+ * Tempo real pelo SSE da lib (`events` do provider): cada evento invalida as áreas afetadas e, quando a
+ * conexão volta depois de cair, todas as consultas do Engramind são relidas. Sem `events`, nada.
+ */
+declare function useEngramindRealtime(): void;
+/** Erro que pede reconfigurar a conexão (token inválido/insuficiente ou sem configuração). */
+declare function needsReconnect(error: unknown): "configure" | "token" | null;
+
+/**
+ * Dados da rede do Engramind: canais (com os arquivados), agentes, assinaturas e memórias de todos os
+ * status (todas as páginas). No modo gestor, também os apps e as configurações globais (o prazo
+ * `consolidation.stale_after_days` e os pesos da busca); no modo app, o próprio app (`whoami`), as
+ * categorias e os limites de `get_consumer_settings`. Tudo pela fonte de dados do provider.
+ */
+declare const STALE_AFTER_DAYS_KEY = "consolidation.stale_after_days";
+declare function toNetworkMemory(memory: EngramindMemory): NetworkMemory;
+/** Pesos da fusão da busca nas configurações do Engramind (padrão 1/1/60). */
+declare function searchFusionOf(setting: (key: string) => unknown): SearchFusion;
+declare function firstSentence(text: string): string;
+/** Pesos da fusão da busca em `get_consumer_settings` (modo app). */
+declare function consumerSearchFusion(consumer: ConsumerSettings | undefined): SearchFusion;
+/** Prazo de desuso: o fixado pelo app, o do Engramind (gestor: `settings`; app: `consumer-settings`) ou 90. */
+declare function resolveStaleAfterDays(fixed: number | undefined, fromEngramind: unknown): number;
+/** Slug do app do token (modo app): o fixado no provider ou o de `whoami`. */
+declare function useOwnApp(): {
+    slug: string | null;
+    isLoading: boolean;
+    error: unknown;
+};
+declare function useEngramindNetwork(): {
+    apps: {
+        slug: string;
+        name: string;
+    }[];
+    /** App do token (modo app); `null` no gestor. */
+    ownApp: string | null;
+    rawChannels: EngramindChannel[];
+    rawAgents: EngramindAgent[];
+    rawMemories: EngramindMemory[];
+    categories: Category[];
+    limits: {
+        textMin: number;
+        textMax: number;
+    } | undefined;
+    maxBatch: number | null;
+    searchFusion: SearchFusion;
+    staleAfterDays: number;
+    memoriesUpdatedAt: number;
+    /** Lista de canais sendo relida (canal recém-criado ainda não chegou). */
+    channelsFetching: boolean;
+    isLoading: boolean;
+    error: unknown;
+    refetch: () => void;
+    agents: NetworkAgent[];
+    agentNames: Map<string, string>;
+    channels: NetworkChannel[];
+    subscriptions: SubscriptionInput[];
+    memories: NetworkMemory[];
+};
+
+/** O Engramind grava os contadores em lote a cada 5 s: a releitura espera um pouco mais. */
+declare const CONSUMPTION_REFRESH_DELAY_MS = 6000;
+/** Espera para juntar os eventos por canal de uma mesma leitura (`consumption`). */
+declare const CONSUMPTION_GROUP_WINDOW_MS = 400;
+declare function isConsumptionEvent(value: unknown): value is ConsumptionEvent;
+/**
+ * Tempo real do consumo de memórias: o webhook `memory.consumed` (Engramind ≥ 0.12.0) chega pelo SSE da
+ * lib, um evento por canal; os eventos da mesma leitura são agrupados pelo `consumption` e a tela anima
+ * **uma** vez com o `handler` (estado local: brilho cheio e tamanho um pouco maior). Leitura sem agente
+ * (token de app ou admin) não anima. Os contadores reais são relidos depois do lote do Engramind; o
+ * consumo não invalida o contexto.
+ */
+declare function useEngramindConsumption(handler: (event: ConsumptionEvent) => void): void;
+interface Travel {
+    id: string;
+    /** Aresta por onde a partícula viaja. */
+    edge: string;
+    /** `true`: do alvo para a origem da aresta. */
+    reverse: boolean;
+    /** `success`: criação de memória por um agente (verde). */
+    tone: "primary" | "white" | "success";
+    delayMs: number;
+}
+/**
+ * Efeitos locais da rede: pulsos por node (contador que remonta o anel), partículas viajando pelas
+ * arestas e o leve aumento de tamanho das memórias consumidas (zerado quando o Engramind relê os
+ * números). Movimento reduzido: sem pulsos nem viagens; o aumento e o brilho continuam.
+ */
+declare function useLiveEffects(resetKey: unknown): {
+    pulses: Record<string, number>;
+    travels: Travel[];
+    bumps: Record<string, number>;
+    liveCount: number;
+    pulse: (keys: readonly string[], delayMs?: number) => void;
+    travel: (items: readonly Omit<Travel, "id">[]) => void;
+    finish: (id: string) => void;
+    bump: (ids: readonly string[]) => void;
+    countEvent: () => void;
+    reducedMotion: boolean;
+};
+type LiveEffects = ReturnType<typeof useLiveEffects>;
+
+interface NetworkSearchResult {
+    ids: Set<string>;
+    textOnly: boolean;
+}
+/** Divide os canais citados em lotes de `size`. Sem canais: um lote vazio (busca sem citar canais). */
+declare function channelBatches(channels: readonly string[], size?: number): string[][];
+/**
+ * Busca da rede (OPE-113): roda sozinha com o termo (a espera de digitação fica no campo), cita os
+ * canais da visão atual (o Engramind só busca nos canais `manage` e arquivados quando citados), em lotes
+ * de 50, e destaca só os resultados relevantes (`relevantSearchIds`).
+ */
+declare function useNetworkSearch({ query, channels, categories, fusion, enabled }: {
+    query: string;
+    channels: readonly string[];
+    categories: readonly string[];
+    fusion: SearchFusion;
+    enabled?: boolean;
+}): _tanstack_react_query.UseQueryResult<NetworkSearchResult, Error>;
+
+/**
+ * Busca e filtros da rede do Engramind (OPE-113, puro): no padrão de `/tarefas`, ficam no navegador
+ * (`usePersistentState`, chave versionada) e **destacam sem remover** (as que não casam ficam apagadas).
+ */
+declare const NETWORK_FILTERS_STORAGE_KEY = "opex.engramind.network-filters.v1";
+declare const networkFiltersSchema: z.ZodObject<{
+    search: z.ZodCatch<z.ZodString>;
+    channels: z.ZodCatch<z.ZodArray<z.ZodString>>;
+    statuses: z.ZodCatch<z.ZodArray<z.ZodString>>;
+    categories: z.ZodCatch<z.ZodArray<z.ZodString>>;
+    authors: z.ZodCatch<z.ZodArray<z.ZodString>>;
+    from: z.ZodCatch<z.ZodUnion<[z.ZodString, z.ZodLiteral<"">]>>;
+    to: z.ZodCatch<z.ZodUnion<[z.ZodString, z.ZodLiteral<"">]>>;
+    includeArchived: z.ZodCatch<z.ZodBoolean>;
+    overviewLayout: z.ZodCatch<z.ZodEnum<{
+        "by-agent": "by-agent";
+        "agents-center": "agents-center";
+    }>>;
+}, z.core.$strip>;
+type NetworkFilters = z.infer<typeof networkFiltersSchema>;
+declare const DEFAULT_NETWORK_FILTERS: NetworkFilters;
+/** Campos que o "Limpar" zera (a distribuição escolhida no card "O que é o Engramind" fica). */
+declare const NETWORK_FILTER_KEYS: readonly ["search", "channels", "statuses", "categories", "authors", "from", "to", "includeArchived"];
+declare const clearNetworkFilters: (filters: NetworkFilters) => NetworkFilters;
+/** Filtros que destacam memórias (sem a busca, que vem do servidor, e sem os arquivados). */
+declare const hasMemoryFilters: (filters: NetworkFilters) => boolean;
+declare const hasActiveFilters: (filters: NetworkFilters, searchIds: ReadonlySet<string> | null) => boolean;
+/** A memória casa com a busca e os filtros? (Destaque: as demais ficam apagadas, nada sai da rede.) */
+declare function matchesFilters(memory: NetworkMemory, filters: NetworkFilters, searchIds: ReadonlySet<string> | null): boolean;
+declare const memoryStatusLabel: (status: string) => string;
+declare const MEMORY_STATUS_OPTIONS: {
+    value: "active" | "permanent" | "archived";
+    label: string;
+}[];
+interface NetworkFilterChip {
+    key: string;
+    label: string;
+    remove: Partial<NetworkFilters>;
+}
+/**
+ * Chips dos filtros ativos (resumo do cartão recolhido e contagem da gaveta no celular). `channelLabel`
+ * mostra o canal legível (`channelDisplayName`: sigla da central no lugar do id).
+ */
+declare function activeNetworkFilterChips(filters: NetworkFilters, channelLabel?: (slug: string) => string): NetworkFilterChip[];
+
+/**
+ * Visão inicial Apps x canais (OPE-129, puro): os links por agente agregados por app e o corte dos
+ * canais vazios. Decisão do dono no plano aprovado: as duas redes (Apps x canais e Agentes x canais)
+ * escondem o canal **sem nenhuma memória**; inativas contam (só some com zero de qualquer status).
+ * Os universos, o filtro Canal, o painel do canal e o Importar continuam com todos os canais.
+ */
+/** Só os canais com ao menos uma memória (de qualquer status), na ordem recebida. */
+declare function channelsWithMemories<T extends {
+    slug: string;
+}>(channels: readonly T[], memories: readonly {
+    channel: string;
+}[]): T[];
+/** App de um agente (`app/agente` → `app`). */
+declare const appOfAgent: (agent: string) => string;
+/** Id da aresta app → canal na visão de apps. */
+declare const appLinkEdgeId: (app: string, channel: string) => string;
+/** Link app → canal: as assinaturas de todos os agentes do app naquele canal. */
+interface AppLink {
+    id: string;
+    app: string;
+    channel: string;
+    /** Modos das assinaturas, sem repetição (ordem de chegada). */
+    modes: SubscriptionMode[];
+    /** Agentes (`app/agente`) que assinam o canal, sem repetição. */
+    agents: string[];
+}
+/** Um link por par (app, canal), na ordem em que o par aparece pela primeira vez. */
+declare function appLinks(links: readonly NetworkLink[]): AppLink[];
+/** Canais assinados por algum agente do app (sem repetição, na ordem dos links). */
+declare function appChannels(app: string, links: readonly NetworkLink[]): string[];
+/** Alcance do app: soma das memórias (ativas) dos canais que os agentes dele assinam, cada canal uma vez. */
+declare function appReach(links: readonly AppLink[], countByChannel: ReadonlyMap<string, number>): Map<string, number>;
+
+/**
+ * Tema dos canvas React Flow (rede do Engramind e outros canvas do app). Só tokens do tema do app
+ * (`var(--color-*)` do Tailwind 4 e `color-mix`), sem cor fixa: a cor primária do app manda.
+ *
+ * O fundo segue o padrão das páginas (`bg-background`) com um brilho da cor primária bem suave no centro; o
+ * React Flow fica transparente. O `colorMode="dark"` da biblioteca pinta o canvas, o minimapa e os
+ * controles de cinza neutro fixo por uma folha de estilo fora das camadas do Tailwind: as variáveis no
+ * `style` do próprio elemento (`FLOW_THEME_STYLE`) vencem essa folha. Os tipos de nó reservados da
+ * biblioteca (`group`, `default`, `input`, `output`) ganham classe com fundo, padding e borda próprios:
+ * os canvas usam tipos com prefixo do domínio, e as variáveis abaixo neutralizam o que sobrar.
+ *
+ * Cor e espessura das arestas vão no `style` inline do `path`: a folha do React Flow é importada fora
+ * das camadas do Tailwind, então a regra `.react-flow__edge-path { stroke; stroke-width }` vence
+ * qualquer classe utilitária (`stroke-primary`) e o atributo `strokeWidth` do SVG.
+ */
+declare const FLOW_SURFACE_CLASS = "relative overflow-hidden rounded-xl border bg-background bg-[radial-gradient(ellipse_at_center,color-mix(in_oklab,var(--color-primary)_8%,transparent),transparent_70%)]";
+/** Cor das linhas das arestas: a primária do tema (aplicar no `style` inline, ver acima). */
+declare const FLOW_EDGE_PRIMARY_STROKE = "var(--color-primary)";
+declare const FLOW_THEME_STYLE: CSSProperties;
+/** Pontos discretos do fundo (`<Background {...FLOW_BACKGROUND_PROPS} />`). */
+declare const FLOW_BACKGROUND_PROPS: {
+    variant: BackgroundVariant;
+    gap: number;
+    size: number;
+};
+
+/**
+ * Partícula que percorre um caminho SVG uma vez (Framer Motion) e avisa ao chegar. Usada nas redes do
+ * Engramind (memórias viajando) e nos diagramas do Agente Arquiteto (pulso da aresta que nasce).
+ */
+declare function PathTraveler({ path, reverse, delayMs, durationMs, radius, className, testId, edge, tone, onDone }: {
+    path: string;
+    reverse?: boolean;
+    delayMs?: number;
+    durationMs?: number;
+    radius?: number;
+    className?: string;
+    testId?: string; /** `data-edge` do grupo e `data-tone` do círculo (testes e estilo). */
+    edge?: string;
+    tone?: string;
+    onDone?: () => void;
+}): react.JSX.Element;
+
+export { AGENT_NODE_SIZE_CLASS, AGENT_WRITE_WINDOW_MS, APP_PARAM, type AgentWrite, type AppLink, AppSettingsSkeleton, type AppSettingsTab, CONSUMPTION_GROUP_WINDOW_MS, CONSUMPTION_REFRESH_DELAY_MS, ChannelDetail, ChannelDisplayName, type ChannelLabel, ChannelLabelsProvider, ChannelName, ChannelPanel, ChannelsCard, type ConfigureTarget, type ConsumptionEvent, DEFAULT_MEMORY_TEXT_LIMITS, DEFAULT_MESSAGES, DEFAULT_NETWORK_FILTERS, DEFAULT_OVERVIEW_LAYOUT, DEFAULT_SEARCH_FUSION, DEFAULT_STALE_AFTER_DAYS, EngramindAppSettings, type EngramindConfig, type EngramindDataSource, type EngramindHrefs, type EngramindMode, EngramindNetwork, EngramindProvider, type EngramindProviderProps, type EngramindRouter, FLOW_BACKGROUND_PROPS, FLOW_EDGE_PRIMARY_STROKE, FLOW_SURFACE_CLASS, FLOW_THEME_STYLE, type FooterContext, HelpBadge, type HttpDataSourceOptions, type HttpMethod, LIVE_BUMP_PX, type LiveEffects, type LiveSubscription, type LocalRemovals, MEMORY_CARD_HEIGHT, MEMORY_CARD_MORPH_S, MEMORY_CARD_WIDTH, MEMORY_STATUS_OPTIONS, MOBILE_FIT_MIN_ZOOM, type MemoryCardActions, MemoryEditor, MemoryEditorDialog, type MemoryEditorTarget, type MemoryStatus, type MemoryTextLimits, MemoryUniverse, type MemoryUniverseProps, type MessageKey, type Messages, NETWORK_CANVAS_CLASS, NETWORK_CANVAS_COMPACT_CLASS, NETWORK_FILTERS_STORAGE_KEY, NETWORK_FILTER_KEYS, NETWORK_FLOW_THEME, NETWORK_SKELETON_AREA_CLASS, NETWORK_STATS_CLASS, NETWORK_STATS_TOGGLE_CLASS, NETWORK_TOUCH_BUTTON_CLASS, type NavigationAdapter, type NetworkAgent, type NetworkChannel, type NetworkFilterChip, type NetworkFilters, NetworkFooter, type NetworkLink, type NetworkMemory, NetworkSkeleton, type Notify, type NotifyKind, ORBIT_STROKE_WIDTH, OVERVIEW_AGENT_BOX, OVERVIEW_CHANNEL_BOX, OVERVIEW_FIT_MARGIN, OVERVIEW_LAYOUT_LABEL, OVERVIEW_LAYOUT_MODES, OVERVIEW_LINK_BEND, OVERVIEW_PADDING, OVERVIEW_SCALE_MAX, OVERVIEW_SCALE_MIN, type OverviewLayout, type OverviewLayoutInput, type OverviewLayoutMode, PARTICLE_MAX_PX, PARTICLE_MIN_PX, PINNED_MIN_BRIGHTNESS, PRIMARY_CHANNEL_COLOR, type Params$1 as Params, type PartialMessages, type ParticleVisual, PathTraveler, type Point, QueryBoundary, type Rect, type RenderLinkProps, SEARCH_SINGLE_BRANCH_TOP, STALE_AFTER_DAYS_KEY, type SearchFusion, Section, SubscribersCard, type SubscriptionInput, type SubscriptionMode, type Travel, UNIVERSE_FIRST_RADIUS, UNIVERSE_PARAM, UNIVERSE_RING_GAP, UNIVERSE_SLOT, type UniverseCenter, type UniverseRef, type UniverseStats, WebhookCard, activeNetworkFilterChips, agentDisplayName, agentReach, agentWritesOf, apiErrorCode, apiErrorMessage, apiErrorStatus, appChannels, appLinkEdgeId, appLinks, appOfAgent, appReach, areaKey, areasForEvent, buildParticles, channelBatches, channelColors, channelDisplayHint, channelDisplayName, channelNameParts, channelsWithMemories, chartToken, clampCardRect, clearDistance, clearNetworkFilters, consumerSearchFusion, createHttpDataSource, engramindGet, engramindKey, engramindSend, errorFromResponse, firstSentence, formatUniverse, generateWebhookSecret, hasActiveFilters, hasMemoryFilters, historyNavigation, isAuthoredByCenter, isConsumptionEvent, isNoAccessError, lastRealUseOf, lastUseOf, layoutOverview, layoutUniverse, matchesFilters, memoryCardSize, memoryStatusLabel, memoryTextSchema, memoryUses, mergeMessages, minZoomCenter, needsReconnect, networkFiltersSchema, networkHref, overviewInitialBounds, overviewLinkMidpoint, overviewLinkPath, overviewScale, parseUniverse, particleBrightness, particleColor, particleSize, pickChannelColors, relevantSearchIds, repelOffset, resolveStaleAfterDays, route, searchFusionOf, splitChannelSlug, stableHash, subscribeLive, subscriptionLinks, subscriptionReaches, toNetworkMemory, universeChannelColors, universeRingCapacity, universeRingCounts, universeStats, useChannelLabels, useEngramindConfig, useEngramindConsumption, useEngramindList, useEngramindMutation, useEngramindNetwork, useEngramindQuery, useEngramindRealtime, useIsManager, useLiveEffects, useLocalRemovals, useNetworkSearch, useOwnApp, useT };