kafka-ts 0.0.1-beta

package/dist/api/index.js

@@ -0,0 +1,164 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.API_ERROR = exports.getApiName = exports.API = void 0;
+const api_versions_1 = require("./api-versions");
+const create_topics_1 = require("./create-topics");
+const delete_topics_1 = require("./delete-topics");
+const fetch_1 = require("./fetch");
+const find_coordinator_1 = require("./find-coordinator");
+const heartbeat_1 = require("./heartbeat");
+const init_producer_id_1 = require("./init-producer-id");
+const join_group_1 = require("./join-group");
+const leave_group_1 = require("./leave-group");
+const list_offsets_1 = require("./list-offsets");
+const metadata_1 = require("./metadata");
+const offset_commit_1 = require("./offset-commit");
+const offset_fetch_1 = require("./offset-fetch");
+const produce_1 = require("./produce");
+const sasl_authenticate_1 = require("./sasl-authenticate");
+const sasl_handshake_1 = require("./sasl-handshake");
+const sync_group_1 = require("./sync-group");
+exports.API = {
+    API_VERSIONS: api_versions_1.API_VERSIONS,
+    CREATE_TOPICS: create_topics_1.CREATE_TOPICS,
+    DELETE_TOPICS: delete_topics_1.DELETE_TOPICS,
+    FETCH: fetch_1.FETCH,
+    FIND_COORDINATOR: find_coordinator_1.FIND_COORDINATOR,
+    HEARTBEAT: heartbeat_1.HEARTBEAT,
+    INIT_PRODUCER_ID: init_producer_id_1.INIT_PRODUCER_ID,
+    JOIN_GROUP: join_group_1.JOIN_GROUP,
+    LEAVE_GROUP: leave_group_1.LEAVE_GROUP,
+    LIST_OFFSETS: list_offsets_1.LIST_OFFSETS,
+    METADATA: metadata_1.METADATA,
+    OFFSET_COMMIT: offset_commit_1.OFFSET_COMMIT,
+    OFFSET_FETCH: offset_fetch_1.OFFSET_FETCH,
+    PRODUCE: produce_1.PRODUCE,
+    SASL_AUTHENTICATE: sasl_authenticate_1.SASL_AUTHENTICATE,
+    SASL_HANDSHAKE: sasl_handshake_1.SASL_HANDSHAKE,
+    SYNC_GROUP: sync_group_1.SYNC_GROUP,
+};
+const getApiName = (api) => Object.entries(exports.API).find(([, v]) => v === api)?.[0];
+exports.getApiName = getApiName;
+exports.API_ERROR = {
+    UNKNOWN_SERVER_ERROR: -1,
+    OFFSET_OUT_OF_RANGE: 1,
+    CORRUPT_MESSAGE: 2,
+    UNKNOWN_TOPIC_OR_PARTITION: 3,
+    INVALID_FETCH_SIZE: 4,
+    LEADER_NOT_AVAILABLE: 5,
+    NOT_LEADER_OR_FOLLOWER: 6,
+    REQUEST_TIMED_OUT: 7,
+    BROKER_NOT_AVAILABLE: 8,
+    REPLICA_NOT_AVAILABLE: 9,
+    MESSAGE_TOO_LARGE: 10,
+    STALE_CONTROLLER_EPOCH: 11,
+    OFFSET_METADATA_TOO_LARGE: 12,
+    NETWORK_EXCEPTION: 13,
+    COORDINATOR_LOAD_IN_PROGRESS: 14,
+    COORDINATOR_NOT_AVAILABLE: 15,
+    NOT_COORDINATOR: 16,
+    INVALID_TOPIC_EXCEPTION: 17,
+    RECORD_LIST_TOO_LARGE: 18,
+    NOT_ENOUGH_REPLICAS: 19,
+    NOT_ENOUGH_REPLICAS_AFTER_APPEND: 20,
+    INVALID_REQUIRED_ACKS: 21,
+    ILLEGAL_GENERATION: 22,
+    INCONSISTENT_GROUP_PROTOCOL: 23,
+    INVALID_GROUP_ID: 24,
+    UNKNOWN_MEMBER_ID: 25,
+    INVALID_SESSION_TIMEOUT: 26,
+    REBALANCE_IN_PROGRESS: 27,
+    INVALID_COMMIT_OFFSET_SIZE: 28,
+    TOPIC_AUTHORIZATION_FAILED: 29,
+    GROUP_AUTHORIZATION_FAILED: 30,
+    CLUSTER_AUTHORIZATION_FAILED: 31,
+    INVALID_TIMESTAMP: 32,
+    UNSUPPORTED_SASL_MECHANISM: 33,
+    ILLEGAL_SASL_STATE: 34,
+    UNSUPPORTED_VERSION: 35,
+    TOPIC_ALREADY_EXISTS: 36,
+    INVALID_PARTITIONS: 37,
+    INVALID_REPLICATION_FACTOR: 38,
+    INVALID_REPLICA_ASSIGNMENT: 39,
+    INVALID_CONFIG: 40,
+    NOT_CONTROLLER: 41,
+    INVALID_REQUEST: 42,
+    UNSUPPORTED_FOR_MESSAGE_FORMAT: 43,
+    POLICY_VIOLATION: 44,
+    OUT_OF_ORDER_SEQUENCE_NUMBER: 45,
+    DUPLICATE_SEQUENCE_NUMBER: 46,
+    INVALID_PRODUCER_EPOCH: 47,
+    INVALID_TXN_STATE: 48,
+    INVALID_PRODUCER_ID_MAPPING: 49,
+    INVALID_TRANSACTION_TIMEOUT: 50,
+    CONCURRENT_TRANSACTIONS: 51,
+    TRANSACTION_COORDINATOR_FENCED: 52,
+    TRANSACTIONAL_ID_AUTHORIZATION_FAILED: 53,
+    SECURITY_DISABLED: 54,
+    OPERATION_NOT_ATTEMPTED: 55,
+    KAFKA_STORAGE_ERROR: 56,
+    LOG_DIR_NOT_FOUND: 57,
+    SASL_AUTHENTICATION_FAILED: 58,
+    UNKNOWN_PRODUCER_ID: 59,
+    REASSIGNMENT_IN_PROGRESS: 60,
+    DELEGATION_TOKEN_AUTH_DISABLED: 61,
+    DELEGATION_TOKEN_NOT_FOUND: 62,
+    DELEGATION_TOKEN_OWNER_MISMATCH: 63,
+    DELEGATION_TOKEN_REQUEST_NOT_ALLOWED: 64,
+    DELEGATION_TOKEN_AUTHORIZATION_FAILED: 65,
+    DELEGATION_TOKEN_EXPIRED: 66,
+    INVALID_PRINCIPAL_TYPE: 67,
+    NON_EMPTY_GROUP: 68,
+    GROUP_ID_NOT_FOUND: 69,
+    FETCH_SESSION_ID_NOT_FOUND: 70,
+    INVALID_FETCH_SESSION_EPOCH: 71,
+    LISTENER_NOT_FOUND: 72,
+    TOPIC_DELETION_DISABLED: 73,
+    FENCED_LEADER_EPOCH: 74,
+    UNKNOWN_LEADER_EPOCH: 75,
+    UNSUPPORTED_COMPRESSION_TYPE: 76,
+    STALE_BROKER_EPOCH: 77,
+    OFFSET_NOT_AVAILABLE: 78,
+    MEMBER_ID_REQUIRED: 79,
+    PREFERRED_LEADER_NOT_AVAILABLE: 80,
+    GROUP_MAX_SIZE_REACHED: 81,
+    FENCED_INSTANCE_ID: 82,
+    ELIGIBLE_LEADERS_NOT_AVAILABLE: 83,
+    ELECTION_NOT_NEEDED: 84,
+    NO_REASSIGNMENT_IN_PROGRESS: 85,
+    GROUP_SUBSCRIBED_TO_TOPIC: 86,
+    INVALID_RECORD: 87,
+    UNSTABLE_OFFSET_COMMIT: 88,
+    THROTTLING_QUOTA_EXCEEDED: 89,
+    PRODUCER_FENCED: 90,
+    RESOURCE_NOT_FOUND: 91,
+    DUPLICATE_RESOURCE: 92,
+    UNACCEPTABLE_CREDENTIAL: 93,
+    INCONSISTENT_VOTER_SET: 94,
+    INVALID_UPDATE_VERSION: 95,
+    FEATURE_UPDATE_FAILED: 96,
+    PRINCIPAL_DESERIALIZATION_FAILURE: 97,
+    SNAPSHOT_NOT_FOUND: 98,
+    POSITION_OUT_OF_RANGE: 99,
+    UNKNOWN_TOPIC_ID: 100,
+    DUPLICATE_BROKER_REGISTRATION: 101,
+    BROKER_ID_NOT_REGISTERED: 102,
+    INCONSISTENT_TOPIC_ID: 103,
+    INCONSISTENT_CLUSTER_ID: 104,
+    TRANSACTIONAL_ID_NOT_FOUND: 105,
+    FETCH_SESSION_TOPIC_ID_ERROR: 106,
+    INELIGIBLE_REPLICA: 107,
+    NEW_LEADER_ELECTED: 108,
+    OFFSET_MOVED_TO_TIERED_STORAGE: 109,
+    FENCED_MEMBER_EPOCH: 110,
+    UNRELEASED_INSTANCE_ID: 111,
+    UNSUPPORTED_ASSIGNOR: 112,
+    STALE_MEMBER_EPOCH: 113,
+    MISMATCHED_ENDPOINT_TYPE: 114,
+    UNSUPPORTED_ENDPOINT_TYPE: 115,
+    UNKNOWN_CONTROLLER_ID: 116,
+    UNKNOWN_SUBSCRIPTION_ID: 117,
+    TELEMETRY_TOO_LARGE: 118,
+    INVALID_REGISTRATION: 119,
+    TRANSACTION_ABORTABLE: 120,
+};

package/dist/api/init-producer-id.d.ts

@@ -0,0 +1,13 @@
+export declare const INIT_PRODUCER_ID: import("../utils/api").Api<{
+    transactionalId: string | null;
+    transactionTimeoutMs: number;
+    producerId: bigint;
+    producerEpoch: number;
+}, {
+    _tag: void;
+    throttleTimeMs: number;
+    errorCode: number;
+    producerId: bigint;
+    producerEpoch: number;
+    _tag2: void;
+}>;

package/dist/api/init-producer-id.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.INIT_PRODUCER_ID = void 0;
+const api_1 = require("../utils/api");
+const error_1 = require("../utils/error");
+exports.INIT_PRODUCER_ID = (0, api_1.createApi)({
+    apiKey: 22,
+    apiVersion: 4,
+    request: (encoder, body) => encoder
+        .writeUVarInt(0)
+        .writeCompactString(body.transactionalId)
+        .writeInt32(body.transactionTimeoutMs)
+        .writeInt64(body.producerId)
+        .writeInt16(body.producerEpoch)
+        .writeUVarInt(0),
+    response: (decoder) => {
+        const result = {
+            _tag: decoder.readTagBuffer(),
+            throttleTimeMs: decoder.readInt32(),
+            errorCode: decoder.readInt16(),
+            producerId: decoder.readInt64(),
+            producerEpoch: decoder.readInt16(),
+            _tag2: decoder.readTagBuffer(),
+        };
+        if (result.errorCode)
+            throw new error_1.KafkaTSApiError(result.errorCode, null, result);
+        return result;
+    },
+});

package/dist/api/join-group.d.ts

@@ -0,0 +1,34 @@
+/// <reference types="node" />
+export declare const JOIN_GROUP: import("../utils/api").Api<{
+    groupId: string;
+    sessionTimeoutMs: number;
+    rebalanceTimeoutMs: number;
+    memberId: string;
+    groupInstanceId: string | null;
+    protocolType: string;
+    protocols: {
+        name: string;
+        metadata: {
+            version: number;
+            topics: string[];
+        };
+    }[];
+    reason: string | null;
+}, {
+    _tag: void;
+    throttleTimeMs: number;
+    errorCode: number;
+    generationId: number;
+    protocolType: string | null;
+    protocolName: string | null;
+    leader: string;
+    skipAssignment: boolean;
+    memberId: string;
+    members: {
+        memberId: string;
+        groupInstanceId: string | null;
+        metadata: Buffer;
+        _tag: void;
+    }[];
+    _tag2: void;
+}>;

package/dist/api/join-group.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JOIN_GROUP = void 0;
+const api_1 = require("../utils/api");
+const encoder_1 = require("../utils/encoder");
+const error_1 = require("../utils/error");
+exports.JOIN_GROUP = (0, api_1.createApi)({
+    apiKey: 11,
+    apiVersion: 9,
+    request: (encoder, data) => encoder
+        .writeUVarInt(0)
+        .writeCompactString(data.groupId)
+        .writeInt32(data.sessionTimeoutMs)
+        .writeInt32(data.rebalanceTimeoutMs)
+        .writeCompactString(data.memberId)
+        .writeCompactString(data.groupInstanceId)
+        .writeCompactString(data.protocolType)
+        .writeCompactArray(data.protocols, (encoder, protocol) => {
+        const metadata = new encoder_1.Encoder()
+            .writeInt16(protocol.metadata.version)
+            .writeArray(protocol.metadata.topics, (encoder, topic) => encoder.writeString(topic))
+            .writeBytes(Buffer.alloc(0))
+            .value();
+        return encoder.writeCompactString(protocol.name).writeCompactBytes(metadata).writeUVarInt(0);
+    })
+        .writeCompactString(data.reason)
+        .writeUVarInt(0),
+    response: (decoder) => {
+        const result = {
+            _tag: decoder.readTagBuffer(),
+            throttleTimeMs: decoder.readInt32(),
+            errorCode: decoder.readInt16(),
+            generationId: decoder.readInt32(),
+            protocolType: decoder.readCompactString(),
+            protocolName: decoder.readCompactString(),
+            leader: decoder.readCompactString(),
+            skipAssignment: decoder.readBoolean(),
+            memberId: decoder.readCompactString(),
+            members: decoder.readCompactArray((decoder) => ({
+                memberId: decoder.readCompactString(),
+                groupInstanceId: decoder.readCompactString(),
+                metadata: decoder.readCompactBytes(),
+                _tag: decoder.readTagBuffer(),
+            })),
+            _tag2: decoder.readTagBuffer(),
+        };
+        if (result.errorCode)
+            throw new error_1.KafkaTSApiError(result.errorCode, null, result);
+        return result;
+    },
+});

package/dist/api/leave-group.d.ts

@@ -0,0 +1,19 @@
+export declare const LEAVE_GROUP: import("../utils/api").Api<{
+    groupId: string;
+    members: {
+        memberId: string;
+        groupInstanceId: string | null;
+        reason: string | null;
+    }[];
+}, {
+    _tag: void;
+    throttleTimeMs: number;
+    errorCode: number;
+    members: {
+        memberId: string;
+        groupInstanceId: string | null;
+        errorCode: number;
+        _tag: void;
+    }[];
+    _tag2: void;
+}>;

package/dist/api/leave-group.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LEAVE_GROUP = void 0;
+const api_1 = require("../utils/api");
+const error_1 = require("../utils/error");
+exports.LEAVE_GROUP = (0, api_1.createApi)({
+    apiKey: 13,
+    apiVersion: 5,
+    request: (encoder, body) => encoder
+        .writeUVarInt(0)
+        .writeCompactString(body.groupId)
+        .writeCompactArray(body.members, (encoder, member) => encoder
+        .writeCompactString(member.memberId)
+        .writeCompactString(member.groupInstanceId)
+        .writeCompactString(member.reason)
+        .writeUVarInt(0))
+        .writeUVarInt(0),
+    response: (decoder) => {
+        const result = {
+            _tag: decoder.readTagBuffer(),
+            throttleTimeMs: decoder.readInt32(),
+            errorCode: decoder.readInt16(),
+            members: decoder.readCompactArray((decoder) => ({
+                memberId: decoder.readCompactString(),
+                groupInstanceId: decoder.readCompactString(),
+                errorCode: decoder.readInt16(),
+                _tag: decoder.readTagBuffer(),
+            })),
+            _tag2: decoder.readTagBuffer(),
+        };
+        if (result.errorCode)
+            throw new error_1.KafkaTSApiError(result.errorCode, null, result);
+        result.members.forEach((member) => {
+            if (member.errorCode)
+                throw new error_1.KafkaTSApiError(member.errorCode, null, result);
+        });
+        return result;
+    },
+});

package/dist/api/list-offsets.d.ts

@@ -0,0 +1,29 @@
+import { IsolationLevel } from "./fetch";
+export declare const LIST_OFFSETS: import("../utils/api").Api<{
+    replicaId: number;
+    isolationLevel: IsolationLevel;
+    topics: {
+        name: string;
+        partitions: {
+            partitionIndex: number;
+            currentLeaderEpoch: number;
+            timestamp: bigint;
+        }[];
+    }[];
+}, {
+    _tag: void;
+    throttleTimeMs: number;
+    topics: {
+        name: string;
+        partitions: {
+            partitionIndex: number;
+            errorCode: number;
+            timestamp: bigint;
+            offset: bigint;
+            leaderEpoch: number;
+            _tag: void;
+        }[];
+        _tag: void;
+    }[];
+    _tag2: void;
+}>;

package/dist/api/list-offsets.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LIST_OFFSETS = void 0;
+const api_1 = require("../utils/api");
+const error_1 = require("../utils/error");
+exports.LIST_OFFSETS = (0, api_1.createApi)({
+    apiKey: 2,
+    apiVersion: 8,
+    request: (encoder, data) => encoder
+        .writeUVarInt(0)
+        .writeInt32(data.replicaId)
+        .writeInt8(data.isolationLevel)
+        .writeCompactArray(data.topics, (encoder, topic) => encoder
+        .writeCompactString(topic.name)
+        .writeCompactArray(topic.partitions, (encoder, partition) => encoder
+        .writeInt32(partition.partitionIndex)
+        .writeInt32(partition.currentLeaderEpoch)
+        .writeInt64(partition.timestamp)
+        .writeUVarInt(0))
+        .writeUVarInt(0))
+        .writeUVarInt(0),
+    response: (decoder) => {
+        const result = {
+            _tag: decoder.readTagBuffer(),
+            throttleTimeMs: decoder.readInt32(),
+            topics: decoder.readCompactArray((decoder) => ({
+                name: decoder.readCompactString(),
+                partitions: decoder.readCompactArray((decoder) => ({
+                    partitionIndex: decoder.readInt32(),
+                    errorCode: decoder.readInt16(),
+                    timestamp: decoder.readInt64(),
+                    offset: decoder.readInt64(),
+                    leaderEpoch: decoder.readInt32(),
+                    _tag: decoder.readTagBuffer(),
+                })),
+                _tag: decoder.readTagBuffer(),
+            })),
+            _tag2: decoder.readTagBuffer(),
+        };
+        result.topics.forEach((topic) => {
+            topic.partitions.forEach((partition) => {
+                if (partition.errorCode)
+                    throw new error_1.KafkaTSApiError(partition.errorCode, null, result);
+            });
+        });
+        return result;
+    },
+});

package/dist/api/metadata.d.ts

@@ -0,0 +1,40 @@
+export type Metadata = ReturnType<(typeof METADATA)["response"]>;
+export declare const METADATA: import("../utils/api").Api<{
+    topics: {
+        id: string | null;
+        name: string;
+    }[] | null;
+    allowTopicAutoCreation: boolean;
+    includeTopicAuthorizedOperations: boolean;
+}, {
+    _tag: void;
+    throttleTimeMs: number;
+    brokers: {
+        nodeId: number;
+        host: string;
+        port: number;
+        rack: string | null;
+        _tag: void;
+    }[];
+    clusterId: string | null;
+    controllerId: number;
+    topics: {
+        errorCode: number;
+        name: string;
+        topicId: string;
+        isInternal: boolean;
+        partitions: {
+            errorCode: number;
+            partitionIndex: number;
+            leaderId: number;
+            leaderEpoch: number;
+            replicaNodes: number[];
+            isrNodes: number[];
+            offlineReplicas: number[];
+            _tag: void;
+        }[];
+        topicAuthorizedOperations: number;
+        _tag: void;
+    }[];
+    _tag2: void;
+}>;

package/dist/api/metadata.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.METADATA = void 0;
+const api_1 = require("../utils/api");
+const error_1 = require("../utils/error");
+exports.METADATA = (0, api_1.createApi)({
+    apiKey: 3,
+    apiVersion: 12,
+    request: (encoder, data) => encoder
+        .writeUVarInt(0)
+        .writeCompactArray(data.topics, (encoder, topic) => encoder.writeUUID(topic.id).writeCompactString(topic.name).writeUVarInt(0))
+        .writeBoolean(data.allowTopicAutoCreation)
+        .writeBoolean(data.includeTopicAuthorizedOperations)
+        .writeUVarInt(0),
+    response: (decoder) => {
+        const result = {
+            _tag: decoder.readTagBuffer(),
+            throttleTimeMs: decoder.readInt32(),
+            brokers: decoder.readCompactArray((broker) => ({
+                nodeId: broker.readInt32(),
+                host: broker.readCompactString(),
+                port: broker.readInt32(),
+                rack: broker.readCompactString(),
+                _tag: broker.readTagBuffer(),
+            })),
+            clusterId: decoder.readCompactString(),
+            controllerId: decoder.readInt32(),
+            topics: decoder.readCompactArray((topic) => ({
+                errorCode: topic.readInt16(),
+                name: topic.readCompactString(),
+                topicId: topic.readUUID(),
+                isInternal: topic.readBoolean(),
+                partitions: topic.readCompactArray((partition) => ({
+                    errorCode: partition.readInt16(),
+                    partitionIndex: partition.readInt32(),
+                    leaderId: partition.readInt32(),
+                    leaderEpoch: partition.readInt32(),
+                    replicaNodes: partition.readCompactArray((node) => node.readInt32()),
+                    isrNodes: partition.readCompactArray((node) => node.readInt32()),
+                    offlineReplicas: partition.readCompactArray((node) => node.readInt32()),
+                    _tag: partition.readTagBuffer(),
+                })),
+                topicAuthorizedOperations: topic.readInt32(),
+                _tag: topic.readTagBuffer(),
+            })),
+            _tag2: decoder.readTagBuffer(),
+        };
+        result.topics.forEach((topic) => {
+            if (topic.errorCode)
+                throw new error_1.KafkaTSApiError(topic.errorCode, null, result);
+            topic.partitions.forEach((partition) => {
+                if (partition.errorCode)
+                    throw new error_1.KafkaTSApiError(partition.errorCode, null, result);
+            });
+        });
+        return result;
+    },
+});

package/dist/api/offset-commit.d.ts

@@ -0,0 +1,28 @@
+export declare const OFFSET_COMMIT: import("../utils/api").Api<{
+    groupId: string;
+    generationIdOrMemberEpoch: number;
+    memberId: string;
+    groupInstanceId: string | null;
+    topics: {
+        name: string;
+        partitions: {
+            partitionIndex: number;
+            committedOffset: bigint;
+            committedLeaderEpoch: number;
+            committedMetadata: string | null;
+        }[];
+    }[];
+}, {
+    _tag: void;
+    throttleTimeMs: number;
+    topics: {
+        name: string | null;
+        partitions: {
+            partitionIndex: number;
+            errorCode: number;
+            _tag: void;
+        }[];
+        _tag: void;
+    }[];
+    _tag2: void;
+}>;

package/dist/api/offset-commit.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OFFSET_COMMIT = void 0;
+const api_1 = require("../utils/api");
+const error_1 = require("../utils/error");
+exports.OFFSET_COMMIT = (0, api_1.createApi)({
+    apiKey: 8,
+    apiVersion: 9,
+    request: (encoder, data) => encoder
+        .writeUVarInt(0)
+        .writeCompactString(data.groupId)
+        .writeInt32(data.generationIdOrMemberEpoch)
+        .writeCompactString(data.memberId)
+        .writeCompactString(data.groupInstanceId)
+        .writeCompactArray(data.topics, (encoder, topic) => encoder
+        .writeCompactString(topic.name)
+        .writeCompactArray(topic.partitions, (encoder, partition) => encoder
+        .writeInt32(partition.partitionIndex)
+        .writeInt64(partition.committedOffset)
+        .writeInt32(partition.committedLeaderEpoch)
+        .writeCompactString(partition.committedMetadata)
+        .writeUVarInt(0))
+        .writeUVarInt(0))
+        .writeUVarInt(0),
+    response: (decoder) => {
+        const result = {
+            _tag: decoder.readTagBuffer(),
+            throttleTimeMs: decoder.readInt32(),
+            topics: decoder.readCompactArray((decoder) => ({
+                name: decoder.readCompactString(),
+                partitions: decoder.readCompactArray((decoder) => ({
+                    partitionIndex: decoder.readInt32(),
+                    errorCode: decoder.readInt16(),
+                    _tag: decoder.readTagBuffer(),
+                })),
+                _tag: decoder.readTagBuffer(),
+            })),
+            _tag2: decoder.readTagBuffer(),
+        };
+        result.topics.forEach((topic) => {
+            topic.partitions.forEach((partition) => {
+                if (partition.errorCode)
+                    throw new error_1.KafkaTSApiError(partition.errorCode, null, result);
+            });
+        });
+        return result;
+    },
+});

package/dist/api/offset-fetch.d.ts

@@ -0,0 +1,33 @@
+export declare const OFFSET_FETCH: import("../utils/api").Api<{
+    groups: {
+        groupId: string;
+        memberId: string | null;
+        memberEpoch: number;
+        topics: {
+            name: string;
+            partitionIndexes: number[];
+        }[];
+    }[];
+    requireStable: boolean;
+}, {
+    _tag: void;
+    throttleTimeMs: number;
+    groups: {
+        groupId: string | null;
+        topics: {
+            name: string;
+            partitions: {
+                partitionIndex: number;
+                committedOffset: bigint;
+                committedLeaderEpoch: number;
+                committedMetadata: string | null;
+                errorCode: number;
+                _tag: void;
+            }[];
+            _tag: void;
+        }[];
+        errorCode: number;
+        _tag: void;
+    }[];
+    _tag2: void;
+}>;