import { BlueNode } from '@blue-labs/language';
import { ContractBundle } from './contract-bundle.js';
import { ChannelRunner } from './channel-runner.js';
import { ContractLoader } from './contract-loader.js';
import { JsonPatch } from '../model/shared/json-patch.js';
import { DocumentUpdateData, DocumentProcessingRuntime } from '../runtime/document-processing-runtime.js';
export interface ProcessorContext {
    resolvePointer(relativePointer: string): string;
    applyPatch(patch: JsonPatch): Promise<void>;
}
export interface ScopeExecutionHooks {
    isScopeInactive(scopePath: string): boolean;
    createContext(scopePath: string, bundle: ContractBundle, event: BlueNode, allowTerminatedWork: boolean, lifecycle?: boolean): ProcessorContext;
    recordLifecycleForBridging(scopePath: string, event: BlueNode): Promise<void>;
    enterFatalTermination(scopePath: string, bundle: ContractBundle | null, reason: string): Promise<void>;
    fatalReason(error: unknown, label: string): string;
    markCutOff(scopePath: string): Promise<void>;
}
export interface ScopeExecutorOptions {
    runtime: DocumentProcessingRuntime;
    contractLoader: ContractLoader;
    channelRunner: ChannelRunner;
    bundles: Map<string, ContractBundle>;
    hooks: ScopeExecutionHooks;
    blueId: (node: BlueNode) => string;
    nodeAt(scopePath: string): BlueNode | null;
    createDocumentUpdateEvent(data: DocumentUpdateData, scopePath: string): BlueNode;
    matchesDocumentUpdate(scopePath: string, watchPath: string | null | undefined, changedPath: string): boolean;
}
export declare class ScopeExecutor {
    private readonly runtime;
    private readonly contractLoader;
    private readonly channelRunner;
    private readonly bundles;
    private readonly hooks;
    private readonly blueId;
    private readonly nodeAt;
    private readonly createDocumentUpdateEvent;
    private readonly matchesDocumentUpdate;
    constructor(options: ScopeExecutorOptions);
    initializeScope(scopePath: string, chargeScopeEntry: boolean): Promise<void>;
    loadBundles(scopePath: string): void;
    processExternalEvent(scopePath: string, event: BlueNode): Promise<void>;
    private processPreparedExternalEvent;
    handlePatch(scopePath: string, bundle: ContractBundle, patch: JsonPatch, allowReservedMutation: boolean): Promise<void>;
    deliverLifecycle(scopePath: string, bundle: ContractBundle | null, event: BlueNode, finalizeAfter: boolean): Promise<void>;
    private processEmbeddedChildren;
    private refreshBundle;
    private nextEmbeddedPath;
    private loadBundle;
    private addInitializationMarker;
    private finalizeScope;
    private bridgeEmbeddedEmissions;
    private drainTriggeredQueue;
    private channelsMatching;
    private isProcessorManagedChannel;
    private validatePatchBoundary;
    private enforceReservedKeyWriteProtection;
    private markCutOffChildrenIfNeeded;
    private hasInitializationMarker;
    private createLifecycleEvent;
}
//# sourceMappingURL=scope-executor.d.ts.map