import { z } from 'zod';

interface DecidoEdge {
    id: string;
    source: string;
    target: string;
    condition?: string;
    sourceHandle: 'success' | 'error' | 'timeout' | string;
}
interface DecidoNode {
    id: string;
    type: string;
    inputMapping?: Record<string, string | {
        template: string;
    }>;
    payload: unknown;
    visual?: {
        x: number;
        y: number;
        parentId?: string;
    };
}
interface DecidoBlueprint {
    id: string;
    version: string;
    name: string;
    signature: {
        inputs: Record<string, 'string' | 'number' | 'boolean' | 'object'>;
        outputs: string[];
    };
    nodes: Record<string, DecidoNode>;
    edges: DecidoEdge[];
}
interface DecidoPersonaConfig {
    id: string;
    name: string;
    voiceName?: string;
    systemInstruction: string;
}
interface DecidoEnvironmentConfig {
    gradient?: string;
    greetingText?: string;
    subtitle?: string;
    borderColor?: string;
    glowColor?: string;
    buttonColor?: string;
    buttonGlow?: string;
}
interface DecidoConfig {
    version: string;
    persona?: DecidoPersonaConfig;
    environments?: Record<string, DecidoEnvironmentConfig>;
    mcpServers?: string[];
    features?: {
        voice?: boolean;
        vision?: boolean;
        sandbox?: boolean | 'strict' | 'loose';
    };
    network?: {
        mlxPort?: number;
        mlxHost?: string;
    };
}
declare function defineConfig(config: DecidoConfig): DecidoConfig;

/** Base interface for any event that can be displayed on an Aura Calendar. */
interface CalendarEvent {
    id: string;
    title: string;
    start: string;
    end?: string;
    color?: string;
    description?: string;
    status?: string;
    metadata?: Record<string, unknown>;
}
/** Specific types for Industrial Orchestration. */
type ResourceType = 'MACHINE' | 'PERSON';
type ResourceStatus = 'AVAILABLE' | 'BUSY' | 'MAINTENANCE' | 'OFF_SHIFT';
type ScheduleStatus = 'PLANNED' | 'IN_PROGRESS' | 'COMPLETED' | 'DELAYED';
interface IndustrialResource {
    id: string;
    name: string;
    type: ResourceType;
    status: ResourceStatus;
    capabilities: string[];
    currentLoad: number;
    maxCapacity: number;
}
interface ResourceSchedule extends CalendarEvent {
    resourceId: string;
    priority: number;
    status: ScheduleStatus;
    timeEstimation: string;
}

interface LegacyKeyframe extends Record<string, unknown> {
    id?: string;
    track?: string;
    speech?: string;
    actorId?: string;
    intent?: string;
    state?: string;
    canvas?: boolean;
    label?: string;
    targetBlueprintId?: string;
    inputMapping?: Record<string, string>;
    outputMapping?: Record<string, string>;
    inputs?: Record<string, string>;
    handle?: string;
    outputs?: Record<string, string>;
    uiSchema?: object;
    schema?: object;
    dataBindings?: Record<string, string>;
    autoComplete?: boolean;
    triggerType?: string;
    cronExpression?: string;
    webhookPath?: string;
    eventChannel?: string;
    conditionExpression?: string;
    variableTarget?: string;
    variableValue?: unknown;
    morphType?: string;
    morphData?: unknown;
    componentId?: string;
    suspendOnMorph?: boolean;
    type?: string;
    shellAction?: string;
    position?: {
        x: number;
        y: number;
    };
    parentId?: string;
}
declare function convertLegacyTimelineToBlueprint(timelineId: string, legacyKeyframes: LegacyKeyframe[], legacyEdges: Record<string, unknown>[]): DecidoBlueprint;

/**
 * ## EngineMemory
 *
 * Repositorio de memoria del motor DecidoEngine dividido en tres ámbitos o alcances de visibilidad.
 */
interface EngineMemory {
    /** Persiste de forma global entre múltiples sesiones o flujos ejecutados. */
    global: Record<string, unknown>;
    /** Almacenamiento continuo a nivel de la sesión o llamada activa actual en el grafo. */
    session: Record<string, unknown>;
    /** Memoria de corto alcance que se limpia y purga una vez que el sub-grafo (subflujo) culmina. */
    local: Record<string, unknown>;
}
/**
 * ## CallFrame
 *
 * Representa un marco de ejecución dentro de la pila de llamadas del motor.
 * Permite mantener el rastro del grafo/subflujo activo, el nodo actual,
 * un snapshot inmutable para reanudar el flujo local del padre y el nodo de retorno.
 */
interface CallFrame {
    /** Identificador del blueprint (diseño/grafo) en ejecución en este marco. */
    blueprintId: string;
    /** Identificador del nodo activo en ejecución. */
    currentNodeId: string;
    /** Snapshot inmutable de la memoria local del marco padre retenido al entrar al subflujo. */
    memorySnapshot: Record<string, unknown>;
    /** Identificador del nodo del blueprint padre al cual debe retornar el control al desapilar el frame. */
    returnToNodeId: string | null;
}
/**
 * Estados operacionales por los que transita la máquina de estados del motor.
 */
type EngineState = 'IDLE' | 'RUNNING' | 'SUSPENDED' | 'ERROR';
/**
 * ## DecidoKernel
 *
 * Interfaz contractual y descriptiva del Kernel central del motor de Decido OS.
 * Define la API expuesta obligatoria para aplicaciones host, paneles de administración y depuradores (DevTools).
 */
interface DecidoKernel {
    /** Estado operacional activo del motor. */
    state: EngineState;
    /** Pila de marcos de ejecución activa. */
    callStack: CallFrame[];
    /** Repositorio de memoria reactiva de tres niveles. */
    memory: EngineMemory;
    /**
     * Inicializa la ejecución secuencial de un blueprint.
     *
     * @param blueprintId Identificador del plano/grafo a iniciar.
     * @param initialInputs Variables iniciales de entrada a inyectar en la sesión.
     */
    start(blueprintId: string, initialInputs: Record<string, unknown>): void;
    /**
     * Pausa de inmediato la ejecución secuencial de los nodos del motor.
     *
     * @param reason Causa de la suspensión de la ejecución.
     */
    suspend(reason: 'WAITING_USER' | 'WAITING_MCP' | 'WAITING_GATE_APPROVAL' | 'INFINITE_LOOP_DETECTED'): void;
    /**
     * Reanuda la ejecución secuencial de un motor en suspensión, inyectando variables adicionales.
     *
     * @param injectedVariables Variables de sesión a inyectar al reanudar.
     */
    resume(injectedVariables?: Record<string, unknown>): void;
    /**
     * Fuerza un salto incondicional por interrupción hacia un nodo específico en el flujo.
     *
     * @param intentNodeId Nodo destino del salto de interrupción.
     */
    interrupt(intentNodeId: string): void;
    /**
     * Registra un callback de escucha sobre los eventos del ciclo de vida del kernel.
     *
     * @param event Nombre del evento contractual.
     * @param callback Función de retorno que consumirá la carga útil del evento emitido.
     */
    on(event: 'node:enter' | 'node:complete' | 'graph:start' | 'graph:end' | 'engine:suspend' | 'engine:resume' | 'engine:callframe_push' | 'engine:callframe_pop' | 'error', callback: (payload: any) => void): void;
}

type AgentRole = 'dev' | 'marketing' | 'security' | 'data_hunter' | 'trainer' | 'evaluator';
type AgentStatus = 'idle' | 'thinking' | 'acting' | 'observing' | 'error' | 'terminated';
type Priority = 'low' | 'normal' | 'high' | 'critical';
type EventType = 'agent_spawned' | 'agent_terminated' | 'agent_status_changed' | 'message_sent' | 'message_received' | 'cognitive_frame' | 'broadcast_event' | 'gas_exhausted' | 'gas_refueled' | 'memory_indexed' | 'error' | 'trace' | 'system_telemetry';
interface AgentInfo {
    id: string;
    role: AgentRole;
    name: string;
    status: AgentStatus;
    tasks_completed: number;
    gas_remaining: number;
    gas_max: number;
    created_at: number;
    parent_id?: string;
}
interface AgentMessage {
    sender: string;
    target: string;
    intent: string;
    payload: string;
    priority: Priority;
    timestamp: number;
}
interface CognitiveFrame {
    agent_id: string;
    thought: string;
    action: string;
    tool_target?: string;
    tool_args?: Record<string, unknown>;
    observation: string;
    timestamp: number;
}
interface SystemEvent {
    event_type: EventType;
    agent_id: string;
    data: Record<string, unknown>;
    timestamp: number;
}
interface MemoryEntry {
    role: string;
    content: string;
}
interface TraceData {
    trace_id: string;
    parent_id?: string;
    name: string;
    status: string;
    latency_ms: number;
    tokens_input?: number;
    tokens_output?: number;
    input_payload?: Record<string, unknown>;
    output_payload?: Record<string, unknown>;
}
interface ToolMetadata {
    name: string;
    description: string;
    input_schema: Record<string, unknown>;
}
interface AgentContextResponse {
    memory: MemoryEntry[];
    tools: string[];
}
interface AgentTemplate {
    role: AgentRole;
}
interface SwarmTemplate {
    id: string;
    name: string;
    description: string;
    agents: AgentTemplate[];
}
declare const ROLE_CONFIG: {
    readonly dev: {
        readonly icon: "⚙️";
        readonly color: "#00d4ff";
        readonly gradient: "linear-gradient(135deg, #00d4ff, #0057ff)";
        readonly label: "Developer";
        readonly glow: "0 0 30px #00d4ff60";
    };
    readonly marketing: {
        readonly icon: "📊";
        readonly color: "#ff00e5";
        readonly gradient: "linear-gradient(135deg, #ff00e5, #7b00ff)";
        readonly label: "Marketing";
        readonly glow: "0 0 30px #ff00e560";
    };
    readonly security: {
        readonly icon: "🛡️";
        readonly color: "#ff6b00";
        readonly gradient: "linear-gradient(135deg, #ff6b00, #ff0040)";
        readonly label: "Security";
        readonly glow: "0 0 30px #ff6b0060";
    };
    readonly data_hunter: {
        readonly icon: "🔍";
        readonly color: "#00ff88";
        readonly gradient: "linear-gradient(135deg, #00ff88, #00b4d8)";
        readonly label: "Data Hunter";
        readonly glow: "0 0 30px #00ff8860";
    };
    readonly trainer: {
        readonly icon: "🧠";
        readonly color: "#aa66ff";
        readonly gradient: "linear-gradient(135deg, #aa66ff, #6600cc)";
        readonly label: "Trainer";
        readonly glow: "0 0 30px #aa66ff60";
    };
    readonly evaluator: {
        readonly icon: "⚖️";
        readonly color: "#ffaa00";
        readonly gradient: "linear-gradient(135deg, #ffaa00, #ff6600)";
        readonly label: "Evaluator";
        readonly glow: "0 0 30px #ffaa0060";
    };
};
declare const STATUS_CONFIG: {
    readonly idle: {
        readonly color: "#4a5568";
        readonly animation: "none";
        readonly label: "Idle";
    };
    readonly thinking: {
        readonly color: "#aa66ff";
        readonly animation: "pulse 1.5s ease-in-out infinite";
        readonly label: "Thinking...";
    };
    readonly acting: {
        readonly color: "#00ff88";
        readonly animation: "pulse 0.8s ease-in-out infinite";
        readonly label: "Acting";
    };
    readonly observing: {
        readonly color: "#00d4ff";
        readonly animation: "pulse 2s ease-in-out infinite";
        readonly label: "Observing";
    };
    readonly error: {
        readonly color: "#ff4444";
        readonly animation: "shake 0.5s ease-in-out";
        readonly label: "Error";
    };
    readonly terminated: {
        readonly color: "#2d3748";
        readonly animation: "none";
        readonly label: "Terminated";
    };
};

/**
 * ## DecidoEngine
 *
 * Motor de ejecución reactivo del ecosistema de Decido OS.
 * Implementa la interfaz `DecidoKernel` y orquesta la ejecución paso a paso de nodos
 * mediante un patrón de Inversión de Control (IoC) delegando la lógica a plugins extensibles.
 *
 * ### Flujo de Ejecución del Kernel y Subflujos:
 *
 * ```mermaid
 * sequenceDiagram
 *     participant Host as Aplicación Host
 *     participant Engine as DecidoEngine
 *     participant Reg as PluginRegistry
 *     participant Plugin as NodePlugin
 *
 *     Host->>Engine: start(blueprintId, initialInputs)
 *     Note over Engine: Estado: RUNNING<br/>Inicia primer CallFrame
 *     Engine-->>Host: Evento 'graph:start'
 *
 *     Host->>Engine: executeNode(node)
 *     Engine->>Reg: get(node.type)
 *     Reg-->>Engine: Plugin
 *     Engine->>Plugin: execute(node.payload, context)
 *
 *     alt Flujo de Completado Simple
 *         Plugin->>Engine: context.dispatchCompletion(handle, outputs)
 *         Note over Engine: Agrega outputs a memory.session
 *         Engine-->>Host: Evento 'node:complete'
 *     else Flujo de Suspensión
 *         Plugin->>Engine: context.dispatchSuspend(reason)
 *         Note over Engine: Estado: SUSPENDED
 *         Engine-->>Host: Evento 'engine:suspend'
 *         Host->>Engine: resume(injectedVariables)
 *         Note over Engine: Estado: RUNNING
 *         Engine-->>Host: Evento 'engine:resume'
 *     else Flujo de Subflujo (Call Stack)
 *         Plugin->>Engine: context.pushCallFrame(targetBlueprintId, startNodeId)
 *         Note over Engine: Respalda memory.local anterior<br/>Inicia memory.local limpia
 *         Engine-->>Host: Evento 'engine:callframe_push'
 *
 *         Note over Engine: Ejecución en subflujo...
 *
 *         Plugin->>Engine: context.popCallFrame(outputs, handle)
 *         Note over Engine: Restaura memory.local anterior
 *         Engine-->>Host: Evento 'engine:callframe_pop'
 *         Engine-->>Host: Evento 'node:complete' (nodo padre)
 *     end
 * ```
 *
 * @summary Motor central de orquestación y máquina de estados para blueprints.
 */
declare class DecidoEngine implements DecidoKernel {
    /** Estado actual en el que se encuentra el kernel. */
    state: EngineState;
    /** Pila de llamadas activa para soportar subflujos. */
    callStack: CallFrame[];
    /** Repositorio de memoria reactiva en tres alcances (global, sesión, local). */
    memory: EngineMemory;
    /** Mapeo de suscriptores para la propagación reactiva de eventos del ciclo de vida. */
    private eventListeners;
    /**
     * Inicializa la ejecución del motor cargando el primer frame en la pila de llamadas
     * e inyectando las variables de sesión iniciales.
     *
     * @param blueprintId Identificador del plano/grafo raíz a ejecutar.
     * @param initialInputs Variables iniciales a inyectar en el contexto de sesión.
     * @returns void
     * @emits `graph:start`
     */
    start(blueprintId: string, initialInputs?: Record<string, unknown>): void;
    /**
     * Resuelve y ejecuta la lógica de un nodo delegando el trabajo al plugin correspondiente.
     * Genera un contexto seguro de Inversión de Control para el plugin.
     *
     * @param node Nodo de ejecución que contiene tipo, identificador y carga útil.
     * @returns Promesa que se resuelve al culminar el envío o disparo de la lógica del plugin.
     * @throws No arroja errores directamente; los captura internamente y emite el evento `'error'`.
     * @emits `node:enter`, `node:complete`, `engine:suspend`, `error`
     */
    executeNode(node: DecidoNode): Promise<void>;
    /**
     * Cambia el estado del motor a `SUSPENDED` y detiene la ejecución secuencial reactiva.
     *
     * @param reason Causa de la suspensión de la ejecución.
     * @returns void
     * @emits `engine:suspend`
     */
    suspend(reason: 'WAITING_USER' | 'WAITING_MCP' | 'WAITING_GATE_APPROVAL' | 'INFINITE_LOOP_DETECTED'): void;
    /**
     * Reanuda la ejecución del motor, inyectando nuevas variables a la memoria de sesión.
     *
     * @param injectedVariables Variables de entrada suministradas al reanudar.
     * @returns void
     * @emits `engine:resume`
     */
    resume(injectedVariables?: Record<string, unknown>): void;
    /**
     * Crea y apila un nuevo CallFrame para soportar la ejecución aislada de sub-grafos.
     * Realiza un respaldo inmutable de la memoria local del marco padre.
     *
     * @param targetBlueprintId Identificador del subflujo/blueprint a cargar.
     * @param startNodeId Nodo de entrada del subflujo.
     * @returns void
     * @emits `engine:callframe_push`
     */
    pushCallFrame(targetBlueprintId: string, startNodeId: string): void;
    /**
     * Retira el marco superior de la pila de llamadas, restaura la memoria local
     * del marco padre e informa de la finalización del nodo de subflujo original.
     *
     * @param outputs Diccionario de salidas generadas por el subflujo a retornar.
     * @param handle Canal/Handle condicional de retorno (por defecto `'success'`).
     * @returns void
     * @emits `engine:callframe_pop`, `node:complete`
     */
    popCallFrame(outputs?: Record<string, unknown>, handle?: string): void;
    /**
     * Fuerza un salto de ejecución hacia un nodo de intención por interrupción.
     *
     * @param intentNodeId Identificador del nodo objetivo del salto.
     * @returns void
     */
    interrupt(intentNodeId: string): void;
    /**
     * Registra un callback de escucha sobre un evento del ciclo de vida del kernel.
     *
     * @param event Nombre del evento a escuchar.
     * @param callback Función de retorno que recibirá la carga útil del evento.
     * @returns void
     */
    on(event: string, callback: (payload: unknown) => void): void;
    /**
     * Emite un evento reactivo a todos sus escuchas registrados capturando fallos
     * de listeners individuales sin interrumpir el motor.
     *
     * @param event Nombre del evento a emitir.
     * @param payload Carga útil asociada al evento.
     * @returns void
     */
    private emit;
}

/**
 * ## DecidoPluginContext
 *
 * Contexto de Inversión de Control (IoC) expuesto y provisto a cada `NodePlugin` durante su ejecución.
 * Otorga acceso seguro de lectura/escritura a los alcances de memoria del motor y permite
 * disparar flujos de control como la finalización del nodo, suspensiones reactivas o manipulación
 * de la pila de llamadas (subflujos).
 */
interface DecidoPluginContext {
    /** Acceso reactivo a la memoria del motor dividida en global, sesión y local. */
    memory: EngineMemory;
    /**
     * Informa al kernel que la ejecución del nodo culminó de forma exitosa o con un handle condicional,
     * propagando opcionalmente variables de salida a la sesión del motor.
     *
     * @param handle Canal condicional de salida (ej: `'success'`, `'error'`).
     * @param outputs Diccionario de variables de salida a propagar.
     */
    dispatchCompletion: (handle: string, outputs?: Record<string, unknown>) => void;
    /**
     * Pausa la ejecución secuencial del motor de forma inmediata, colocando el estado general en `SUSPENDED`.
     *
     * @param reason Motivo por el cual la ejecución se suspende (ej: esperando aprobación o entrada de usuario).
     */
    dispatchSuspend: (reason: 'WAITING_USER' | 'WAITING_MCP' | 'WAITING_GATE_APPROVAL' | 'INFINITE_LOOP_DETECTED') => void;
    /**
     * Inicia la ejecución de un subflujo, apilando un nuevo marco de ejecución y aislando la memoria local.
     *
     * @param targetBlueprintId Identificador del plano/grafo hijo.
     * @param startNodeId Nodo de entrada dentro del subflujo.
     */
    pushCallFrame: (targetBlueprintId: string, startNodeId: string) => void;
    /**
     * Finaliza la ejecución del subflujo activo, desapilando el call frame superior y restaurando el contexto padre.
     *
     * @param outputs Diccionario de salida a retornar al grafo padre.
     * @param handle Canal condicional de retorno del subflujo.
     */
    popCallFrame: (outputs?: Record<string, unknown>, handle?: string) => void;
}
/**
 * ## NodePlugin
 *
 * Interfaz contractual para la definición de plugins de ejecución de nodos en Decido OS.
 */
interface NodePlugin {
    /** Identificador de tipo único que casa con la propiedad `type` del nodo (ej: `'ai:dialogue'`). */
    type: string;
    /**
     * Lógica central de ejecución del nodo. Invocada reactivamente por el motor.
     *
     * @param payload Carga útil deserializada del nodo, correspondiente a su configuración.
     * @param context Contexto seguro de IoC para operaciones de control y memoria.
     */
    execute: (payload: unknown, context: DecidoPluginContext) => Promise<void> | void;
    /**
     * Método opcional invocado si la ejecución es cancelada o interrumpida prematuramente por el usuario
     * o por un salto de flujo forzado (ej: detener un proceso de Texto a Voz / TTS).
     */
    abort?: () => void;
}
/**
 * ## PluginRegistry
 *
 * Registro central y único (Singleton) que almacena la catálogo de plugins activos de nodos del motor.
 */
declare const PluginRegistry: {
    /** Colección activa de plugins indexados por su identificador de tipo. */
    plugins: Map<string, NodePlugin>;
    /**
     * Registra un nuevo plugin de ejecución en el catálogo del motor.
     *
     * @param plugin Instancia del plugin contractual a añadir.
     */
    register(plugin: NodePlugin): void;
    /**
     * Recupera un plugin de ejecución previamente registrado según su tipo.
     *
     * @param type Identificador del tipo de nodo.
     * @returns Instancia del `NodePlugin` correspondiente, o `undefined` si no está registrado.
     */
    get(type: string): NodePlugin | undefined;
    /**
     * Purga y vacía por completo el catálogo de plugins activos.
     * Utilizado principalmente para limpiezas y reinicio de suites de pruebas.
     */
    clear(): void;
};

declare const DecidoEdgeSchema: z.ZodObject<{
    id: z.ZodString;
    source: z.ZodString;
    target: z.ZodString;
    condition: z.ZodOptional<z.ZodString>;
    sourceHandle: z.ZodString;
}, z.core.$strip>;
declare const DecidoNodeSchema: z.ZodObject<{
    id: z.ZodString;
    type: z.ZodString;
    inputMapping: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
        template: z.ZodString;
    }, z.core.$strip>]>>>;
    payload: z.ZodUnknown;
    visual: z.ZodOptional<z.ZodObject<{
        x: z.ZodNumber;
        y: z.ZodNumber;
        parentId: z.ZodOptional<z.ZodString>;
    }, z.core.$strip>>;
}, z.core.$strip>;
declare const DecidoBlueprintSchema: z.ZodObject<{
    id: z.ZodString;
    version: z.ZodString;
    name: z.ZodString;
    signature: z.ZodObject<{
        inputs: z.ZodRecord<z.ZodString, z.ZodEnum<{
            string: "string";
            number: "number";
            boolean: "boolean";
            object: "object";
        }>>;
        outputs: z.ZodArray<z.ZodString>;
    }, z.core.$strip>;
    nodes: z.ZodRecord<z.ZodString, z.ZodObject<{
        id: z.ZodString;
        type: z.ZodString;
        inputMapping: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
            template: z.ZodString;
        }, z.core.$strip>]>>>;
        payload: z.ZodUnknown;
        visual: z.ZodOptional<z.ZodObject<{
            x: z.ZodNumber;
            y: z.ZodNumber;
            parentId: z.ZodOptional<z.ZodString>;
        }, z.core.$strip>>;
    }, z.core.$strip>>;
    edges: z.ZodArray<z.ZodObject<{
        id: z.ZodString;
        source: z.ZodString;
        target: z.ZodString;
        condition: z.ZodOptional<z.ZodString>;
        sourceHandle: z.ZodString;
    }, z.core.$strip>>;
}, z.core.$strip>;
declare function validateBlueprint(data: unknown): {
    id: string;
    version: string;
    name: string;
    signature: {
        inputs: Record<string, "string" | "number" | "boolean" | "object">;
        outputs: string[];
    };
    nodes: Record<string, {
        id: string;
        type: string;
        payload: unknown;
        inputMapping?: Record<string, string | {
            template: string;
        }> | undefined;
        visual?: {
            x: number;
            y: number;
            parentId?: string | undefined;
        } | undefined;
    }>;
    edges: {
        id: string;
        source: string;
        target: string;
        sourceHandle: string;
        condition?: string | undefined;
    }[];
};

/**
 * Resuelve expresiones de tipo template contra la EngineMemory.
 * Soporta:
 * - Paths directos: "memory.session.userId" → context.memory.session.userId
 * - Templates: "{{session.userId}}" → valor interpolado
 * - Valores literales: "hello" → "hello"
 * - Números/booleans: 42, true → tal cual
 */
declare function resolveExpression(expr: unknown, memory: EngineMemory): unknown;
/**
 * Resuelve un objeto completo de mappings contra la memoria.
 * Ej: { "userId": "{{session.user.id}}", "count": 5 }
 * → { "userId": "abc123", "count": 5 }
 */
declare function resolveMappings(mapping: Record<string, unknown>, memory: EngineMemory): Record<string, unknown>;

/**
 * SubflowPlugin — Orquesta la entrada a un sub-grafo.
 *
 * Cuando el motor encuentra un nodo `core:subflow`, este plugin:
 * 1. Resuelve el inputMapping contra la memoria actual
 * 2. Hace push de un nuevo CallFrame al call stack
 * 3. Inyecta los inputs resueltos en memory.local del hijo
 *
 * El motor continuará ejecutando el sub-grafo desde su nodo 'entry'.
 * Cuando un nodo core:return ejecute popCallFrame, el motor regresa aquí.
 */
declare const SubflowPlugin: NodePlugin;

/**
 * ReturnPlugin — Orquesta la salida de un sub-grafo.
 *
 * Cuando el motor encuentra un nodo `core:return`, este plugin:
 * 1. Resuelve el outputMapping para recolectar valores de memory.local/session
 * 2. Hace pop del CallFrame actual
 * 3. Los outputs se inyectan en memory.session del padre
 * 4. El motor regresa al nodo padre con el handle especificado (success/error)
 */
declare const ReturnPlugin: NodePlugin;

/**
 * Recupera un valor almacenado asociado a la clave suministrada.
 *
 * @template T Tipo esperado del objeto a retornar.
 * @param key Clave válida de búsqueda en IndexedDB.
 * @returns Promesa que resuelve al valor correspondiente, o `undefined` si no se encuentra.
 * @example
 * ```typescript
 * const token = await get<string>('auth_token');
 * ```
 */
declare function get<T = unknown>(key: IDBValidKey): Promise<T | undefined>;
/**
 * Guarda o actualiza un valor asociado a una clave específica en el almacén.
 *
 * @param key Clave única a la cual asociar el elemento.
 * @param value Carga útil o valor a persistir.
 * @returns Promesa que se resuelve al culminar la transacción de escritura.
 * @example
 * ```typescript
 * await set('user_profile', { name: 'Julio', role: 'admin' });
 * ```
 */
declare function set(key: IDBValidKey, value: unknown): Promise<void>;
/**
 * Elimina la clave y su valor asociado del almacén.
 *
 * @param key Clave a remover del almacén.
 * @returns Promesa que se resuelve al confirmar la remoción del registro.
 * @example
 * ```typescript
 * await del('user_profile');
 * ```
 */
declare function del(key: IDBValidKey): Promise<void>;
/**
 * Vierte y limpia todas las claves y registros contenidos en el almacén de IndexedDB.
 *
 * @returns Promesa que se resuelve al purgar completamente el almacén.
 * @example
 * ```typescript
 * await clear();
 * ```
 */
declare function clear(): Promise<void>;
/**
 * Cierra físicamente la conexión de base de datos activa liberando los recursos del pool,
 * y limpia la instancia de singleton cached (`dbInstance`).
 * Utilizado primordialmente en reinicios del motor, tests unitarios, o cierres de sesión.
 *
 * @returns void
 * @example
 * ```typescript
 * resetDB();
 * ```
 */
declare function resetDB(): void;

type CorsOrigin = string | boolean | string[] | ((origin: string | undefined, cb: (err: Error | null, allow?: boolean) => void) => void);
declare function cors(options?: {
    origin?: CorsOrigin;
    credentials?: boolean;
    methods?: string[];
    allowedHeaders?: string[];
}): (req: unknown, res: unknown, next: unknown) => void;

export { type AgentContextResponse, type AgentInfo, type AgentMessage, type AgentRole, type AgentStatus, type AgentTemplate, type CalendarEvent, type CallFrame, type CognitiveFrame, type DecidoBlueprint, DecidoBlueprintSchema, type DecidoConfig, type DecidoEdge, DecidoEdgeSchema, DecidoEngine, type DecidoEnvironmentConfig, type DecidoKernel, type DecidoNode, DecidoNodeSchema, type DecidoPersonaConfig, type DecidoPluginContext, type EngineMemory, type EngineState, type EventType, type IndustrialResource, type LegacyKeyframe, type MemoryEntry, type NodePlugin, PluginRegistry, type Priority, ROLE_CONFIG, type ResourceSchedule, type ResourceStatus, type ResourceType, ReturnPlugin, STATUS_CONFIG, type ScheduleStatus, SubflowPlugin, type SwarmTemplate, type SystemEvent, type ToolMetadata, type TraceData, clear, convertLegacyTimelineToBlueprint, cors, defineConfig, del, get, resetDB, resolveExpression, resolveMappings, set, validateBlueprint };