/// <reference types="node" />
import { EventBase } from "./event-base";
export type StartPosition = {
    type: "beginning";
} | {
    type: "latest";
} | {
    type: "timestamp";
    timestamp: number;
} | {
    type: "offset";
    partition: number;
    offset: string;
};
export type SeekTarget = {
    type: "timestamp";
    timestamp: number;
    partition?: number;
} | {
    type: "offset";
    partition: number;
    offset: string;
} | {
    type: "beginning";
    partition?: number;
} | {
    type: "latest";
    partition?: number;
};
export type ConsumptionScenario = "single" | "concurrent" | "batch";
export interface BackpressureOptions {
    maxBytes?: number;
    maxBytesPerPartition?: number;
    minBytes?: number;
    maxWaitTimeMs?: number;
    partitionsConsumedConcurrently?: number;
    maxInFlight?: number;
    memoryGuard?: MemoryGuardOptions;
}
export interface MemoryGuardOptions {
    enabled?: boolean;
    metric?: "rss" | "heapUsed" | "external";
    checkIntervalMs?: number;
    pauseAboveBytes?: number;
    resumeBelowBytes?: number;
    pauseAboveHeapFraction?: number;
    resumeBelowHeapFraction?: number;
    shouldPause?: (usage: NodeJS.MemoryUsage) => boolean;
}
export interface CommitOptions {
    autoCommit?: boolean;
    autoCommitIntervalMs?: number;
    autoCommitThreshold?: number;
}
export interface BatchOptions {
    maxSize?: number;
    maxWaitMs?: number;
}
export interface MessageControls {
    ack(): Promise<void>;
    nack(requeue?: boolean): Promise<void>;
    heartbeat(): Promise<void>;
    pause(): void;
    resume(): void;
}
export interface BatchContext<MessageType, HeadersType = Record<string, unknown>> {
    events: EventBase<MessageType, HeadersType>[];
    resolve(event: EventBase<MessageType, HeadersType>): void;
    commit(): Promise<void>;
    heartbeat(): Promise<void>;
    isRunning(): boolean;
    isStale(): boolean;
    pause(): () => void;
}
export type SingleMessageHandler<MessageType, HeadersType = Record<string, unknown>> = (event: EventBase<MessageType, HeadersType>, controls: MessageControls) => Promise<void>;
export type BatchMessageHandler<MessageType, HeadersType = Record<string, unknown>> = (context: BatchContext<MessageType, HeadersType>) => Promise<void>;
export interface ConsumerCallbacks<MessageType, HeadersType = Record<string, unknown>> {
    onError?: (error: Error, event?: EventBase<MessageType, HeadersType>) => void;
    onRebalance?: (info: {
        assigned?: unknown;
        revoked?: unknown;
    }) => void;
    onPause?: (reason: "backpressure" | "memory" | "manual") => void;
    onResume?: (reason: "backpressure" | "memory" | "manual") => void;
}
export interface BaseConsumerOptions<MessageType, HeadersType = Record<string, unknown>> {
    groupId?: string;
    startFrom?: StartPosition;
    backpressure?: BackpressureOptions;
    commit?: CommitOptions;
    callbacks?: ConsumerCallbacks<MessageType, HeadersType>;
}
export interface SingleConsumerOptions<MessageType, HeadersType = Record<string, unknown>> extends BaseConsumerOptions<MessageType, HeadersType> {
    scenario?: "single";
    handler: SingleMessageHandler<MessageType, HeadersType>;
}
export interface ConcurrentConsumerOptions<MessageType, HeadersType = Record<string, unknown>> extends BaseConsumerOptions<MessageType, HeadersType> {
    scenario: "concurrent";
    concurrency: number;
    handler: SingleMessageHandler<MessageType, HeadersType>;
}
export interface BatchConsumerOptions<MessageType, HeadersType = Record<string, unknown>> extends BaseConsumerOptions<MessageType, HeadersType> {
    scenario: "batch";
    batch?: BatchOptions;
    handler: BatchMessageHandler<MessageType, HeadersType>;
}
export type ConsumerOptions<MessageType, HeadersType = Record<string, unknown>> = SingleConsumerOptions<MessageType, HeadersType> | ConcurrentConsumerOptions<MessageType, HeadersType> | BatchConsumerOptions<MessageType, HeadersType>;
export interface PartitionLag {
    topic: string;
    partition: number;
    lag: number;
    committedOffset?: string;
    logEndOffset?: string;
}
export interface ConsumerMetrics {
    topic?: string;
    groupId?: string;
    inFlight: number;
    processed: number;
    failed: number;
    retried: number;
    lastCommittedAt?: number;
    throughputPerSec?: number;
    lag?: PartitionLag[];
    totalLag?: number;
}
export interface GracefulShutdownOptions {
    timeoutMs?: number;
    commitOnShutdown?: boolean;
    onDraining?: () => void;
    onTimeout?: (inFlight: number) => void;
}