kafka-ts 0.0.1-beta

package/dist/connection.js

@@ -0,0 +1,155 @@
+"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

@@ -0,0 +1,36 @@
+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

@@ -0,0 +1,182 @@
+"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

@@ -0,0 +1,7 @@
+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

@@ -0,0 +1,14 @@
+"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

@@ -0,0 +1,37 @@
+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

@@ -0,0 +1,178 @@
+"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

@@ -0,0 +1,24 @@
+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 {};