import { type FetchRequestTopic } from '../../apis/consumer/fetch-v17.ts';
import { type GroupProtocols } from '../../apis/enumerations.ts';
import { type ConnectionPool } from '../../network/connection-pool.ts';
import { type KafkaRecord, type Message } from '../../protocol/records.ts';
import { type SchemaRegistry } from '../../registries/abstract.ts';
import { type BaseOptions, type ClusterMetadata, type TopicWithPartitionAndOffset } from '../base/types.ts';
import { type BeforeDeserializationHook, type Deserializers } from '../serde.ts';
export interface GroupProtocolSubscription {
    name: string;
    version: number;
    metadata?: Buffer | string;
}
export interface GroupAssignment {
    topic: string;
    partitions: number[];
}
export interface GroupPartitionsAssignments {
    memberId: string;
    assignments: Map<string, GroupAssignment>;
}
export interface ExtendedGroupProtocolSubscription extends Omit<GroupProtocolSubscription, 'name'> {
    topics?: string[];
    memberId: string;
}
export type Offsets = Map<string, bigint[]>;
export type OffsetsWithTimestamps = Map<string, Map<number, {
    offset: bigint;
    timestamp: bigint;
}>>;
export type CorruptedMessageHandler = (record: KafkaRecord, topic: string, partition: number, firstTimestamp: bigint, firstOffset: bigint, commit: Message['commit']) => boolean;
export type GroupPartitionsAssigner = (current: string, members: Map<string, ExtendedGroupProtocolSubscription>, topics: Set<string>, metadata: ClusterMetadata) => GroupPartitionsAssignments[];
export declare const MessagesStreamModes: {
    readonly LATEST: "latest";
    readonly EARLIEST: "earliest";
    readonly COMMITTED: "committed";
    readonly MANUAL: "manual";
};
export declare const allowedMessagesStreamModes: MessagesStreamModeValue[];
export type MessagesStreamMode = keyof typeof MessagesStreamModes;
export type MessagesStreamModeValue = (typeof MessagesStreamModes)[keyof typeof MessagesStreamModes];
export declare const MessagesStreamFallbackModes: {
    readonly LATEST: "latest";
    readonly EARLIEST: "earliest";
    readonly FAIL: "fail";
};
export declare const allowedMessagesStreamFallbackModes: MessagesStreamFallbackModeValue[];
export type MessagesStreamFallbackMode = keyof typeof MessagesStreamFallbackModes;
export type MessagesStreamFallbackModeValue = (typeof MessagesStreamFallbackModes)[keyof typeof MessagesStreamFallbackModes];
export interface GroupOptions {
    groupProtocol?: typeof GroupProtocols.CLASSIC;
    groupInstanceId?: string;
    sessionTimeout?: number;
    rebalanceTimeout?: number;
    heartbeatInterval?: number;
    protocols?: GroupProtocolSubscription[];
    partitionAssigner?: GroupPartitionsAssigner;
}
export interface ConsumerGroupOptions {
    groupProtocol: typeof GroupProtocols.CONSUMER;
    groupInstanceId?: string;
    groupRemoteAssignor?: string;
    rebalanceTimeout?: number;
}
export interface ConsumeBaseOptions<Key, Value, HeaderKey, HeaderValue> {
    autocommit?: boolean | number;
    minBytes?: number;
    maxBytes?: number;
    maxWaitTime?: number;
    isolationLevel?: number;
    deserializers?: Partial<Deserializers<Key, Value, HeaderKey, HeaderValue>>;
    highWaterMark?: number;
    beforeDeserialization?: BeforeDeserializationHook;
    registry?: SchemaRegistry<unknown, unknown, Key, Value, HeaderKey, HeaderValue>;
}
export interface StreamOptions {
    topics: string[];
    context?: unknown;
    mode?: MessagesStreamModeValue;
    fallbackMode?: MessagesStreamFallbackModeValue;
    maxFetches?: number;
    offsets?: TopicWithPartitionAndOffset[];
    onCorruptedMessage?: CorruptedMessageHandler;
}
export type ConsumeOptions<Key, Value, HeaderKey, HeaderValue> = StreamOptions & ConsumeBaseOptions<Key, Value, HeaderKey, HeaderValue> & GroupOptions;
export type ConsumerOptions<Key, Value, HeaderKey, HeaderValue> = BaseOptions & {
    groupId: string;
    context?: unknown;
    streamContext?: unknown;
} & (GroupOptions | ConsumerGroupOptions) & ConsumeBaseOptions<Key, Value, HeaderKey, HeaderValue>;
export type FetchOptions<Key, Value, HeaderKey, HeaderValue> = Pick<ConsumeBaseOptions<Key, Value, HeaderKey, HeaderValue>, 'minBytes' | 'maxBytes' | 'maxWaitTime' | 'isolationLevel'> & {
    node: number;
    topics: FetchRequestTopic[];
    connectionPool?: ConnectionPool;
};
export interface CommitOptionsPartition extends TopicWithPartitionAndOffset {
    leaderEpoch: number;
}
export interface CommitOptions {
    offsets: CommitOptionsPartition[];
}
export interface ListCommitsOptions {
    topics: GroupAssignment[];
}
export interface ListOffsetsOptions {
    topics: string[];
    partitions?: Record<string, number[]>;
    timestamp?: bigint;
    isolationLevel?: number;
}
export type GetLagOptions = Omit<ListOffsetsOptions, 'timestamp' | 'isolationLevel'>;
export interface ConsumerGroupJoinPayload {
    groupId: string;
    memberId: string;
    generationId?: number;
    isLeader?: boolean;
    assignments?: GroupAssignment[];
}
export interface ConsumerGroupLeavePayload {
    groupId: string;
    memberId: string | null;
    generationId?: number;
}
export interface ConsumerGroupRebalancePayload {
    groupId: string;
}
export interface ConsumerHeartbeatPayload {
    groupId?: string;
    memberId?: string | null;
    generationId?: number;
}
export interface ConsumerHeartbeatErrorPayload extends ConsumerHeartbeatPayload {
    error: Error;
}