import type { Constructor } from '@cratis/fundamentals';
import type { AppendedEvent } from '../events/AppendedEvent.js';
import type { AppendOptions } from '../eventSequences/AppendOptions.js';
import type { ReactorDeliveryResult } from './ReactorDeliveryResult.js';
import type { ReactorScenarioOptions } from './ReactorScenarioOptions.js';
import type { RecordedReactorSideEffect } from './RecordedReactorSideEffect.js';
/** Live, ordered reactor deliveries over the fixture-proven EventScenario event boundary. */
export declare class ReactorScenario {
    private readonly _reactor;
    private readonly _options;
    readonly given: {
        forEventSource(id: string, options?: AppendOptions): {
            events(...events: object[]): Promise<void>;
        };
    };
    readonly when: {
        forEventSource(id: string, options?: AppendOptions): {
            events(...events: object[]): Promise<void>;
        };
    };
    private readonly _events;
    private readonly _entries;
    private readonly _eventTypes;
    private readonly _instance?;
    private readonly _validateInstance;
    private readonly _store;
    private readonly _controller;
    private readonly _effects;
    private readonly _results;
    private _busy;
    private _failed;
    private _delivery?;
    private readonly _deliveryContext;
    private _deliveryIndex;
    constructor(_reactor: Constructor, _options?: ReactorScenarioOptions);
    private scenarioStore;
    get produced(): readonly unknown[];
    get sideEffects(): readonly RecordedReactorSideEffect[];
    get results(): readonly ReactorDeliveryResult[];
    /** Committed input and explicit service appends; recorded returned effects are not part of this history. */
    get appendedEvents(): readonly AppendedEvent[];
    /** Assertion view, deliberately not a callable Promise-like `then`. */
    get then(): {
        readonly produced: readonly unknown[];
        readonly sideEffects: readonly RecordedReactorSideEffect[];
        readonly results: readonly ReactorDeliveryResult[];
    };
    shouldHaveProduced<T>(type: new (...args: never[]) => T, predicate?: (value: T) => boolean): void;
    shouldNotHaveProduced(type: Function): void;
    /** Replay, redelivery and scheduler semantics need a separate kernel-backed increment. */
    replay(): Promise<never>;
    redeliver(): Promise<never>;
    private deliver;
    private violation;
    private latch;
    private throwIfViolated;
    private process;
    private record;
}
//# sourceMappingURL=ReactorScenario.d.ts.map