import type { IDispatchStrategy } from '../actor/IDispatchStrategy';
import type { IMessageMeta } from '../actor/IMessageMeta';
/** @deprecated Use IMessageMeta instead */
type MessageMeta = IMessageMeta;
import type { ILispEnvironment } from '../../engine/core/ILispEnvironment';
import type { ILispSecurityContext } from '../security/LispSecurityContext';
/**
 * LispDispatchStrategy - LISP handler dispatch for ActorBehavior.
 *
 * IMPORTANT: This instance is PRIVATE to each actor.
 * Each actor creates its own LispDispatchStrategy - never shared!
 *
 * This implements per-actor LISP handler isolation while sharing
 * the global LISP builtins (arithmetic, list ops, etc.).
 *
 * Per the expert panel consensus:
 * - Per-actor strategy instances
 * - Shared builtins (read-only)
 * - Isolated handler storage
 * - Runtime-configurable priority
 *
 * @example
 * ```typescript
 * class MyActor extends MatrixActor {
 *   private lisp = new LispDispatchStrategy(this.context.lispEnv);
 *
 *   onBootstrap() {
 *     this._actor?.addDispatchStrategy(this.lisp);
 *     this.lisp.registerHandler('calculate', '(+ (:x payload) (:y payload))');
 *   }
 * }
 * ```
 */
export declare class LispDispatchStrategy implements IDispatchStrategy {
    readonly name = "lisp";
    priority: number;
    private readonly mount;
    private readonly handlers;
    private readonly env?;
    /**
     * Security context for Lisp evaluation.
     *
     * Controls what primitives and operations are allowed.
     * Default: Environment-based (COMPONENT_CONTEXT in prod, DEVELOPER_CONTEXT in dev).
     *
     * Mark Miller (Capability Security): "Security context travels with computation."
     *
     * Vision 27 §11.11: Environment determines default context.
     */
    private _securityContext;
    /**
     * Create a LispDispatchStrategy for an actor.
     *
     * @param mount - The actor's mount path
     * @param env - Optional LISP environment (from context.lispEnv)
     * @param priority - Dispatch priority (default: 10, after system commands)
     * @param securityContext - Optional security context (default: environment-based)
     */
    constructor(mount: string, env?: ILispEnvironment, priority?: number, securityContext?: ILispSecurityContext);
    /**
     * Get the current security context.
     */
    get securityContext(): ILispSecurityContext;
    /**
     * Set the security context for this dispatch strategy.
     *
     * This controls what primitives and operations are allowed during
     * LISP handler execution.
     *
     * @param context - The security context to use
     */
    setSecurityContext(context: ILispSecurityContext): void;
    /**
     * Check if a LISP handler exists for this command.
     */
    canHandle(command: string): boolean;
    /**
     * Execute the LISP handler for a command.
     *
     * Security context is passed to the environment for primitive-level
     * enforcement per Vision 18 and 27.
     */
    handle(command: string, payload: unknown, meta: MessageMeta): Promise<unknown>;
    /**
     * Register a LISP handler expression for a command.
     *
     * The handler is stored locally and will be used when the command
     * is dispatched. This enables per-actor handler isolation.
     *
     * @param command - Command name
     * @param handler - LISP expression string
     */
    registerHandler(command: string, handler: string): void;
    /**
     * Unregister a LISP handler.
     *
     * @param command - Command name
     */
    unregisterHandler(command: string): void;
    /**
     * Get list of registered handler commands.
     */
    listHandlers(): string[];
    /**
     * Check if a specific handler is registered locally.
     */
    hasHandler(command: string): boolean;
    /**
     * Get the handler expression for a command.
     */
    getHandler(command: string): string | undefined;
    /**
     * Dispose and clean up.
     *
     * Unregisters all handlers from the global environment.
     */
    dispose(): void;
}
export {};
//# sourceMappingURL=LispDispatchStrategy.d.ts.map