import { ChronicleConnection } from '../connection/index.js';
import { Constructor } from '@cratis/fundamentals';
import type { AppendedEvent } from '../events/AppendedEvent.js';
import { AppendedEventWithResult } from './AppendedEventWithResult.js';
import { AppendOperationsBroadcaster } from './AppendOperationsBroadcaster.js';
import { AppendOptions } from './AppendOptions.js';
import { AppendResult } from './AppendResult.js';
import { CompleteStreamResult } from './CompleteStreamResult.js';
import { ConstraintViolation } from './ConstraintViolation.js';
import { EventForEventSourceId } from './EventForEventSourceId.js';
import { IEventSequence } from './IEventSequence.js';
import { ITransactionalEventSequence } from './ITransactionalEventSequence.js';
import { EventSequenceId } from './EventSequenceId.js';
import { EventSequenceNumber } from './EventSequenceNumber.js';
import type { ChronicleTelemetryOptions } from '../telemetry/ChronicleTelemetryOptions.js';
import type { IEventSources } from '../eventSources/IEventSources.js';
import { IUnitOfWorkManager } from '../transactions/IUnitOfWorkManager.js';
/**
 * Implements {@link IEventSequence} by communicating with the Chronicle Kernel
 * via gRPC using the {@link ChronicleConnection}.
 */
export declare class EventSequence implements IEventSequence {
    readonly id: EventSequenceId;
    private readonly _eventStoreName;
    private readonly _namespace;
    private readonly _connection;
    private readonly _unitOfWorkManager;
    private readonly _resolveConstraintMessage?;
    private readonly _telemetry?;
    private readonly _eventSources?;
    readonly transactional: ITransactionalEventSequence;
    readonly appendOperations: AppendOperationsBroadcaster<AppendedEventWithResult[]>;
    constructor(id: EventSequenceId, _eventStoreName: string, _namespace: string, _connection: ChronicleConnection, _unitOfWorkManager: IUnitOfWorkManager, _resolveConstraintMessage?: ((violation: ConstraintViolation) => ConstraintViolation) | undefined, _telemetry?: ChronicleTelemetryOptions | undefined, _eventSources?: IEventSources | undefined);
    /** @inheritdoc */
    append(eventSourceId: string, event: object, options?: AppendOptions): Promise<AppendResult>;
    private get sequenceMetricAttributes();
    private sendAppend;
    private toAppendRouteFields;
    private createAppendRequest;
    private recordAppendMetrics;
    /** @inheritdoc */
    appendMany(eventSourceId: string, events: object[], options?: AppendOptions): Promise<AppendResult[]>;
    appendMany(events: EventForEventSourceId[], options?: AppendOptions): Promise<AppendResult[]>;
    private applyBatchRouting;
    private sendAppendMany;
    private toAppendManyResults;
    private recordAppendManyMetrics;
    private publishAppendMany;
    /** @inheritdoc */
    getNextSequenceNumber(): Promise<EventSequenceNumber>;
    /** @inheritdoc */
    getTailSequenceNumber(eventSourceId?: string, eventSourceType?: string, eventStreamType?: string, eventStreamId?: string, filterEventTypes?: Constructor[]): Promise<EventSequenceNumber>;
    /** @inheritdoc */
    getTailSequenceNumberForObserver(observerType: Constructor): Promise<EventSequenceNumber>;
    /** @inheritdoc */
    hasEventsFor(eventSourceId: string): Promise<boolean>;
    /** @inheritdoc */
    getForEventSourceIdAndEventTypes(eventSourceId: string, eventTypes: Constructor[], eventStreamType?: string, eventStreamId?: string, eventSourceType?: string): Promise<AppendedEvent[]>;
    /** @inheritdoc */
    getFromSequenceNumber(sequenceNumber: EventSequenceNumber, eventSourceId?: string, filterEventTypes?: Constructor[]): Promise<AppendedEvent[]>;
    /** @inheritdoc */
    redact(sequenceNumber: EventSequenceNumber, reason: string): Promise<void>;
    /** @inheritdoc */
    redactForEventSource(eventSourceId: string, reason: string, eventTypes?: Constructor[]): Promise<void>;
    private sendRedaction;
    /**
     * Resolves which registered event type classes a given observer (reactor/reducer) type handles,
     * using the same naming convention the observation runtimes use to dispatch events to handler
     * methods: an event type named `SomethingHappened` dispatches to a method named `somethingHappened`.
     */
    private getEventTypesHandledBy;
    /** @inheritdoc */
    completeStream(eventStreamType: string, eventStreamId: string): Promise<CompleteStreamResult>;
    private setSequenceAttributes;
    private toClientCompleteStreamError;
    private joinEventTypeIds;
    private toClientAppendedEvent;
    private mapAppendResponse;
    /**
     * Waits for all observers affected by an append to either process up to the given tail sequence
     * number or fail. Backs {@link AppendResult.waitForCompletion}.
     */
    private waitForObserverCompletion;
    private resolveWaitOptions;
    private readonly tailReader;
    private toContractConcurrencyScope;
}
//# sourceMappingURL=EventSequence.d.ts.map