kafka-ts 0.0.1-beta

package/src/api/api-versions.ts

@@ -0,0 +1,21 @@
+import { createApi } from "../utils/api.js";
+import { KafkaTSApiError } from "../utils/error.js";
+
+export const API_VERSIONS = createApi({
+    apiKey: 18,
+    apiVersion: 2,
+    request: (encoder) => encoder,
+    response: (decoder) => {
+        const result = {
+            errorCode: decoder.readInt16(),
+            versions: decoder.readArray((version) => ({
+                apiKey: version.readInt16(),
+                minVersion: version.readInt16(),
+                maxVersion: version.readInt16(),
+            })),
+            throttleTimeMs: decoder.readInt32(),
+        };
+        if (result.errorCode) throw new KafkaTSApiError(result.errorCode, null, result);
+        return result;
+    },
+});

package/src/api/create-topics.ts

@@ -0,0 +1,78 @@
+import { createApi } from "../utils/api";
+import { KafkaTSApiError } from "../utils/error";
+
+export const CREATE_TOPICS = createApi({
+    apiKey: 19,
+    apiVersion: 7,
+    request: (
+        encoder,
+        data: {
+            topics: {
+                name: string;
+                numPartitions: number;
+                replicationFactor: number;
+                assignments: {
+                    partitionIndex: number;
+                    brokerIds: number[];
+                }[];
+                configs: {
+                    name: string;
+                    value: string | null;
+                }[];
+            }[];
+            timeoutMs: number;
+            validateOnly: boolean;
+        },
+    ) =>
+        encoder
+            .writeUVarInt(0)
+            .writeCompactArray(data.topics, (encoder, topic) =>
+                encoder
+                    .writeCompactString(topic.name)
+                    .writeInt32(topic.numPartitions)
+                    .writeInt16(topic.replicationFactor)
+                    .writeCompactArray(topic.assignments, (encoder, assignment) =>
+                        encoder
+                            .writeInt32(assignment.partitionIndex)
+                            .writeCompactArray(assignment.brokerIds, (encoder, brokerId) =>
+                                encoder.writeInt32(brokerId),
+                            )
+                            .writeUVarInt(0),
+                    )
+                    .writeCompactArray(topic.configs, (encoder, config) =>
+                        encoder.writeCompactString(config.name).writeCompactString(config.value).writeUVarInt(0),
+                    )
+                    .writeUVarInt(0),
+            )
+            .writeInt32(data.timeoutMs)
+            .writeBoolean(data.validateOnly)
+            .writeUVarInt(0),
+    response: (decoder) => {
+        const result = {
+            _tag: decoder.readTagBuffer(),
+            throttleTimeMs: decoder.readInt32(),
+            topics: decoder.readCompactArray((topic) => ({
+                name: topic.readCompactString(),
+                topicId: topic.readUUID(),
+                errorCode: topic.readInt16(),
+                errorMessage: topic.readCompactString(),
+                numPartitions: topic.readInt32(),
+                replicationFactor: topic.readInt16(),
+                configs: topic.readCompactArray((config) => ({
+                    name: config.readCompactString(),
+                    value: config.readCompactString(),
+                    readOnly: config.readBoolean(),
+                    configSource: config.readInt8(),
+                    isSensitive: config.readBoolean(),
+                    _tag: config.readTagBuffer(),
+                })),
+                _tag: topic.readTagBuffer(),
+            })),
+            _tag2: decoder.readTagBuffer(),
+        };
+        result.topics.forEach((topic) => {
+            if (topic.errorCode) throw new KafkaTSApiError(topic.errorCode, topic.errorMessage, result);
+        });
+        return result;
+    },
+});

package/src/api/delete-topics.ts

@@ -0,0 +1,42 @@
+import { createApi } from "../utils/api";
+import { KafkaTSApiError } from "../utils/error";
+
+export const DELETE_TOPICS = createApi({
+    apiKey: 20,
+    apiVersion: 6,
+    request: (
+        encoder,
+        data: {
+            topics: {
+                name: string | null;
+                topicId: string | null;
+            }[];
+            timeoutMs: number;
+        },
+    ) =>
+        encoder
+            .writeUVarInt(0)
+            .writeCompactArray(data.topics, (encoder, topic) =>
+                encoder.writeCompactString(topic.name).writeUUID(topic.topicId).writeUVarInt(0),
+            )
+            .writeInt32(data.timeoutMs)
+            .writeUVarInt(0),
+    response: (decoder) => {
+        const result = {
+            _tag: decoder.readTagBuffer(),
+            throttleTimeMs: decoder.readInt32(),
+            responses: decoder.readCompactArray((decoder) => ({
+                name: decoder.readCompactString(),
+                topicId: decoder.readUUID(),
+                errorCode: decoder.readInt16(),
+                errorMessage: decoder.readCompactString(),
+                _tag: decoder.readTagBuffer(),
+            })),
+            _tag2: decoder.readTagBuffer(),
+        };
+        result.responses.forEach((response) => {
+            if (response.errorCode) throw new KafkaTSApiError(response.errorCode, response.errorMessage, result);
+        });
+        return result;
+    },
+});

package/src/api/fetch.ts

@@ -0,0 +1,143 @@
+import { createApi } from "../utils/api";
+import { Decoder } from "../utils/decoder";
+import { KafkaTSApiError } from "../utils/error";
+
+export const enum IsolationLevel {
+    READ_UNCOMMITTED = 0,
+    READ_COMMITTED = 1,
+}
+
+export const FETCH = createApi({
+    apiKey: 1,
+    apiVersion: 16,
+    request: (
+        encoder,
+        data: {
+            maxWaitMs: number;
+            minBytes: number;
+            maxBytes: number;
+            isolationLevel: IsolationLevel;
+            sessionId: number;
+            sessionEpoch: number;
+            topics: {
+                topicId: string;
+                partitions: {
+                    partition: number;
+                    currentLeaderEpoch: number;
+                    fetchOffset: bigint;
+                    lastFetchedEpoch: number;
+                    logStartOffset: bigint;
+                    partitionMaxBytes: number;
+                }[];
+            }[];
+            forgottenTopicsData: {
+                topicId: string;
+                partitions: number[];
+            }[];
+            rackId: string;
+        },
+    ) =>
+        encoder
+            .writeUVarInt(0)
+            .writeInt32(data.maxWaitMs)
+            .writeInt32(data.minBytes)
+            .writeInt32(data.maxBytes)
+            .writeInt8(data.isolationLevel)
+            .writeInt32(data.sessionId)
+            .writeInt32(data.sessionEpoch)
+            .writeCompactArray(data.topics, (encoder, topic) =>
+                encoder
+                    .writeUUID(topic.topicId)
+                    .writeCompactArray(topic.partitions, (encoder, partition) =>
+                        encoder
+                            .writeInt32(partition.partition)
+                            .writeInt32(partition.currentLeaderEpoch)
+                            .writeInt64(partition.fetchOffset)
+                            .writeInt32(partition.lastFetchedEpoch)
+                            .writeInt64(partition.logStartOffset)
+                            .writeInt32(partition.partitionMaxBytes)
+                            .writeUVarInt(0),
+                    )
+                    .writeUVarInt(0),
+            )
+            .writeCompactArray(data.forgottenTopicsData, (encoder, forgottenTopic) =>
+                encoder
+                    .writeUUID(forgottenTopic.topicId)
+                    .writeCompactArray(forgottenTopic.partitions, (encoder, partition) => encoder.writeInt32(partition))
+                    .writeUVarInt(0),
+            )
+            .writeCompactString(data.rackId)
+            .writeUVarInt(0),
+    response: (decoder) => {
+        const result = {
+            _tag: decoder.readTagBuffer(),
+            throttleTimeMs: decoder.readInt32(),
+            errorCode: decoder.readInt16(),
+            sessionId: decoder.readInt32(),
+            responses: decoder.readCompactArray((response) => ({
+                topicId: response.readUUID(),
+                partitions: response.readCompactArray((partition) => ({
+                    partitionIndex: partition.readInt32(),
+                    errorCode: partition.readInt16(),
+                    highWatermark: partition.readInt64(),
+                    lastStableOffset: partition.readInt64(),
+                    logStartOffset: partition.readInt64(),
+                    abortedTransactions: partition.readCompactArray((abortedTransaction) => ({
+                        producerId: abortedTransaction.readInt64(),
+                        firstOffset: abortedTransaction.readInt64(),
+                        _tag: abortedTransaction.readTagBuffer(),
+                    })),
+                    preferredReadReplica: partition.readInt32(),
+                    records: decodeRecords(partition),
+                    _tag: partition.readTagBuffer(),
+                })),
+                _tag: response.readTagBuffer(),
+            })),
+            _tag2: decoder.readTagBuffer(),
+        };
+        if (result.errorCode) throw new KafkaTSApiError(result.errorCode, null, result);
+        result.responses.forEach((response) => {
+            response.partitions.forEach((partition) => {
+                if (partition.errorCode) throw new KafkaTSApiError(partition.errorCode, null, result);
+            });
+        });
+        return result;
+    },
+});
+
+const decodeRecords = (decoder: Decoder) => {
+    const size = decoder.readUVarInt() - 1;
+    if (size <= 0) {
+        return [];
+    }
+
+    const results = [];
+    while (decoder.getBufferLength() > decoder.getOffset() + 49) {
+        results.push({
+            baseOffset: decoder.readInt64(),
+            batchLength: decoder.readInt32(),
+            partitionLeaderEpoch: decoder.readInt32(),
+            magic: decoder.readInt8(),
+            crc: decoder.readUInt32(),
+            attributes: decoder.readInt16(),
+            lastOffsetDelta: decoder.readInt32(),
+            baseTimestamp: decoder.readInt64(),
+            maxTimestamp: decoder.readInt64(),
+            producerId: decoder.readInt64(),
+            producerEpoch: decoder.readInt16(),
+            baseSequence: decoder.readInt32(),
+            records: decoder.readRecords((record) => ({
+                attributes: record.readInt8(),
+                timestampDelta: record.readVarLong(),
+                offsetDelta: record.readVarInt(),
+                key: record.readVarIntString(),
+                value: record.readVarIntString(),
+                headers: record.readCompactArray((header) => ({
+                    key: header.readVarIntString(),
+                    value: header.readVarIntString(),
+                })),
+            })),
+        });
+    }
+    return results;
+};

package/src/api/find-coordinator.ts

@@ -0,0 +1,39 @@
+import { createApi } from "../utils/api";
+import { KafkaTSApiError } from "../utils/error";
+
+export const KEY_TYPE = {
+    GROUP: 0,
+    TRANSACTION: 1,
+};
+
+export const FIND_COORDINATOR = createApi({
+    apiKey: 10,
+    apiVersion: 4,
+    request: (encoder, data: { keyType: number; keys: string[] }) =>
+        encoder
+            .writeUVarInt(0)
+            .writeInt8(data.keyType)
+            .writeCompactArray(data.keys, (encoder, key) => encoder.writeCompactString(key))
+            .writeUVarInt(0),
+    response: (decoder) => {
+        const result = {
+            _tag: decoder.readTagBuffer(),
+            throttleTimeMs: decoder.readInt32(),
+            coordinators: decoder.readCompactArray((decoder) => ({
+                key: decoder.readCompactString(),
+                nodeId: decoder.readInt32(),
+                host: decoder.readCompactString()!,
+                port: decoder.readInt32(),
+                errorCode: decoder.readInt16(),
+                errorMessage: decoder.readCompactString(),
+                _tag: decoder.readTagBuffer(),
+            })),
+            _tag2: decoder.readTagBuffer(),
+        };
+        result.coordinators.forEach((coordinator) => {
+            if (coordinator.errorCode)
+                throw new KafkaTSApiError(coordinator.errorCode, coordinator.errorMessage, result);
+        });
+        return result;
+    },
+});

package/src/api/heartbeat.ts

@@ -0,0 +1,33 @@
+import { createApi } from "../utils/api";
+import { KafkaTSApiError } from "../utils/error";
+
+export const HEARTBEAT = createApi({
+    apiKey: 12,
+    apiVersion: 4,
+    request: (
+        encoder,
+        data: {
+            groupId: string;
+            generationId: number;
+            memberId: string;
+            groupInstanceId: string | null;
+        },
+    ) =>
+        encoder
+            .writeUVarInt(0)
+            .writeCompactString(data.groupId)
+            .writeInt32(data.generationId)
+            .writeCompactString(data.memberId)
+            .writeCompactString(data.groupInstanceId)
+            .writeUVarInt(0),
+    response: (decoder) => {
+        const result = {
+            _tag: decoder.readTagBuffer(),
+            throttleTimeMs: decoder.readInt32(),
+            errorCode: decoder.readInt16(),
+            _tag2: decoder.readTagBuffer(),
+        };
+        if (result.errorCode) throw new KafkaTSApiError(result.errorCode, null, result);
+        return result;
+    },
+});

package/src/api/index.ts

@@ -0,0 +1,164 @@
+import { Api } from "../utils/api";
+import { API_VERSIONS } from "./api-versions";
+import { CREATE_TOPICS } from "./create-topics";
+import { DELETE_TOPICS } from "./delete-topics";
+import { FETCH } from "./fetch";
+import { FIND_COORDINATOR } from "./find-coordinator";
+import { HEARTBEAT } from "./heartbeat";
+import { INIT_PRODUCER_ID } from "./init-producer-id";
+import { JOIN_GROUP } from "./join-group";
+import { LEAVE_GROUP } from "./leave-group";
+import { LIST_OFFSETS } from "./list-offsets";
+import { METADATA } from "./metadata";
+import { OFFSET_COMMIT } from "./offset-commit";
+import { OFFSET_FETCH } from "./offset-fetch";
+import { PRODUCE } from "./produce";
+import { SASL_AUTHENTICATE } from "./sasl-authenticate";
+import { SASL_HANDSHAKE } from "./sasl-handshake";
+import { SYNC_GROUP } from "./sync-group";
+
+export const API = {
+    API_VERSIONS,
+    CREATE_TOPICS,
+    DELETE_TOPICS,
+    FETCH,
+    FIND_COORDINATOR,
+    HEARTBEAT,
+    INIT_PRODUCER_ID,
+    JOIN_GROUP,
+    LEAVE_GROUP,
+    LIST_OFFSETS,
+    METADATA,
+    OFFSET_COMMIT,
+    OFFSET_FETCH,
+    PRODUCE,
+    SASL_AUTHENTICATE,
+    SASL_HANDSHAKE,
+    SYNC_GROUP,
+};
+
+export const getApiName = (api: Api<unknown, unknown>) => Object.entries(API).find(([, v]) => v === api)?.[0];
+
+export const 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/src/api/init-producer-id.ts

@@ -0,0 +1,35 @@
+import { createApi } from "../utils/api";
+import { KafkaTSApiError } from "../utils/error";
+
+export const INIT_PRODUCER_ID = createApi({
+    apiKey: 22,
+    apiVersion: 4,
+    request: (
+        encoder,
+        body: {
+            transactionalId: string | null;
+            transactionTimeoutMs: number;
+            producerId: bigint;
+            producerEpoch: number;
+        },
+    ) =>
+        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 KafkaTSApiError(result.errorCode, null, result);
+        return result;
+    },
+});

package/src/api/join-group.ts

@@ -0,0 +1,67 @@
+import { createApi } from "../utils/api";
+import { Encoder } from "../utils/encoder";
+import { KafkaTSApiError } from "../utils/error";
+
+export const JOIN_GROUP = createApi({
+    apiKey: 11,
+    apiVersion: 9,
+    request: (
+        encoder,
+        data: {
+            groupId: string;
+            sessionTimeoutMs: number;
+            rebalanceTimeoutMs: number;
+            memberId: string;
+            groupInstanceId: string | null;
+            protocolType: string;
+            protocols: {
+                name: string;
+                metadata: {
+                    version: number;
+                    topics: string[];
+                };
+            }[];
+            reason: string | null;
+        },
+    ) =>
+        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()
+                    .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 KafkaTSApiError(result.errorCode, null, result);
+        return result;
+    },
+});

package/src/api/leave-group.ts

@@ -0,0 +1,48 @@
+import { createApi } from "../utils/api";
+import { KafkaTSApiError } from "../utils/error";
+
+export const LEAVE_GROUP = createApi({
+    apiKey: 13,
+    apiVersion: 5,
+    request: (
+        encoder,
+        body: {
+            groupId: string;
+            members: {
+                memberId: string;
+                groupInstanceId: string | null;
+                reason: string | null;
+            }[];
+        },
+    ) =>
+        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 KafkaTSApiError(result.errorCode, null, result);
+        result.members.forEach((member) => {
+            if (member.errorCode) throw new KafkaTSApiError(member.errorCode, null, result);
+        });
+        return result;
+    },
+});