import { AppendOperationsBroadcaster } from '../eventSequences/AppendOperationsBroadcaster.js';
import { type Constructor } from '@cratis/fundamentals';
import type { AppendedEvent } from '../events/AppendedEvent.js';
import type { AppendOptions } from '../eventSequences/AppendOptions.js';
import type { AppendResult } from '../eventSequences/AppendResult.js';
import type { AppendedEventWithResult } from '../eventSequences/AppendedEventWithResult.js';
import type { EventForEventSourceId } from '../eventSequences/EventForEventSourceId.js';
import { EventSequenceId } from '../eventSequences/EventSequenceId.js';
import { EventSequenceNumber } from '../eventSequences/EventSequenceNumber.js';
import type { IEventSequence } from '../eventSequences/IEventSequence.js';
import type { ITransactionalEventSequence } from '../eventSequences/ITransactionalEventSequence.js';
import type { CompleteStreamResult } from '../eventSequences/CompleteStreamResult.js';
import { InProcessConstraints } from './InProcessConstraints.js';
import type { EventScenarioOptions } from './EventScenarioOptions.js';
import { UnsupportedEventSequenceOperation } from './UnsupportedEventSequenceOperation.js';
/**
 * Observe every unsupported operation a scenario sequence reports, however the caller receives it.
 * Internal to the testing harness; ReactorScenario uses it to fail deliveries that swallow such errors.
 * @param sequence - The in-process sequence to observe.
 * @param observer - Called with each unsupported-operation error the sequence creates.
 */
export declare function observeUnsupportedOperations(sequence: object, observer: (error: UnsupportedEventSequenceOperation) => void): void;
/** Fixture-backed, scenario-local append sequence; no kernel or observer scheduler is started. */
export declare class InProcessEventSequence implements IEventSequence {
    private readonly _constraints?;
    readonly id: EventSequenceId;
    private readonly _catalog;
    private readonly _history;
    private readonly _store;
    private readonly _namespace;
    private readonly _clock;
    private readonly _correlationId?;
    private _setup;
    private _allowSeedAppend;
    private _stagedSeeds?;
    private _stagedNotifications?;
    private _busy;
    private readonly _results;
    readonly appendOperations: AppendOperationsBroadcaster<AppendedEventWithResult[]>;
    constructor(options: EventScenarioOptions, eventTypes: Constructor[], _constraints?: InProcessConstraints | undefined);
    get results(): readonly AppendResult[];
    get appendedEvents(): readonly AppendedEvent[];
    /** Validate and stage all setup appends, then commit and notify in single-append order. */
    seed(source: string, events: object[], options?: AppendOptions): Promise<void>;
    get transactional(): ITransactionalEventSequence;
    append(eventSourceId: string, event: object, options?: AppendOptions): Promise<AppendResult>;
    appendMany(eventSourceId: string, events: object[], options?: AppendOptions): Promise<AppendResult[]>;
    appendMany(events: EventForEventSourceId[], options?: AppendOptions): Promise<AppendResult[]>;
    getNextSequenceNumber(): Promise<EventSequenceNumber>;
    getTailSequenceNumber(source?: string, sourceType?: string, streamType?: string, streamId?: string, types?: Constructor[]): Promise<EventSequenceNumber>;
    getTailSequenceNumberForObserver(observer: Constructor): Promise<EventSequenceNumber>;
    hasEventsFor(source: string): Promise<boolean>;
    getForEventSourceIdAndEventTypes(source: string, types: Constructor[], streamType?: string, streamId?: string, sourceType?: string): Promise<AppendedEvent[]>;
    getFromSequenceNumber(sequence: EventSequenceNumber, source?: string, types?: Constructor[]): Promise<AppendedEvent[]>;
    redact(): Promise<void>;
    redactForEventSource(): Promise<void>;
    completeStream(): Promise<CompleteStreamResult>;
    private filterIds;
    private validateRouteFilters;
    private validateBatchOptions;
    private validateGuid;
    private checkedDate;
    private validateSource;
    private checkedContent;
    private validateConstraints;
    private rejected;
    private success;
    private snapshot;
    private validateReadSource;
    private unsupported;
}
//# sourceMappingURL=InProcessEventSequence.d.ts.map