import { AuditEntry, AuditScanOptions } from '../interfaces/audit-entry.interface';
import { AuditService } from '../services/audit.service';
export interface AuditStreamState {
    checkpoint: string | null;
    highWatermark: string | null;
}
export interface AuditStreamCheckpointStore {
    load(streamId: string): Promise<AuditStreamState | null>;
    save(streamId: string, state: AuditStreamState): Promise<void>;
}
export interface AuditStreamBatchContext {
    streamId: string;
    batchId: string;
    checkpoint: string;
    highWatermark: string;
    attempt: number;
}
export interface AuditStreamSink {
    deliver(entries: readonly AuditEntry[], context: AuditStreamBatchContext): Promise<void>;
}
export interface AuditStreamDeadLetter {
    streamId: string;
    batchId: string;
    checkpoint: string;
    highWatermark: string;
    entries: readonly AuditEntry[];
    error: AuditStreamDeliveryError;
}
export interface AuditStreamDeadLetterStore {
    write(deadLetter: AuditStreamDeadLetter): Promise<void>;
}
export type AuditStreamMetric = {
    name: 'batch_delivered';
    streamId: string;
    entries: number;
    attempt: number;
} | {
    name: 'batch_retried';
    streamId: string;
    entries: number;
    attempt: number;
    delayMs: number;
} | {
    name: 'batch_dead_lettered';
    streamId: string;
    entries: number;
} | {
    name: 'run_failed';
    streamId: string;
};
export interface AuditStreamErrorContext {
    phase: 'delivery';
    streamId: string;
    batchId: string;
    attempt: number;
    terminal: boolean;
}
export interface AuditStreamRunnerOptions {
    streamId: string;
    scan: Omit<AuditScanOptions, 'after' | 'until' | 'signal'>;
    sink: AuditStreamSink;
    checkpointStore: AuditStreamCheckpointStore;
    deadLetterStore?: AuditStreamDeadLetterStore;
    maxRetries?: number;
    initialBackoffMs?: number;
    maxBackoffMs?: number;
    redact?: (entry: Readonly<AuditEntry>) => AuditEntry;
    onMetric?: (metric: AuditStreamMetric) => void;
    onError?: (error: unknown, context: AuditStreamErrorContext) => void;
    sleep?: (delayMs: number, signal?: AbortSignal) => Promise<void>;
}
export interface AuditStreamRunResult {
    status: 'idle' | 'delivered';
    deliveredEntries: number;
    deadLetteredEntries: number;
    batches: number;
    checkpoint: string | null;
}
export declare class AuditStreamDeliveryError extends Error {
    readonly terminal: boolean;
    readonly status?: number;
    readonly retryAfterMs?: number;
    constructor(message: string, options: {
        terminal: boolean;
        status?: number;
        retryAfterMs?: number;
        cause?: unknown;
    });
}
export declare class AuditStreamRunner {
    private readonly auditService;
    private readonly options;
    constructor(auditService: Pick<AuditService, 'scan'>, options: AuditStreamRunnerOptions);
    runOnce(input?: {
        signal?: AbortSignal;
    }): Promise<AuditStreamRunResult>;
    private deliver;
    private redactEntry;
    private batchId;
    private normalizeDeliveryError;
    private backoffDelay;
    private emitMetric;
    private emitError;
    private validateOptions;
    private throwIfAborted;
}
//# sourceMappingURL=audit-stream.d.ts.map