kafka-ts 0.0.1-beta → 0.0.1-beta.0

package/dist/connection.js

@@ -1,155 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-};
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-var __metadata = (this && this.__metadata) || function (k, v) {
-    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Connection = void 0;
-const assert_1 = __importDefault(require("assert"));
-const net_1 = __importStar(require("net"));
-const tls_1 = __importDefault(require("tls"));
-const api_1 = require("./api");
-const decoder_1 = require("./utils/decoder");
-const encoder_1 = require("./utils/encoder");
-const error_1 = require("./utils/error");
-const tracer_1 = require("./utils/tracer");
-class Connection {
-    options;
-    socket = new net_1.Socket();
-    queue = {};
-    lastCorrelationId = 0;
-    buffer = null;
-    constructor(options) {
-        this.options = options;
-    }
-    async connect() {
-        this.queue = {};
-        this.buffer = null;
-        await new Promise((resolve, reject) => {
-            const { ssl, connection } = this.options;
-            this.socket = ssl
-                ? tls_1.default.connect({
-                    ...connection,
-                    ...ssl,
-                    ...(connection.host && !(0, net_1.isIP)(connection.host) && { servername: connection.host }),
-                }, resolve)
-                : net_1.default.connect(connection, resolve);
-            this.socket.once("error", reject);
-        });
-        this.socket.removeAllListeners("error");
-        this.socket.on("data", (data) => this.handleData(data));
-        this.socket.once("close", async () => {
-            Object.values(this.queue).forEach(({ reject }) => {
-                reject(new error_1.ConnectionError("Socket closed unexpectedly"));
-            });
-            this.queue = {};
-        });
-    }
-    disconnect() {
-        this.socket.removeAllListeners();
-        return new Promise((resolve) => {
-            if (this.socket.pending) {
-                return resolve();
-            }
-            this.socket.end(resolve);
-        });
-    }
-    async sendRequest(api, body) {
-        const correlationId = this.nextCorrelationId();
-        const encoder = new encoder_1.Encoder()
-            .writeInt16(api.apiKey)
-            .writeInt16(api.apiVersion)
-            .writeInt32(correlationId)
-            .writeString(this.options.clientId);
-        const request = api.request(encoder, body).value();
-        const requestEncoder = new encoder_1.Encoder().writeInt32(request.length).write(request);
-        const { responseDecoder, responseSize } = await new Promise(async (resolve, reject) => {
-            try {
-                await this.write(requestEncoder.value());
-                this.queue[correlationId] = { resolve, reject };
-            }
-            catch (error) {
-                reject(error);
-            }
-        });
-        const response = api.response(responseDecoder);
-        (0, assert_1.default)(responseDecoder.getOffset() - 4 === responseSize, `Buffer not correctly consumed: ${responseDecoder.getOffset() - 4} !== ${responseSize}`);
-        return response;
-    }
-    write(buffer) {
-        return new Promise((resolve, reject) => {
-            const { stack } = new Error("Write error");
-            this.socket.write(buffer, (error) => {
-                if (error) {
-                    const err = new error_1.ConnectionError(error.message);
-                    err.stack += `\n${stack}`;
-                    return reject(err);
-                }
-                resolve();
-            });
-        });
-    }
-    handleData(buffer) {
-        this.buffer = this.buffer ? Buffer.concat([this.buffer, buffer]) : buffer;
-        if (this.buffer.length < 4) {
-            return;
-        }
-        const decoder = new decoder_1.Decoder(this.buffer);
-        const size = decoder.readInt32();
-        if (size !== decoder.getBufferLength() - 4) {
-            return;
-        }
-        const correlationId = decoder.readInt32();
-        const { resolve } = this.queue[correlationId];
-        delete this.queue[correlationId];
-        resolve({ responseDecoder: decoder, responseSize: size });
-        this.buffer = null;
-    }
-    nextCorrelationId() {
-        return (this.lastCorrelationId = (this.lastCorrelationId + 1) % 2 ** 31);
-    }
-}
-exports.Connection = Connection;
-__decorate([
-    (0, tracer_1.trace)(),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", []),
-    __metadata("design:returntype", Promise)
-], Connection.prototype, "connect", null);
-__decorate([
-    (0, tracer_1.trace)((api, body) => ({ apiName: (0, api_1.getApiName)(api), body })),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [Object, Request]),
-    __metadata("design:returntype", Promise)
-], Connection.prototype, "sendRequest", null);

package/dist/consumer/consumer-group.d.ts

@@ -1,36 +0,0 @@
-import { Cluster } from "../cluster";
-import { ConsumerMetadata } from "./consumer-metadata";
-import { OffsetManager } from "./offset-manager";
-type ConsumerGroupOptions = {
-    cluster: Cluster;
-    topics: string[];
-    groupId: string;
-    groupInstanceId: string | null;
-    sessionTimeoutMs: number;
-    rebalanceTimeoutMs: number;
-    metadata: ConsumerMetadata;
-    offsetManager: OffsetManager;
-};
-export declare class ConsumerGroup {
-    private options;
-    private coordinatorId;
-    private memberId;
-    private generationId;
-    private leaderId;
-    private memberIds;
-    private heartbeatInterval;
-    private heartbeatError;
-    constructor(options: ConsumerGroupOptions);
-    join(): Promise<void>;
-    private startHeartbeater;
-    private stopHeartbeater;
-    handleLastHeartbeat(): Promise<void>;
-    private findCoordinator;
-    private joinGroup;
-    private syncGroup;
-    private offsetFetch;
-    offsetCommit(): Promise<void>;
-    heartbeat(): Promise<void>;
-    leaveGroup(): Promise<void>;
-}
-export {};

package/dist/consumer/consumer-group.js

@@ -1,182 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ConsumerGroup = void 0;
-const api_1 = require("../api");
-const find_coordinator_1 = require("../api/find-coordinator");
-class ConsumerGroup {
-    options;
-    coordinatorId = -1;
-    memberId = "";
-    generationId = -1;
-    leaderId = "";
-    memberIds = [];
-    heartbeatInterval = null;
-    heartbeatError = null;
-    constructor(options) {
-        this.options = options;
-    }
-    async join() {
-        await this.findCoordinator();
-        await this.joinGroup();
-        await this.syncGroup();
-        await this.offsetFetch();
-        this.startHeartbeater();
-    }
-    async startHeartbeater() {
-        this.heartbeatInterval = setInterval(async () => {
-            try {
-                await this.heartbeat();
-            }
-            catch (error) {
-                this.heartbeatError = error;
-            }
-        }, 5000);
-    }
-    async stopHeartbeater() {
-        if (this.heartbeatInterval) {
-            clearInterval(this.heartbeatInterval);
-            this.heartbeatInterval = null;
-        }
-    }
-    async handleLastHeartbeat() {
-        if (this.heartbeatError) {
-            throw this.heartbeatError;
-        }
-    }
-    async findCoordinator() {
-        const { coordinators } = await this.options.cluster.sendRequest(api_1.API.FIND_COORDINATOR, {
-            keyType: find_coordinator_1.KEY_TYPE.GROUP,
-            keys: [this.options.groupId],
-        });
-        this.coordinatorId = coordinators[0].nodeId;
-    }
-    async joinGroup() {
-        const { cluster, groupId, groupInstanceId, sessionTimeoutMs, rebalanceTimeoutMs, topics } = this.options;
-        try {
-            const response = await cluster.sendRequestToNode(this.coordinatorId)(api_1.API.JOIN_GROUP, {
-                groupId,
-                groupInstanceId,
-                memberId: this.memberId,
-                sessionTimeoutMs,
-                rebalanceTimeoutMs,
-                protocolType: "consumer",
-                protocols: [{ name: "RoundRobinAssigner", metadata: { version: 0, topics } }],
-                reason: null,
-            });
-            this.memberId = response.memberId;
-            this.generationId = response.generationId;
-            this.leaderId = response.leader;
-            this.memberIds = response.members.map((member) => member.memberId);
-        }
-        catch (error) {
-            if (error.errorCode === api_1.API_ERROR.MEMBER_ID_REQUIRED) {
-                this.memberId = error.response.memberId;
-                return this.joinGroup();
-            }
-            throw error;
-        }
-    }
-    async syncGroup() {
-        const { cluster, metadata, groupId, groupInstanceId } = this.options;
-        let assignments = [];
-        if (this.memberId === this.leaderId) {
-            const memberAssignments = Object.entries(metadata.getTopicPartitions())
-                .flatMap(([topic, partitions]) => partitions.map((partition) => ({ topic, partition })))
-                .reduce((acc, { topic, partition }, index) => {
-                const memberId = this.memberIds[index % this.memberIds.length];
-                acc[memberId] ??= {};
-                acc[memberId][topic] ??= [];
-                acc[memberId][topic].push(partition);
-                return acc;
-            }, {});
-            assignments = Object.entries(memberAssignments).map(([memberId, assignment]) => ({ memberId, assignment }));
-        }
-        const response = await cluster.sendRequestToNode(this.coordinatorId)(api_1.API.SYNC_GROUP, {
-            groupId,
-            groupInstanceId,
-            memberId: this.memberId,
-            generationId: this.generationId,
-            protocolType: "consumer",
-            protocolName: "RoundRobinAssigner",
-            assignments,
-        });
-        metadata.setAssignment(JSON.parse(response.assignments || "{}"));
-    }
-    async offsetFetch() {
-        const { cluster, groupId, topics, metadata, offsetManager } = this.options;
-        const assignment = metadata.getAssignment();
-        const request = {
-            groups: [
-                {
-                    groupId,
-                    memberId: this.memberId,
-                    memberEpoch: -1,
-                    topics: topics
-                        .map((topic) => ({ name: topic, partitionIndexes: assignment[topic] ?? [] }))
-                        .filter(({ partitionIndexes }) => partitionIndexes.length),
-                },
-            ].filter(({ topics }) => topics.length),
-            requireStable: true,
-        };
-        if (!request.groups.length)
-            return;
-        const response = await cluster.sendRequestToNode(this.coordinatorId)(api_1.API.OFFSET_FETCH, request);
-        response.groups.forEach((group) => {
-            group.topics.forEach((topic) => {
-                topic.partitions
-                    .filter(({ committedOffset }) => committedOffset >= 0)
-                    .forEach(({ partitionIndex, committedOffset }) => offsetManager.resolve(topic.name, partitionIndex, committedOffset));
-            });
-        });
-        offsetManager.flush();
-    }
-    async offsetCommit() {
-        const { cluster, groupId, groupInstanceId, offsetManager } = this.options;
-        const request = {
-            groupId,
-            groupInstanceId,
-            memberId: this.memberId,
-            generationIdOrMemberEpoch: this.generationId,
-            topics: Object.entries(offsetManager.pendingOffsets).map(([topic, partitions]) => ({
-                name: topic,
-                partitions: Object.entries(partitions).map(([partition, offset]) => ({
-                    partitionIndex: parseInt(partition),
-                    committedOffset: offset,
-                    committedLeaderEpoch: -1,
-                    committedMetadata: null,
-                })),
-            })),
-        };
-        if (!request.topics.length) {
-            return;
-        }
-        await cluster.sendRequestToNode(this.coordinatorId)(api_1.API.OFFSET_COMMIT, request);
-        offsetManager.flush();
-    }
-    async heartbeat() {
-        const { cluster, groupId, groupInstanceId } = this.options;
-        await cluster.sendRequestToNode(this.coordinatorId)(api_1.API.HEARTBEAT, {
-            groupId,
-            groupInstanceId,
-            memberId: this.memberId,
-            generationId: this.generationId,
-        });
-    }
-    async leaveGroup() {
-        const { cluster, groupId, groupInstanceId } = this.options;
-        this.stopHeartbeater();
-        try {
-            await cluster.sendRequestToNode(this.coordinatorId)(api_1.API.LEAVE_GROUP, {
-                groupId,
-                members: [{ memberId: this.memberId, groupInstanceId, reason: null }],
-            });
-        }
-        catch (error) {
-            if (error.errorCode === api_1.API_ERROR.FENCED_INSTANCE_ID) {
-                return;
-            }
-            throw error;
-        }
-    }
-}
-exports.ConsumerGroup = ConsumerGroup;

package/dist/consumer/consumer-metadata.d.ts

@@ -1,7 +0,0 @@
-import { Assignment } from "../api/sync-group";
-import { Metadata } from "../metadata";
-export declare class ConsumerMetadata extends Metadata {
-    private assignment;
-    getAssignment(): Assignment;
-    setAssignment(newAssignment: Assignment): void;
-}

package/dist/consumer/consumer-metadata.js

@@ -1,14 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ConsumerMetadata = void 0;
-const metadata_1 = require("../metadata");
-class ConsumerMetadata extends metadata_1.Metadata {
-    assignment = {};
-    getAssignment() {
-        return this.assignment;
-    }
-    setAssignment(newAssignment) {
-        this.assignment = newAssignment;
-    }
-}
-exports.ConsumerMetadata = ConsumerMetadata;

package/dist/consumer/consumer.d.ts

@@ -1,37 +0,0 @@
-import { IsolationLevel } from "../api/fetch";
-import { Cluster } from "../cluster";
-import { Message } from "../types";
-import { Retrier } from "../utils/retrier";
-export type ConsumerOptions = {
-    topics: string[];
-    groupId?: string | null;
-    groupInstanceId?: string | null;
-    rackId?: string;
-    isolationLevel?: IsolationLevel;
-    sessionTimeoutMs?: number;
-    rebalanceTimeoutMs?: number;
-    maxWaitMs?: number;
-    minBytes?: number;
-    maxBytes?: number;
-    partitionMaxBytes?: number;
-    allowTopicAutoCreation?: boolean;
-    fromBeginning?: boolean;
-    retrier?: Retrier;
-} & ({
-    onMessage: (message: Message) => unknown;
-} | {
-    onBatch: (messages: Message[]) => unknown;
-});
-export declare class Consumer {
-    private cluster;
-    private options;
-    private metadata;
-    private consumerGroup;
-    private offsetManager;
-    private stopHook;
-    constructor(cluster: Cluster, options: ConsumerOptions);
-    start(): Promise<void>;
-    private fetchLoop;
-    close(force?: boolean): Promise<void>;
-    private fetch;
-}

package/dist/consumer/consumer.js

@@ -1,178 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Consumer = void 0;
-const api_1 = require("../api");
-const assignments_to_replicas_1 = require("../distributors/assignments-to-replicas");
-const delay_1 = require("../utils/delay");
-const error_1 = require("../utils/error");
-const retrier_1 = require("../utils/retrier");
-const consumer_group_1 = require("./consumer-group");
-const consumer_metadata_1 = require("./consumer-metadata");
-const offset_manager_1 = require("./offset-manager");
-class Consumer {
-    cluster;
-    options;
-    metadata;
-    consumerGroup;
-    offsetManager;
-    stopHook;
-    constructor(cluster, options) {
-        this.cluster = cluster;
-        this.options = {
-            ...options,
-            groupId: options.groupId ?? null,
-            groupInstanceId: options.groupInstanceId ?? null,
-            rackId: options.rackId ?? "",
-            sessionTimeoutMs: options.sessionTimeoutMs ?? 30_000,
-            rebalanceTimeoutMs: options.rebalanceTimeoutMs ?? 60_000,
-            maxWaitMs: options.maxWaitMs ?? 5000,
-            minBytes: options.minBytes ?? 1,
-            maxBytes: options.maxBytes ?? 1_000_000,
-            partitionMaxBytes: options.partitionMaxBytes ?? 1_000_000,
-            isolationLevel: options.isolationLevel ?? 0 /* IsolationLevel.READ_UNCOMMITTED */,
-            allowTopicAutoCreation: options.allowTopicAutoCreation ?? false,
-            fromBeginning: options.fromBeginning ?? false,
-            retrier: options.retrier ?? retrier_1.defaultRetrier,
-        };
-        this.metadata = new consumer_metadata_1.ConsumerMetadata({ cluster: this.cluster });
-        this.offsetManager = new offset_manager_1.OffsetManager({
-            cluster: this.cluster,
-            metadata: this.metadata,
-            isolationLevel: this.options.isolationLevel,
-        });
-        this.consumerGroup = this.options.groupId
-            ? new consumer_group_1.ConsumerGroup({
-                cluster: this.cluster,
-                topics: this.options.topics,
-                groupId: this.options.groupId,
-                groupInstanceId: this.options.groupInstanceId,
-                sessionTimeoutMs: this.options.sessionTimeoutMs,
-                rebalanceTimeoutMs: this.options.rebalanceTimeoutMs,
-                metadata: this.metadata,
-                offsetManager: this.offsetManager,
-            })
-            : undefined;
-    }
-    async start() {
-        const { topics, allowTopicAutoCreation, fromBeginning } = this.options;
-        this.stopHook = undefined;
-        try {
-            await this.cluster.connect();
-            await this.metadata.fetchMetadataIfNecessary({ topics, allowTopicAutoCreation });
-            this.metadata.setAssignment(this.metadata.getTopicPartitions());
-            await this.offsetManager.fetchOffsets({ fromBeginning });
-            await this.consumerGroup?.join();
-        }
-        catch (error) {
-            console.error(error);
-            console.debug(`Restarting consumer in 1 second...`);
-            await (0, delay_1.delay)(1000);
-            if (this.stopHook)
-                return this.stopHook();
-            return this.close(true).then(() => this.start());
-        }
-        this.fetchLoop();
-    }
-    fetchLoop = async () => {
-        const { options } = this;
-        const { retrier } = options;
-        let nodeAssignments = [];
-        let shouldReassign = true;
-        while (!this.stopHook) {
-            if (shouldReassign || !nodeAssignments) {
-                nodeAssignments = Object.entries((0, assignments_to_replicas_1.distributeAssignmentsToNodes)(this.metadata.getAssignment(), this.metadata.getTopicPartitionReplicaIds())).map(([nodeId, assignment]) => ({ nodeId: parseInt(nodeId), assignment }));
-                shouldReassign = false;
-            }
-            try {
-                for (const { nodeId, assignment } of nodeAssignments) {
-                    const batch = await this.fetch(nodeId, assignment);
-                    const messages = batch.responses.flatMap(({ topicId, partitions }) => partitions.flatMap(({ partitionIndex, records }) => records.flatMap(({ baseTimestamp, baseOffset, records }) => records.map((message) => ({
-                        topic: this.metadata.getTopicNameById(topicId),
-                        partition: partitionIndex,
-                        key: message.key ?? null,
-                        value: message.value ?? null,
-                        headers: Object.fromEntries(message.headers.map(({ key, value }) => [key, value])),
-                        timestamp: baseTimestamp + BigInt(message.timestampDelta),
-                        offset: baseOffset + BigInt(message.offsetDelta),
-                    })))));
-                    if ("onBatch" in options) {
-                        await retrier(() => options.onBatch(messages));
-                        messages.forEach(({ topic, partition, offset }) => this.offsetManager.resolve(topic, partition, offset + 1n));
-                    }
-                    else if ("onMessage" in options) {
-                        for (const message of messages) {
-                            await retrier(() => options.onMessage(message));
-                            const { topic, partition, offset } = message;
-                            this.offsetManager.resolve(topic, partition, offset + 1n);
-                        }
-                    }
-                    await this.consumerGroup?.offsetCommit();
-                    await this.consumerGroup?.handleLastHeartbeat();
-                }
-                if (!nodeAssignments.length) {
-                    console.debug("No partitions assigned. Waiting for reassignment...");
-                    await (0, delay_1.delay)(this.options.maxWaitMs);
-                    await this.consumerGroup?.handleLastHeartbeat();
-                }
-            }
-            catch (error) {
-                if (error.errorCode === api_1.API_ERROR.REBALANCE_IN_PROGRESS) {
-                    console.debug("Rebalance in progress...");
-                    shouldReassign = true;
-                    continue;
-                }
-                if (error.errorCode === api_1.API_ERROR.FENCED_INSTANCE_ID) {
-                    console.debug("New consumer with the same groupInstanceId joined. Exiting the consumer...");
-                    this.close();
-                    break;
-                }
-                if (error instanceof error_1.ConnectionError ||
-                    (error instanceof error_1.KafkaTSApiError && error.errorCode === api_1.API_ERROR.NOT_COORDINATOR)) {
-                    console.debug(`${error.message}. Restarting consumer...`);
-                    this.close().then(() => this.start());
-                    break;
-                }
-                console.error(error);
-                await this.consumerGroup?.offsetCommit();
-                break;
-            }
-        }
-        this.stopHook?.();
-    };
-    async close(force = false) {
-        if (!force) {
-            await new Promise((resolve) => {
-                this.stopHook = resolve;
-            });
-        }
-        await this.consumerGroup
-            ?.leaveGroup()
-            .catch((error) => console.warn(`Failed to leave group: ${error.message}`));
-        await this.cluster.disconnect().catch((error) => console.warn(`Failed to disconnect: ${error.message}`));
-    }
-    fetch(nodeId, assignment) {
-        const { rackId, maxWaitMs, minBytes, maxBytes, partitionMaxBytes, isolationLevel } = this.options;
-        return this.cluster.sendRequestToNode(nodeId)(api_1.API.FETCH, {
-            maxWaitMs,
-            minBytes,
-            maxBytes,
-            isolationLevel,
-            sessionId: 0,
-            sessionEpoch: -1,
-            topics: Object.entries(assignment).map(([topic, partitions]) => ({
-                topicId: this.metadata.getTopicIdByName(topic),
-                partitions: partitions.map((partition) => ({
-                    partition,
-                    currentLeaderEpoch: -1,
-                    fetchOffset: this.offsetManager.getCurrentOffset(topic, partition),
-                    lastFetchedEpoch: -1,
-                    logStartOffset: 0n,
-                    partitionMaxBytes,
-                })),
-            })),
-            forgottenTopicsData: [],
-            rackId,
-        });
-    }
-}
-exports.Consumer = Consumer;

package/dist/consumer/metadata.d.ts

@@ -1,24 +0,0 @@
-import { IsolationLevel } from "../api/fetch";
-import { Assignment } from "../api/sync-group";
-import { Cluster } from "../cluster";
-import { OffsetManager } from "./offset-manager";
-export type Metadata = ReturnType<typeof createMetadata>;
-type MetadataOptions = {
-    cluster: Cluster;
-    topics?: string[];
-    isolationLevel?: IsolationLevel;
-    allowTopicAutoCreation?: boolean;
-    fromBeginning?: boolean;
-    offsetManager?: OffsetManager;
-};
-export declare const createMetadata: ({ cluster, topics, isolationLevel, allowTopicAutoCreation, fromBeginning, offsetManager, }: MetadataOptions) => {
-    init: () => Promise<void>;
-    getTopicPartitions: () => Record<string, number[]>;
-    getTopicIdByName: (name: string) => string;
-    getTopicNameById: (id: string) => string;
-    getAssignment: () => Assignment;
-    setAssignment: (newAssignment: Assignment) => void;
-    getLeaderIdByTopicPartition: (topic: string, partition: number) => number;
-    getIsrNodeIdsByTopicPartition: (topic: string, partition: number) => number[];
-};
-export {};