@platformatic/kafka 2.0.1 → 2.2.0

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

@@ -0,0 +1,56 @@
+import { ResponseError } from "../../errors.js";
+import { Writer } from "../../protocol/writer.js";
+import { createAPI } from "../definitions.js";
+/*
+  OffsetCommit Request (Version: 5) => group_id generation_id_or_member_epoch member_id [topics]
+    group_id => STRING
+    generation_id_or_member_epoch => INT32
+    member_id => STRING
+    topics => name [partitions]
+      name => STRING
+      partitions => partition_index committed_offset committed_metadata
+        partition_index => INT32
+        committed_offset => INT64
+        committed_metadata => NULLABLE_STRING
+*/
+export function createRequest(groupId, generationIdOrMemberEpoch, memberId, _groupInstanceId, topics) {
+    return Writer.create()
+        .appendString(groupId, false)
+        .appendInt32(generationIdOrMemberEpoch)
+        .appendString(memberId, false)
+        .appendArray(topics, (w, t) => {
+        w.appendString(t.name, false).appendArray(t.partitions, (w, p) => {
+            w.appendInt32(p.partitionIndex).appendInt64(p.committedOffset).appendString(p.committedMetadata, false);
+        }, false, false);
+    }, false, false);
+}
+/*
+  OffsetCommit Response (Version: 5) => throttle_time_ms [topics]
+    throttle_time_ms => INT32
+    topics => name [partitions]
+      name => STRING
+      partitions => partition_index error_code
+        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) => ({
+            name: r.readString(false),
+            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, null]]);
+                }
+                return partition;
+            }, false, false)
+        }), false, false)
+    };
+    if (errors.length) {
+        throw new ResponseError(apiKey, apiVersion, Object.fromEntries(errors), response);
+    }
+    return response;
+}
+export const api = createAPI(8, 5, createRequest, parseResponse, false, false);

package/dist/apis/consumer/offset-commit-v6.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-v6.js

@@ -0,0 +1,60 @@
+import { ResponseError } from "../../errors.js";
+import { Writer } from "../../protocol/writer.js";
+import { createAPI } from "../definitions.js";
+/*
+  OffsetCommit Request (Version: 6) => group_id generation_id_or_member_epoch member_id [topics]
+    group_id => STRING
+    generation_id_or_member_epoch => INT32
+    member_id => STRING
+    topics => name [partitions]
+      name => STRING
+      partitions => partition_index committed_offset committed_leader_epoch committed_metadata
+        partition_index => INT32
+        committed_offset => INT64
+        committed_leader_epoch => INT32
+        committed_metadata => NULLABLE_STRING
+*/
+export function createRequest(groupId, generationIdOrMemberEpoch, memberId, _groupInstanceId, topics) {
+    return Writer.create()
+        .appendString(groupId, false)
+        .appendInt32(generationIdOrMemberEpoch)
+        .appendString(memberId, false)
+        .appendArray(topics, (w, t) => {
+        w.appendString(t.name, false).appendArray(t.partitions, (w, p) => {
+            w.appendInt32(p.partitionIndex)
+                .appendInt64(p.committedOffset)
+                .appendInt32(p.committedLeaderEpoch)
+                .appendString(p.committedMetadata, false);
+        }, false, false);
+    }, false, false);
+}
+/*
+  OffsetCommit Response (Version: 6) => throttle_time_ms [topics]
+    throttle_time_ms => INT32
+    topics => name [partitions]
+      name => STRING
+      partitions => partition_index error_code
+        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) => ({
+            name: r.readString(false),
+            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, null]]);
+                }
+                return partition;
+            }, false, false)
+        }), false, false)
+    };
+    if (errors.length) {
+        throw new ResponseError(apiKey, apiVersion, Object.fromEntries(errors), response);
+    }
+    return response;
+}
+export const api = createAPI(8, 6, createRequest, parseResponse, false, false);

package/dist/apis/consumer/offset-commit-v7.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-v7.js

@@ -0,0 +1,62 @@
+import { ResponseError } from "../../errors.js";
+import { Writer } from "../../protocol/writer.js";
+import { createAPI } from "../definitions.js";
+/*
+  OffsetCommit Request (Version: 7) => group_id generation_id_or_member_epoch member_id group_instance_id [topics]
+    group_id => STRING
+    generation_id_or_member_epoch => INT32
+    member_id => STRING
+    group_instance_id => NULLABLE_STRING
+    topics => name [partitions]
+      name => STRING
+      partitions => partition_index committed_offset committed_leader_epoch committed_metadata
+        partition_index => INT32
+        committed_offset => INT64
+        committed_leader_epoch => INT32
+        committed_metadata => NULLABLE_STRING
+*/
+export function createRequest(groupId, generationIdOrMemberEpoch, memberId, groupInstanceId, topics) {
+    return Writer.create()
+        .appendString(groupId, false)
+        .appendInt32(generationIdOrMemberEpoch)
+        .appendString(memberId, false)
+        .appendString(groupInstanceId, false)
+        .appendArray(topics, (w, t) => {
+        w.appendString(t.name, false).appendArray(t.partitions, (w, p) => {
+            w.appendInt32(p.partitionIndex)
+                .appendInt64(p.committedOffset)
+                .appendInt32(p.committedLeaderEpoch)
+                .appendString(p.committedMetadata, false);
+        }, false, false);
+    }, false, false);
+}
+/*
+  OffsetCommit Response (Version: 7) => throttle_time_ms [topics]
+    throttle_time_ms => INT32
+    topics => name [partitions]
+      name => STRING
+      partitions => partition_index error_code
+        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) => ({
+            name: r.readString(false),
+            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, null]]);
+                }
+                return partition;
+            }, false, false)
+        }), false, false)
+    };
+    if (errors.length) {
+        throw new ResponseError(apiKey, apiVersion, Object.fromEntries(errors), response);
+    }
+    return response;
+}
+export const api = createAPI(8, 7, createRequest, parseResponse, false, false);

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

@@ -24,6 +24,6 @@ export interface OffsetCommitResponse {
     throttleTimeMs: number;
     topics: OffsetCommitResponseTopic[];
 }
-export declare function createRequest(groupId: string, generationIdOrMemberEpoch: number, memberId: NullableString, groupInstanceId: NullableString, topics: OffsetCommitRequestTopic[]): Writer;
+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: NullableString, groupInstanceId: NullableString, topics: OffsetCommitRequestTopic[]], 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-v8.js

@@ -26,9 +26,11 @@ export function createRequest(groupId, generationIdOrMemberEpoch, memberId, grou
             w.appendInt32(p.partitionIndex)
                 .appendInt64(p.committedOffset)
                 .appendInt32(p.committedLeaderEpoch)
-                .appendString(p.committedMetadata);
-        });
-    })
+                .appendString(p.committedMetadata)
+                .appendTaggedFields();
+        }, true, false);
+        w.appendTaggedFields();
+    }, true, false)
         .appendTaggedFields();
 }
 /*
@@ -60,6 +62,7 @@ export function parseResponse(_correlationId, apiKey, apiVersion, reader) {
             };
         })
     };
+    reader.readTaggedFields();
     if (errors.length) {
         throw new ResponseError(apiKey, apiVersion, Object.fromEntries(errors), response);
     }

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

@@ -24,6 +24,6 @@ export interface OffsetCommitResponse {
     throttleTimeMs: number;
     topics: OffsetCommitResponseTopic[];
 }
-export declare function createRequest(groupId: string, generationIdOrMemberEpoch: number, memberId: NullableString, groupInstanceId: NullableString, topics: OffsetCommitRequestTopic[]): Writer;
+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: NullableString, groupInstanceId: NullableString, topics: OffsetCommitRequestTopic[]], 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-v9.js

@@ -26,9 +26,11 @@ export function createRequest(groupId, generationIdOrMemberEpoch, memberId, grou
             w.appendInt32(p.partitionIndex)
                 .appendInt64(p.committedOffset)
                 .appendInt32(p.committedLeaderEpoch)
-                .appendString(p.committedMetadata);
-        });
-    })
+                .appendString(p.committedMetadata)
+                .appendTaggedFields();
+        }, true, false);
+        w.appendTaggedFields();
+    }, true, false)
         .appendTaggedFields();
 }
 /*
@@ -60,6 +62,7 @@ export function parseResponse(_correlationId, apiKey, apiVersion, reader) {
             };
         })
     };
+    reader.readTaggedFields();
     if (errors.length) {
         throw new ResponseError(apiKey, apiVersion, Object.fromEntries(errors), response);
     }

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

@@ -0,0 +1,40 @@
+import { type Nullable, 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: Nullable<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;
+    topics: OffsetFetchResponseTopic[];
+    errorCode: number;
+    groups: OffsetFetchResponseGroup[];
+}
+export declare function createRequest(groups: OffsetFetchRequestGroup[], requireStable: boolean): Writer;
+export declare function createRequestForVersion(groups: OffsetFetchRequestGroup[], _requireStable: boolean, version: number): 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>;

package/dist/apis/consumer/offset-fetch-v0.js

@@ -0,0 +1,62 @@
+import { ResponseError, UserError } from "../../errors.js";
+import { Writer } from "../../protocol/writer.js";
+import { createAPI } from "../definitions.js";
+/*
+  OffsetFetch Request (Version: 0) => group_id [topics]
+    group_id => STRING
+    topics => name [partition_indexes]
+      name => STRING
+      partition_indexes => INT32
+*/
+export function createRequest(groups, requireStable) {
+    return createRequestForVersion(groups, requireStable, 0);
+}
+export function createRequestForVersion(groups, _requireStable, version) {
+    const group = groups[0] ?? { groupId: '', topics: [] };
+    if (group.topics == null) {
+        throw new UserError(`OffsetFetch v${version} does not support fetching all offsets.`);
+    }
+    return Writer.create()
+        .appendString(group.groupId, false)
+        .appendArray(group.topics, (w, topic) => {
+        w.appendString(topic.name, false).appendArray(topic.partitionIndexes, (w, partition) => w.appendInt32(partition), false, false);
+    }, false, false);
+}
+/*
+  OffsetFetch Response (Version: 0) => [topics]
+    topics => name [partitions]
+      name => STRING
+      partitions => partition_index committed_offset metadata error_code
+        partition_index => INT32
+        committed_offset => INT64
+        metadata => NULLABLE_STRING
+        error_code => INT16
+*/
+export function parseResponse(_correlationId, apiKey, apiVersion, reader) {
+    const errors = [];
+    const response = {
+        throttleTimeMs: 0,
+        topics: reader.readArray((r, topicIndex) => ({
+            name: r.readString(false),
+            partitions: r.readArray((r, partitionIndex) => {
+                const partition = {
+                    partitionIndex: r.readInt32(),
+                    committedOffset: r.readInt64(),
+                    committedLeaderEpoch: -1,
+                    metadata: r.readNullableString(false),
+                    errorCode: r.readInt16()
+                };
+                if (partition.errorCode !== 0) {
+                    errors.push([`/topics/${topicIndex}/partitions/${partitionIndex}`, [partition.errorCode, null]]);
+                }
+                return partition;
+            }, false, false)
+        }), false, false),
+        errorCode: 0,
+        groups: []
+    };
+    if (errors.length)
+        throw new ResponseError(apiKey, apiVersion, Object.fromEntries(errors), response);
+    return response;
+}
+export const api = createAPI(9, 0, createRequest, parseResponse, false, false);

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

@@ -0,0 +1,6 @@
+import { type Reader } from '../../protocol/reader.ts';
+import { createRequestForVersion, type OffsetFetchRequest, type OffsetFetchResponse } from './offset-fetch-v0.ts';
+export type { OffsetFetchRequest, OffsetFetchRequestGroup, OffsetFetchRequestTopic, OffsetFetchResponse, OffsetFetchResponseGroup, OffsetFetchResponsePartition, OffsetFetchResponseTopic } from './offset-fetch-v0.ts';
+export declare function createRequest(...args: OffsetFetchRequest): ReturnType<typeof createRequestForVersion>;
+export declare function parseResponse(_correlationId: number, apiKey: number, apiVersion: number, reader: Reader): OffsetFetchResponse;
+export declare const api: import("../definitions.ts").API<[groups: import("./offset-fetch-v0.ts").OffsetFetchRequestGroup[], requireStable: boolean], OffsetFetchResponse>;

package/dist/apis/consumer/offset-fetch-v1.js

@@ -0,0 +1,41 @@
+import { ResponseError } from "../../errors.js";
+import { createAPI } from "../definitions.js";
+import { createRequestForVersion } from "./offset-fetch-v0.js";
+export function createRequest(...args) {
+    return createRequestForVersion(...args, 1);
+}
+/*
+  OffsetFetch Response (Version: 1) => [topics]
+    topics => name [partitions]
+      name => STRING
+      partitions => partition_index committed_offset metadata error_code
+        partition_index => INT32
+        committed_offset => INT64
+        metadata => NULLABLE_STRING
+        error_code => INT16
+*/
+export function parseResponse(_correlationId, apiKey, apiVersion, reader) {
+    const errors = [];
+    const topics = reader.readArray((r, topicIndex) => ({
+        name: r.readString(false),
+        partitions: r.readArray((r, partitionIndex) => {
+            const partition = {
+                partitionIndex: r.readInt32(),
+                committedOffset: r.readInt64(),
+                committedLeaderEpoch: -1,
+                metadata: r.readNullableString(false),
+                errorCode: r.readInt16()
+            };
+            if (partition.errorCode !== 0) {
+                errors.push([`/topics/${topicIndex}/partitions/${partitionIndex}`, [partition.errorCode, null]]);
+            }
+            return partition;
+        }, false, false)
+    }), false, false);
+    const response = { throttleTimeMs: 0, topics, errorCode: 0, groups: [] };
+    if (errors.length) {
+        throw new ResponseError(apiKey, apiVersion, Object.fromEntries(errors), response);
+    }
+    return response;
+}
+export const api = createAPI(9, 1, createRequest, parseResponse, false, false);

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

@@ -0,0 +1,7 @@
+import { type Reader } from '../../protocol/reader.ts';
+import { Writer } from '../../protocol/writer.ts';
+import { type OffsetFetchRequest, type OffsetFetchResponse } from './offset-fetch-v0.ts';
+export type { OffsetFetchRequest, OffsetFetchRequestGroup, OffsetFetchRequestTopic, OffsetFetchResponse, OffsetFetchResponseGroup, OffsetFetchResponsePartition, OffsetFetchResponseTopic } from './offset-fetch-v0.ts';
+export declare function createRequest(groups: OffsetFetchRequest[0], _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: import("./offset-fetch-v0.ts").OffsetFetchRequestGroup[], requireStable: boolean], OffsetFetchResponse>;

package/dist/apis/consumer/offset-fetch-v2.js

@@ -0,0 +1,48 @@
+import { ResponseError } from "../../errors.js";
+import { createAPI } from "../definitions.js";
+import { Writer } from "../../protocol/writer.js";
+export function createRequest(groups, _requireStable) {
+    const group = groups[0] ?? { groupId: '', topics: null };
+    return Writer.create()
+        .appendString(group.groupId, false)
+        .appendArray(group.topics, (writer, topic) => writer.appendString(topic.name, false).appendArray(topic.partitionIndexes, (writer, partitionIndex) => writer.appendInt32(partitionIndex), false, false), false, false);
+}
+/*
+  OffsetFetch Response (Version: 2) => [topics] error_code
+    topics => name [partitions]
+      name => STRING
+      partitions => partition_index committed_offset metadata error_code
+        partition_index => INT32
+        committed_offset => INT64
+        metadata => NULLABLE_STRING
+        error_code => INT16
+    error_code => INT16
+*/
+export function parseResponse(_correlationId, apiKey, apiVersion, reader) {
+    const errors = [];
+    const topics = reader.readArray((r, topicIndex) => ({
+        name: r.readString(false),
+        partitions: r.readArray((r, partitionIndex) => {
+            const partition = {
+                partitionIndex: r.readInt32(),
+                committedOffset: r.readInt64(),
+                committedLeaderEpoch: -1,
+                metadata: r.readNullableString(false),
+                errorCode: r.readInt16()
+            };
+            if (partition.errorCode !== 0) {
+                errors.push([`/topics/${topicIndex}/partitions/${partitionIndex}`, [partition.errorCode, null]]);
+            }
+            return partition;
+        }, false, false)
+    }), false, false);
+    const response = { throttleTimeMs: 0, topics, errorCode: reader.readInt16(), groups: [] };
+    if (response.errorCode !== 0) {
+        errors.push(['/errorCode', [response.errorCode, null]]);
+    }
+    if (errors.length) {
+        throw new ResponseError(apiKey, apiVersion, Object.fromEntries(errors), response);
+    }
+    return response;
+}
+export const api = createAPI(9, 2, createRequest, parseResponse, false, false);

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

@@ -0,0 +1,39 @@
+import { type Nullable, 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?: Nullable<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 OffsetFetchResponse {
+    throttleTimeMs: number;
+    topics: OffsetFetchResponseTopic[];
+    errorCode: number;
+    groups: OffsetFetchResponseGroup[];
+}
+export interface OffsetFetchResponseGroup {
+    groupId: string;
+    topics: OffsetFetchResponseTopic[];
+    errorCode: number;
+}
+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>;

package/dist/apis/consumer/offset-fetch-v3.js

@@ -0,0 +1,64 @@
+import { ResponseError } from "../../errors.js";
+import { Writer } from "../../protocol/writer.js";
+import { createAPI } from "../definitions.js";
+/*
+  OffsetFetch Request (Version: 3) => group_id [topics]
+    group_id => STRING
+    topics => name [partition_indexes]
+      name => STRING
+      partition_indexes => INT32
+*/
+export function createRequest(groups, _requireStable) {
+    const group = groups[0] ?? { groupId: '', topics: null };
+    return Writer.create()
+        .appendString(group.groupId, false)
+        .appendArray(group.topics, (writer, topic) => {
+        writer
+            .appendString(topic.name, false)
+            .appendArray(topic.partitionIndexes, (writer, partitionIndex) => writer.appendInt32(partitionIndex), false, false);
+    }, false, false);
+}
+/*
+  OffsetFetch Response (Version: 3) => throttle_time_ms [topics] error_code
+    throttle_time_ms => INT32
+    topics => name [partitions]
+      name => STRING
+      partitions => partition_index committed_offset metadata error_code
+        partition_index => INT32
+        committed_offset => INT64
+        metadata => NULLABLE_STRING
+        error_code => INT16
+    error_code => INT16
+*/
+export function parseResponse(_correlationId, apiKey, apiVersion, reader) {
+    const errors = [];
+    const response = {
+        throttleTimeMs: reader.readInt32(),
+        topics: reader.readArray((topicReader, topicIndex) => ({
+            name: topicReader.readString(false),
+            partitions: topicReader.readArray((partitionReader, partitionIndex) => {
+                const partition = {
+                    partitionIndex: partitionReader.readInt32(),
+                    committedOffset: partitionReader.readInt64(),
+                    committedLeaderEpoch: -1,
+                    metadata: partitionReader.readNullableString(false),
+                    errorCode: partitionReader.readInt16()
+                };
+                if (partition.errorCode !== 0) {
+                    errors.push([`/topics/${topicIndex}/partitions/${partitionIndex}`, [partition.errorCode, null]]);
+                }
+                return partition;
+            }, false, false)
+        }), false, false),
+        errorCode: reader.readInt16(),
+        groups: []
+    };
+    if (response.errorCode !== 0) {
+        errors.push(['/errorCode', [response.errorCode, null]]);
+    }
+    if (errors.length) {
+        throw new ResponseError(apiKey, apiVersion, Object.fromEntries(errors), response);
+    }
+    return response;
+}
+export const api = createAPI(9, 3, createRequest, parseResponse, false, false);

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

@@ -0,0 +1,39 @@
+import { type Nullable, 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?: Nullable<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 OffsetFetchResponse {
+    throttleTimeMs: number;
+    topics: OffsetFetchResponseTopic[];
+    errorCode: number;
+    groups: OffsetFetchResponseGroup[];
+}
+export interface OffsetFetchResponseGroup {
+    groupId: string;
+    topics: OffsetFetchResponseTopic[];
+    errorCode: number;
+}
+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>;