import type { NodeType } from './types.js';
/**
 * [2026-10-16, mejora #112] Qué saca cada nodo: la fuente de verdad de los
 * campos que recibe el nodo SIGUIENTE (`{{payload.<campo>}}`).
 *
 * ## Por qué
 *
 * No había ninguna. El `examplePayload` de los nodos está a `null`, y Hermes
 * adivinaba las variables de las plantillas: escribió `{{text}}` y
 * `{{subject}}`, y los correos y mensajes llegaron VACÍOS (F5 del Builder).
 * host-agent tenía su propia tabla medida para cinco nodos. Ahora la tabla
 * vive aquí, para Hermes y para el MCP que se construya sobre las mismas
 * herramientas.
 *
 * ## Cómo se lee
 *
 * - `forma`:
 *   - `campos`: saca esas claves de primer nivel (y quizá alguna más).
 *   - `la-entrada`: deja pasar lo que le entró (las claves de `extras`, si
 *     las hay, se añaden en `_meta`).
 *   - `la-define-el-nodo`: sus campos los decide su configuración (las
 *     reglas de un Transform, lo que devuelve un Code).
 * - `fuente`: `medido` (salió en un payload real de producción) o `codigo`
 *   (leído del código que lo arma).
 * - `codigo`: dónde se arma, con el repo delante — `api:` (los triggers),
 *   `hw:` (hw-nodes, que ejecuta los nodos) o `comun:` (un fichero gemelo de
 *   `common/`, en los dos). Un guardián en cada repo comprueba que cada campo
 *   aparece en esos ficheros.
 *
 * ## Lo que no se sabe, dicho
 *
 * Todo tipo de nodo está en `NODE_OUTPUTS` o en `SALIDAS_DESCONOCIDAS`, con
 * su porqué (lo vigila un test con `ALL_NODE_TYPES`). `salidaDelNodo` nunca
 * se calla: o da la salida, o dice que no se sabe. Que Hermes diga «no sé qué
 * campos saca» es mejor que inventarlos.
 */
export type FuenteDeLaSalida = 'medido' | 'codigo';
export type FormaDeLaSalida = 'campos' | 'la-entrada' | 'la-define-el-nodo';
export interface SalidaDeNodo {
    type: NodeType;
    /** Triggers: el servicio. */
    service?: string;
    /** Acciones: la operación. */
    operation?: string;
    /** Nodos con modos (el vector store): el modo. */
    mode?: string;
    forma: FormaDeLaSalida;
    /** Las claves de primer nivel que manda al nodo siguiente (forma `campos`). */
    campos?: readonly string[];
    /** Lo que añade en `_meta` cuando la forma es `la-entrada`. */
    extras?: readonly string[];
    /**
     * [mejora #188] Cuando lo que saca es una LISTA que se recorre: el nodo
     * siguiente corre una vez por cada elemento de `lista` y recibe ESE elemento
     * como payload (`execute-with-iteration.ts` de node-sdk). Sus plantillas
     * leen estos `campos` (`{{payload.title}}`), no los de arriba.
     */
    porElemento?: {
        lista: string;
        campos: readonly string[];
    };
    fuente: FuenteDeLaSalida;
    /** Cómo usarlo, en inglés: es lo que lee el modelo. */
    nota?: string;
    /** Dónde se arma: `api:…`, `hw:…` o `comun:…`, relativo a `src/`. */
    codigo: readonly string[];
}
export interface SalidaDesconocida {
    type: NodeType;
    desconocida: true;
    /** En inglés: es lo que lee el modelo. */
    porQue: string;
}
export declare const NODE_OUTPUTS: readonly SalidaDeNodo[];
/** Los tipos con algo en `NODE_OUTPUTS` y los de aquí son, juntos, TODOS los tipos. */
export declare const SALIDAS_DESCONOCIDAS: readonly SalidaDesconocida[];
/**
 * Qué saca un nodo: su salida escrita, o que no se sabe (con su porqué).
 * Nunca `undefined`: si no se sabe, se dice. De las que casan, la más
 * concreta (con servicio, operación o modo) manda.
 */
export declare function salidaDelNodo(type: NodeType, opciones?: {
    service?: string;
    operation?: string;
    mode?: string;
}): SalidaDeNodo | SalidaDesconocida;
export declare function esSalidaDesconocida(s: SalidaDeNodo | SalidaDesconocida): s is SalidaDesconocida;
/** Los tipos que no están en ninguna de las dos listas: para el test del censo. */
export declare function tiposSinCensar(): NodeType[];