import { MatrixActor } from '../../core/MatrixActor';
import type { SExpr } from '../SExpr';
import type { IStream } from '../IStream';
import type { IActiveSubscription } from '../IActiveSubscription';
/**
 * LispEval - Evaluates LISP expressions in JSON wire format
 *
 * The wire format is simple: LISP as JSON arrays
 *   ["+", 1, 2, 3] → 6
 *   ["call", "service", "method", {...params}]
 *
 * Mount: {namespace}.lisp
 *
 * @example
 * await callComponent('flowpad.lisp', 'eval', {
 *   expr: ["+", 1, 2, 3]
 * })
 * // → 6
 */
export declare class LispEval extends MatrixActor {
    static accepts: {
        eval: {
            expr: string;
        };
        define: {
            name: string;
            value: string;
        };
        getEnv: {};
        registerService: {
            mount: string;
        };
        listServices: {};
        subscribe: {
            stream: string;
            outputTopic: string;
        };
        unsubscribe: {
            subscriptionId: string;
        };
        listSubscriptions: {};
    };
    static emits: {
        evaluated: {
            expr: string;
            result: string;
            durationMs: string;
        };
        evalError: {
            expr: string;
            error: string;
        };
        defined: {
            name: string;
            value: string;
        };
        'stream.subscribed': {
            subscriptionId: string;
            outputTopic: string;
        };
        'stream.unsubscribed': {
            subscriptionId: string;
        };
        'stream.value': {
            subscriptionId: string;
            value: string;
        };
        'stream.error': {
            subscriptionId: string;
            error: string;
        };
    };
    private _interpreter;
    private _streamRuntime?;
    private _localServices;
    protected onBootstrap(): Promise<void>;
    /**
     * Evaluate a LISP expression
     */
    onEval(params: {
        expr: SExpr;
    }): Promise<unknown>;
    /**
     * Define a global binding
     */
    onDefine(params: {
        name: string;
        value: unknown;
    }): Promise<void>;
    /**
     * Get current environment (for debugging)
     */
    onGetEnv(): Promise<Record<string, unknown>>;
    /**
     * Register a local service mount for routing optimization hints.
     * All calls still go through transport - this is metadata that could
     * be used for future transport-level optimization (e.g., priority routing).
     */
    onRegisterService(params: {
        mount: string;
    }): void;
    /**
     * List all registered local services
     */
    onListServices(): {
        services: string[];
    };
    /**
     * Subscribe to a stream and activate the pipeline
     */
    onSubscribe(params: {
        stream: IStream;
        outputTopic?: string;
    }): Promise<{
        subscriptionId: string;
    }>;
    /**
     * Unsubscribe from a stream
     */
    onUnsubscribe(params: {
        subscriptionId: string;
    }): Promise<{
        success: boolean;
    }>;
    /**
     * List all active stream subscriptions
     */
    onListSubscriptions(): Promise<{
        subscriptions: IActiveSubscription[];
    }>;
}
//# sourceMappingURL=LispEval.d.ts.map