@platformatic/kafka 0.1.0

package/dist/apis/consumer/fetch.d.ts

@@ -0,0 +1,46 @@
+import { Reader } from '../../protocol/reader.ts';
+import { type RecordsBatch } from '../../protocol/records.ts';
+import { Writer } from '../../protocol/writer.ts';
+export interface FetchRequestPartition {
+    partition: number;
+    currentLeaderEpoch: number;
+    fetchOffset: bigint;
+    lastFetchedEpoch: number;
+    partitionMaxBytes: number;
+}
+export interface FetchRequestTopic {
+    topicId: string;
+    partitions: FetchRequestPartition[];
+}
+export interface FetchRequestForgottenTopicsData {
+    topic: string;
+    partitions: number[];
+}
+export type FetchRequest = Parameters<typeof createRequest>;
+export interface FetchResponsePartitionAbortedTransaction {
+    producerId: bigint;
+    firstOffset: bigint;
+}
+export interface FetchResponsePartition {
+    partitionIndex: number;
+    errorCode: number;
+    highWatermark: bigint;
+    lastStableOffset: bigint;
+    logStartOffset: bigint;
+    abortedTransactions: FetchResponsePartitionAbortedTransaction[];
+    preferredReadReplica: number;
+    records?: RecordsBatch;
+}
+export interface FetchResponseTopic {
+    topicId: string;
+    partitions: FetchResponsePartition[];
+}
+export type FetchResponse = {
+    throttleTimeMs: number;
+    errorCode: number;
+    sessionId: number;
+    responses: FetchResponseTopic[];
+};
+export declare function createRequest(maxWaitMs: number, minBytes: number, maxBytes: number, isolationLevel: number, sessionId: number, sessionEpoch: number, topics: FetchRequestTopic[], forgottenTopicsData: FetchRequestForgottenTopicsData[], rackId: string): Writer;
+export declare function parseResponse(_correlationId: number, apiKey: number, apiVersion: number, reader: Reader): FetchResponse;
+export declare const api: import("../definitions.ts").API<[maxWaitMs: number, minBytes: number, maxBytes: number, isolationLevel: number, sessionId: number, sessionEpoch: number, topics: FetchRequestTopic[], forgottenTopicsData: FetchRequestForgottenTopicsData[], rackId: string], FetchResponse>;

package/dist/apis/consumer/fetch.js

@@ -0,0 +1,121 @@
+import { ResponseError } from "../../errors.js";
+import { Reader } from "../../protocol/reader.js";
+import { readRecordsBatch } from "../../protocol/records.js";
+import { Writer } from "../../protocol/writer.js";
+import { createAPI } from "../definitions.js";
+/*
+  Fetch Request (Version: 17) => max_wait_ms min_bytes max_bytes isolation_level session_id session_epoch [topics] [forgotten_topics_data] rack_id TAG_BUFFER
+  max_wait_ms => INT32
+  min_bytes => INT32
+  max_bytes => INT32
+  isolation_level => INT8
+  session_id => INT32
+  session_epoch => INT32
+  topics => topic_id [partitions] TAG_BUFFER
+    topic_id => UUID
+    partitions => partition current_leader_epoch fetch_offset last_fetched_epoch log_start_offset partition_max_bytes TAG_BUFFER
+      partition => INT32
+      current_leader_epoch => INT32
+      fetch_offset => INT64
+      last_fetched_epoch => INT32
+      log_start_offset => INT64
+      partition_max_bytes => INT32
+  forgotten_topics_data => topic_id [partitions] TAG_BUFFER
+    topic_id => UUID
+    partitions => INT32
+  rack_id => COMPACT_STRING
+*/
+export function createRequest(maxWaitMs, minBytes, maxBytes, isolationLevel, sessionId, sessionEpoch, topics, forgottenTopicsData, rackId) {
+    return Writer.create()
+        .appendInt32(maxWaitMs)
+        .appendInt32(minBytes)
+        .appendInt32(maxBytes)
+        .appendInt8(isolationLevel)
+        .appendInt32(sessionId)
+        .appendInt32(sessionEpoch)
+        .appendArray(topics, (w, t) => {
+        w.appendUUID(t.topicId).appendArray(t.partitions, (w, p) => {
+            w.appendInt32(p.partition)
+                .appendInt32(p.currentLeaderEpoch)
+                .appendInt64(p.fetchOffset)
+                .appendInt32(p.lastFetchedEpoch)
+                .appendInt64(-1n)
+                .appendInt32(p.partitionMaxBytes);
+        });
+    })
+        .appendArray(forgottenTopicsData, (w, t) => {
+        w.appendUUID(t.topic).appendArray(t.partitions, (w, p) => {
+            w.appendInt32(p);
+        }, true, false);
+    })
+        .appendString(rackId)
+        .appendTaggedFields();
+}
+/*
+  Fetch Response (Version: 17) => throttle_time_ms error_code session_id [responses] TAG_BUFFER
+    throttle_time_ms => INT32
+    error_code => INT16
+    session_id => INT32
+    responses => topic_id [partitions] TAG_BUFFER
+      topic_id => UUID
+      partitions => partition_index error_code high_watermark last_stable_offset log_start_offset [aborted_transactions] preferred_read_replica records TAG_BUFFER
+        partition_index => INT32
+        error_code => INT16
+        high_watermark => INT64
+        last_stable_offset => INT64
+        log_start_offset => INT64
+        aborted_transactions => producer_id first_offset TAG_BUFFER
+          producer_id => INT64
+          first_offset => INT64
+        preferred_read_replica => INT32
+        records => COMPACT_RECORDS
+*/
+export function parseResponse(_correlationId, apiKey, apiVersion, reader) {
+    const errors = [];
+    const throttleTimeMs = reader.readInt32();
+    const errorCode = reader.readInt16();
+    if (errorCode !== 0) {
+        errors.push(['', errorCode]);
+    }
+    const response = {
+        throttleTimeMs,
+        errorCode,
+        sessionId: reader.readInt32(),
+        responses: reader.readArray((r, i) => {
+            return {
+                topicId: r.readUUID(),
+                partitions: r.readArray((r, j) => {
+                    const partition = {
+                        partitionIndex: r.readInt32(),
+                        errorCode: r.readInt16(),
+                        highWatermark: r.readInt64(),
+                        lastStableOffset: r.readInt64(),
+                        logStartOffset: r.readInt64(),
+                        abortedTransactions: r.readArray(r => {
+                            return {
+                                producerId: r.readInt64(),
+                                firstOffset: r.readInt64()
+                            };
+                        }),
+                        preferredReadReplica: r.readInt32()
+                    };
+                    let recordsSize = r.readUnsignedVarInt();
+                    if (partition.errorCode !== 0) {
+                        errors.push([`/responses/${i}/partitions/${j}`, partition.errorCode]);
+                    }
+                    if (recordsSize > 1) {
+                        recordsSize--;
+                        partition.records = readRecordsBatch(Reader.from(r.buffer.subarray(r.position, r.position + recordsSize)));
+                        r.skip(recordsSize);
+                    }
+                    return partition;
+                })
+            };
+        })
+    };
+    if (errors.length) {
+        throw new ResponseError(apiKey, apiVersion, Object.fromEntries(errors), response);
+    }
+    return response;
+}
+export const api = createAPI(1, 17, createRequest, parseResponse);

package/dist/apis/consumer/heartbeat.d.ts

@@ -0,0 +1,11 @@
+import { type NullableString } from '../../protocol/definitions.ts';
+import { type Reader } from '../../protocol/reader.ts';
+import { Writer } from '../../protocol/writer.ts';
+export type HeartbeatRequest = Parameters<typeof createRequest>;
+export interface HeartbeatResponse {
+    throttleTimeMs: number;
+    errorCode: number;
+}
+export declare function createRequest(groupId: string, generationId: number, memberId: string, groupInstanceId?: NullableString): Writer;
+export declare function parseResponse(_correlationId: number, apiKey: number, apiVersion: number, reader: Reader): HeartbeatResponse;
+export declare const api: import("../definitions.ts").API<[groupId: string, generationId: number, memberId: string, groupInstanceId?: NullableString], HeartbeatResponse>;

package/dist/apis/consumer/heartbeat.js

@@ -0,0 +1,34 @@
+import { ResponseError } from "../../errors.js";
+import { Writer } from "../../protocol/writer.js";
+import { createAPI } from "../definitions.js";
+/*
+  Heartbeat Request (Version: 4) => group_id generation_id member_id group_instance_id TAG_BUFFER
+    group_id => COMPACT_STRING
+    generation_id => INT32
+    member_id => COMPACT_STRING
+    group_instance_id => COMPACT_NULLABLE_STRING
+*/
+export function createRequest(groupId, generationId, memberId, groupInstanceId) {
+    return Writer.create()
+        .appendString(groupId)
+        .appendInt32(generationId)
+        .appendString(memberId)
+        .appendString(groupInstanceId)
+        .appendTaggedFields();
+}
+/*
+  Heartbeat Response (Version: 4) => throttle_time_ms error_code TAG_BUFFER
+    throttle_time_ms => INT32
+    error_code => INT16
+*/
+export function parseResponse(_correlationId, apiKey, apiVersion, reader) {
+    const response = {
+        throttleTimeMs: reader.readInt32(),
+        errorCode: reader.readInt16()
+    };
+    if (response.errorCode !== 0) {
+        throw new ResponseError(apiKey, apiVersion, { '': response.errorCode }, response);
+    }
+    return response;
+}
+export const api = createAPI(12, 4, createRequest, parseResponse);

package/dist/apis/consumer/index.d.ts

@@ -0,0 +1,9 @@
+export * as consumerGroupHeartbeatV0 from './consumer-group-heartbeat.ts';
+export * as fetchV17 from './fetch.ts';
+export * as heartbeatV4 from './heartbeat.ts';
+export * as joinGroupV9 from './join-group.ts';
+export * as leaveGroupV5 from './leave-group.ts';
+export * as listOffsetsV9 from './list-offsets.ts';
+export * as offsetCommitV9 from './offset-commit.ts';
+export * as offsetFetchV9 from './offset-fetch.ts';
+export * as syncGroupV5 from './sync-group.ts';

package/dist/apis/consumer/index.js

@@ -0,0 +1,9 @@
+export * as consumerGroupHeartbeatV0 from "./consumer-group-heartbeat.js";
+export * as fetchV17 from "./fetch.js";
+export * as heartbeatV4 from "./heartbeat.js";
+export * as joinGroupV9 from "./join-group.js";
+export * as leaveGroupV5 from "./leave-group.js";
+export * as listOffsetsV9 from "./list-offsets.js";
+export * as offsetCommitV9 from "./offset-commit.js";
+export * as offsetFetchV9 from "./offset-fetch.js";
+export * as syncGroupV5 from "./sync-group.js";

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

@@ -0,0 +1,27 @@
+import { type NullableString } from '../../protocol/definitions.ts';
+import { type Reader } from '../../protocol/reader.ts';
+import { Writer } from '../../protocol/writer.ts';
+export interface JoinGroupRequestProtocol {
+    name: string;
+    metadata?: Buffer | null;
+}
+export type JoinGroupRequest = Parameters<typeof createRequest>;
+export interface JoinGroupResponseMember {
+    memberId: string;
+    groupInstanceId?: NullableString;
+    metadata: Buffer | null;
+}
+export interface JoinGroupResponse {
+    throttleTimeMs: number;
+    errorCode: number;
+    generationId: number;
+    protocolType: NullableString;
+    protocolName: NullableString;
+    leader: string;
+    skipAssignment: boolean;
+    memberId: NullableString;
+    members: JoinGroupResponseMember[];
+}
+export declare function createRequest(groupId: string, sessionTimeoutMs: number, rebalanceTimeoutMs: number, memberId: string, groupInstanceId: NullableString, protocolType: string, protocols: JoinGroupRequestProtocol[], reason?: NullableString): Writer;
+export declare function parseResponse(_correlationId: number, apiKey: number, apiVersion: number, reader: Reader): JoinGroupResponse;
+export declare const api: import("../definitions.ts").API<[groupId: string, sessionTimeoutMs: number, rebalanceTimeoutMs: number, memberId: string, groupInstanceId: NullableString, protocolType: string, protocols: JoinGroupRequestProtocol[], reason?: NullableString], JoinGroupResponse>;

package/dist/apis/consumer/join-group.js

@@ -0,0 +1,71 @@
+import { ResponseError } from "../../errors.js";
+import { EMPTY_BUFFER } from "../../protocol/definitions.js";
+import { Writer } from "../../protocol/writer.js";
+import { createAPI } from "../definitions.js";
+/*
+  JoinGroup Request (Version: 9) => group_id session_timeout_ms rebalance_timeout_ms member_id group_instance_id protocol_type [protocols] reason TAG_BUFFER
+    group_id => COMPACT_STRING
+    session_timeout_ms => INT32
+    rebalance_timeout_ms => INT32
+    member_id => COMPACT_STRING
+    group_instance_id => COMPACT_NULLABLE_STRING
+    protocol_type => COMPACT_STRING
+    protocols => name metadata TAG_BUFFER
+      name => COMPACT_STRING
+      metadata => COMPACT_BYTES
+    reason => COMPACT_NULLABLE_STRING
+*/
+export function createRequest(groupId, sessionTimeoutMs, rebalanceTimeoutMs, memberId, groupInstanceId, protocolType, protocols, reason) {
+    return Writer.create()
+        .appendString(groupId)
+        .appendInt32(sessionTimeoutMs)
+        .appendInt32(rebalanceTimeoutMs)
+        .appendString(memberId)
+        .appendString(groupInstanceId)
+        .appendString(protocolType)
+        .appendArray(protocols, (w, protocol) => {
+        w.appendString(protocol.name).appendBytes(protocol.metadata ? protocol.metadata : EMPTY_BUFFER);
+    })
+        .appendString(reason)
+        .appendTaggedFields();
+}
+/*
+JoinGroup Response (Version: 9) => throttle_time_ms error_code generation_id protocol_type protocol_name leader skip_assignment member_id [members] TAG_BUFFER
+  throttle_time_ms => INT32
+  error_code => INT16
+  generation_id => INT32
+  protocol_type => COMPACT_NULLABLE_STRING
+  protocol_name => COMPACT_NULLABLE_STRING
+  leader => COMPACT_STRING
+  skip_assignment => BOOLEAN
+  member_id => COMPACT_STRING
+  members => member_id group_instance_id metadata TAG_BUFFER
+    member_id => COMPACT_STRING
+    group_instance_id => COMPACT_NULLABLE_STRING
+    metadata => COMPACT_BYTES
+
+*/
+export function parseResponse(_correlationId, apiKey, apiVersion, reader) {
+    const response = {
+        throttleTimeMs: reader.readInt32(),
+        errorCode: reader.readInt16(),
+        generationId: reader.readInt32(),
+        protocolType: reader.readNullableString(),
+        protocolName: reader.readNullableString(),
+        leader: reader.readString(),
+        skipAssignment: reader.readBoolean(),
+        memberId: reader.readNullableString(),
+        members: reader.readArray(r => {
+            return {
+                memberId: r.readString(),
+                groupInstanceId: r.readNullableString(),
+                metadata: r.readNullableBytes()
+            };
+        })
+    };
+    if (response.errorCode !== 0) {
+        throw new ResponseError(apiKey, apiVersion, { '': response.errorCode }, response);
+    }
+    return response;
+}
+export const api = createAPI(11, 9, createRequest, parseResponse);

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

@@ -0,0 +1,22 @@
+import { type NullableString } from '../../protocol/definitions.ts';
+import { type Reader } from '../../protocol/reader.ts';
+import { Writer } from '../../protocol/writer.ts';
+export interface LeaveGroupRequestMember {
+    memberId: string;
+    groupInstanceId?: NullableString;
+    reason?: NullableString;
+}
+export type LeaveGroupRequest = Parameters<typeof createRequest>;
+export interface LeaveGroupResponseMember {
+    memberId: NullableString;
+    groupInstanceId: NullableString;
+    errorCode: number;
+}
+export interface LeaveGroupResponse {
+    throttleTimeMs: number;
+    errorCode: number;
+    members: LeaveGroupResponseMember[];
+}
+export declare function createRequest(groupId: string, members: LeaveGroupRequestMember[]): Writer;
+export declare function parseResponse(_correlationId: number, apiKey: number, apiVersion: number, reader: Reader): LeaveGroupResponse;
+export declare const api: import("../definitions.ts").API<[groupId: string, members: LeaveGroupRequestMember[]], LeaveGroupResponse>;

package/dist/apis/consumer/leave-group.js

@@ -0,0 +1,57 @@
+import { ResponseError } from "../../errors.js";
+import { Writer } from "../../protocol/writer.js";
+import { createAPI } from "../definitions.js";
+/*
+  LeaveGroup Request (Version: 5) => group_id [members] TAG_BUFFER
+    group_id => COMPACT_STRING
+    members => member_id group_instance_id reason TAG_BUFFER
+      member_id => COMPACT_STRING
+      group_instance_id => COMPACT_NULLABLE_STRING
+      reason => COMPACT_NULLABLE_STRING
+*/
+export function createRequest(groupId, members) {
+    return Writer.create()
+        .appendString(groupId)
+        .appendArray(members, (w, m) => {
+        w.appendString(m.memberId).appendString(m.groupInstanceId).appendString(m.reason);
+    })
+        .appendTaggedFields();
+}
+/*
+  LeaveGroup Response (Version: 5) => throttle_time_ms error_code [members] TAG_BUFFER
+    throttle_time_ms => INT32
+    error_code => INT16
+    members => member_id group_instance_id error_code TAG_BUFFER
+      member_id => COMPACT_STRING
+      group_instance_id => COMPACT_NULLABLE_STRING
+      error_code => INT16
+
+*/
+export function parseResponse(_correlationId, apiKey, apiVersion, reader) {
+    const errors = [];
+    const throttleTimeMs = reader.readInt32();
+    const errorCode = reader.readInt16();
+    if (errorCode !== 0) {
+        errors.push(['', errorCode]);
+    }
+    const response = {
+        throttleTimeMs,
+        errorCode,
+        members: reader.readArray((r, i) => {
+            const member = {
+                memberId: r.readNullableString(),
+                groupInstanceId: r.readNullableString(),
+                errorCode: r.readInt16()
+            };
+            if (member.errorCode !== 0) {
+                errors.push([`/members/${i}`, member.errorCode]);
+            }
+            return member;
+        })
+    };
+    if (errors.length) {
+        throw new ResponseError(apiKey, apiVersion, Object.fromEntries(errors), response);
+    }
+    return response;
+}
+export const api = createAPI(13, 5, createRequest, parseResponse);

package/dist/apis/consumer/list-offsets.d.ts

@@ -0,0 +1,30 @@
+import { type Reader } from '../../protocol/reader.ts';
+import { Writer } from '../../protocol/writer.ts';
+export interface ListOffsetsRequestPartition {
+    partitionIndex: number;
+    currentLeaderEpoch: number;
+    timestamp: bigint;
+}
+export interface ListOffsetsRequestTopic {
+    name: string;
+    partitions: ListOffsetsRequestPartition[];
+}
+export type ListOffsetsRequest = Parameters<typeof createRequest>;
+export interface ListOffsetResponsePartition {
+    partitionIndex: number;
+    errorCode: number;
+    timestamp: bigint;
+    offset: bigint;
+    leaderEpoch: number;
+}
+export interface ListOffsetResponseTopic {
+    name: string;
+    partitions: ListOffsetResponsePartition[];
+}
+export interface ListOffsetsResponse {
+    throttleTimeMs: number;
+    topics: ListOffsetResponseTopic[];
+}
+export declare function createRequest(replica: number, isolationLevel: number, topics: ListOffsetsRequestTopic[]): Writer;
+export declare function parseResponse(_correlationId: number, apiKey: number, apiVersion: number, reader: Reader): ListOffsetsResponse;
+export declare const api: import("../definitions.ts").API<[replica: number, isolationLevel: number, topics: ListOffsetsRequestTopic[]], ListOffsetsResponse>;

package/dist/apis/consumer/list-offsets.js

@@ -0,0 +1,68 @@
+import { ResponseError } from "../../errors.js";
+import { Writer } from "../../protocol/writer.js";
+import { createAPI } from "../definitions.js";
+/*
+  ListOffsets Request (Version: 9) => replica_id isolation_level [topics] TAG_BUFFER
+    replica_id => INT32
+    isolation_level => INT8
+    topics => name [partitions] TAG_BUFFER
+      name => COMPACT_STRING
+      partitions => partition_index current_leader_epoch timestamp TAG_BUFFER
+        partition_index => INT32
+        current_leader_epoch => INT32
+        timestamp => INT64
+*/
+export function createRequest(replica, isolationLevel, topics) {
+    return Writer.create()
+        .appendInt32(replica)
+        .appendInt8(isolationLevel)
+        .appendArray(topics, (w, topic) => {
+        w.appendString(topic.name).appendArray(topic.partitions, (w, partition) => {
+            w.appendInt32(partition.partitionIndex)
+                .appendInt32(partition.currentLeaderEpoch)
+                .appendInt64(partition.timestamp);
+        });
+    })
+        .appendTaggedFields();
+}
+/*
+  ListOffsets Response (Version: 9) => throttle_time_ms [topics] TAG_BUFFER
+    throttle_time_ms => INT32
+    topics => name [partitions] TAG_BUFFER
+      name => COMPACT_STRING
+      partitions => partition_index error_code timestamp offset leader_epoch TAG_BUFFER
+        partition_index => INT32
+        error_code => INT16
+        timestamp => INT64
+        offset => INT64
+        leader_epoch => INT32
+*/
+export function parseResponse(_correlationId, apiKey, apiVersion, reader) {
+    const errors = [];
+    const response = {
+        throttleTimeMs: reader.readInt32(),
+        topics: reader.readArray((r, i) => {
+            return {
+                name: r.readString(),
+                partitions: r.readArray((r, j) => {
+                    const partition = {
+                        partitionIndex: r.readInt32(),
+                        errorCode: r.readInt16(),
+                        timestamp: r.readInt64(),
+                        offset: r.readInt64(),
+                        leaderEpoch: r.readInt32()
+                    };
+                    if (partition.errorCode !== 0) {
+                        errors.push([`/topics/${i}/partitions/${j}`, partition.errorCode]);
+                    }
+                    return partition;
+                })
+            };
+        })
+    };
+    if (errors.length) {
+        throw new ResponseError(apiKey, apiVersion, Object.fromEntries(errors), response);
+    }
+    return response;
+}
+export const api = createAPI(2, 9, createRequest, parseResponse);

package/dist/apis/consumer/offset-commit.d.ts

@@ -0,0 +1,29 @@
+import { type NullableString } from '../../protocol/definitions.ts';
+import { type Reader } from '../../protocol/reader.ts';
+import { Writer } from '../../protocol/writer.ts';
+export interface OffsetCommitRequestPartition {
+    partitionIndex: number;
+    committedOffset: bigint;
+    committedLeaderEpoch: number;
+    committedMetadata?: NullableString;
+}
+export interface OffsetCommitRequestTopic {
+    name: string;
+    partitions: OffsetCommitRequestPartition[];
+}
+export type OffsetCommitRequest = Parameters<typeof createRequest>;
+export interface OffsetCommitResponsePartition {
+    partitionIndex: number;
+    errorCode: number;
+}
+export interface OffsetCommitResponseTopic {
+    name: string;
+    partitions: OffsetCommitResponsePartition[];
+}
+export interface OffsetCommitResponse {
+    throttleTimeMs: number;
+    topics: OffsetCommitResponseTopic[];
+}
+export declare function createRequest(groupId: string, generationIdOrMemberEpoch: number, memberId: string, groupInstanceId: NullableString, topics: OffsetCommitRequestTopic[]): Writer;
+export declare function parseResponse(_correlationId: number, apiKey: number, apiVersion: number, reader: Reader): OffsetCommitResponse;
+export declare const api: import("../definitions.ts").API<[groupId: string, generationIdOrMemberEpoch: number, memberId: string, groupInstanceId: NullableString, topics: OffsetCommitRequestTopic[]], OffsetCommitResponse>;

package/dist/apis/consumer/offset-commit.js

@@ -0,0 +1,68 @@
+import { ResponseError } from "../../errors.js";
+import { Writer } from "../../protocol/writer.js";
+import { createAPI } from "../definitions.js";
+/*
+  OffsetCommit Request (Version: 9) => group_id generation_id_or_member_epoch member_id group_instance_id [topics] TAG_BUFFER
+    group_id => COMPACT_STRING
+    generation_id_or_member_epoch => INT32
+    member_id => COMPACT_STRING
+    group_instance_id => COMPACT_NULLABLE_STRING
+    topics => name [partitions] TAG_BUFFER
+      name => COMPACT_STRING
+      partitions => partition_index committed_offset committed_leader_epoch committed_metadata TAG_BUFFER
+        partition_index => INT32
+        committed_offset => INT64
+        committed_leader_epoch => INT32
+        committed_metadata => COMPACT_NULLABLE_STRING
+*/
+export function createRequest(groupId, generationIdOrMemberEpoch, memberId, groupInstanceId, topics) {
+    return Writer.create()
+        .appendString(groupId)
+        .appendInt32(generationIdOrMemberEpoch)
+        .appendString(memberId)
+        .appendString(groupInstanceId)
+        .appendArray(topics, (w, t) => {
+        w.appendString(t.name).appendArray(t.partitions, (w, p) => {
+            w.appendInt32(p.partitionIndex)
+                .appendInt64(p.committedOffset)
+                .appendInt32(p.committedLeaderEpoch)
+                .appendString(p.committedMetadata);
+        });
+    })
+        .appendTaggedFields();
+}
+/*
+  OffsetCommit Response (Version: 9) => throttle_time_ms [topics] TAG_BUFFER
+    throttle_time_ms => INT32
+    topics => name [partitions] TAG_BUFFER
+      name => COMPACT_STRING
+      partitions => partition_index error_code TAG_BUFFER
+        partition_index => INT32
+        error_code => INT16
+*/
+export function parseResponse(_correlationId, apiKey, apiVersion, reader) {
+    const errors = [];
+    const response = {
+        throttleTimeMs: reader.readInt32(),
+        topics: reader.readArray((r, i) => {
+            return {
+                name: r.readString(),
+                partitions: r.readArray((r, j) => {
+                    const partition = {
+                        partitionIndex: r.readInt32(),
+                        errorCode: r.readInt16()
+                    };
+                    if (partition.errorCode !== 0) {
+                        errors.push([`/topics/${i}/partitions/${j}`, partition.errorCode]);
+                    }
+                    return partition;
+                })
+            };
+        })
+    };
+    if (errors.length) {
+        throw new ResponseError(apiKey, apiVersion, Object.fromEntries(errors), response);
+    }
+    return response;
+}
+export const api = createAPI(8, 9, createRequest, parseResponse);

package/dist/apis/consumer/offset-fetch.d.ts

@@ -0,0 +1,37 @@
+import { type NullableString } from '../../protocol/definitions.ts';
+import { type Reader } from '../../protocol/reader.ts';
+import { Writer } from '../../protocol/writer.ts';
+export interface OffsetFetchRequestTopic {
+    name: string;
+    partitionIndexes: number[];
+}
+export interface OffsetFetchRequestGroup {
+    groupId: string;
+    memberId?: NullableString;
+    memberEpoch: number;
+    topics: OffsetFetchRequestTopic[];
+}
+export type OffsetFetchRequest = Parameters<typeof createRequest>;
+export interface OffsetFetchResponsePartition {
+    partitionIndex: number;
+    committedOffset: bigint;
+    committedLeaderEpoch: number;
+    metadata: NullableString;
+    errorCode: number;
+}
+export interface OffsetFetchResponseTopic {
+    name: string;
+    partitions: OffsetFetchResponsePartition[];
+}
+export interface OffsetFetchResponseGroup {
+    groupId: string;
+    topics: OffsetFetchResponseTopic[];
+    errorCode: number;
+}
+export interface OffsetFetchResponse {
+    throttleTimeMs: number;
+    groups: OffsetFetchResponseGroup[];
+}
+export declare function createRequest(groups: OffsetFetchRequestGroup[], requireStable: boolean): Writer;
+export declare function parseResponse(_correlationId: number, apiKey: number, apiVersion: number, reader: Reader): OffsetFetchResponse;
+export declare const api: import("../definitions.ts").API<[groups: OffsetFetchRequestGroup[], requireStable: boolean], OffsetFetchResponse>;