@platformatic/kafka 2.0.1 → 2.2.0

package/dist/apis/consumer/fetch-v8.js

@@ -0,0 +1,117 @@
+import { ResponseError } from "../../errors.js";
+import { Reader } from "../../protocol/reader.js";
+import { readRecordsBatches } from "../../protocol/records.js";
+import { Writer } from "../../protocol/writer.js";
+import { createAPI } from "../definitions.js";
+/*
+  Fetch Request (Version: 8) => replica_id max_wait_ms min_bytes max_bytes isolation_level session_id session_epoch [topics] [forgotten_topics_data]
+  replica_id => INT32
+  max_wait_ms => INT32
+  min_bytes => INT32
+  max_bytes => INT32
+  isolation_level => INT8
+  session_id => INT32
+  session_epoch => INT32
+  topics => topic_id [partitions]
+    topic => STRING
+    partitions => partition fetch_offset log_start_offset partition_max_bytes
+      partition => INT32
+      fetch_offset => INT64
+      log_start_offset => INT64
+      partition_max_bytes => INT32
+  forgotten_topics_data => topic [partitions]
+    topic => STRING
+    partitions => INT32
+*/
+export function createRequest(maxWaitMs, minBytes, maxBytes, isolationLevel, sessionId, sessionEpoch, topics, forgottenTopicsData, _rackId) {
+    return Writer.create()
+        .appendInt32(-1)
+        .appendInt32(maxWaitMs)
+        .appendInt32(minBytes)
+        .appendInt32(maxBytes)
+        .appendInt8(isolationLevel)
+        .appendInt32(sessionId)
+        .appendInt32(sessionEpoch)
+        .appendArray(topics, (w, t) => {
+        w.appendString(t.topicId, false).appendArray(t.partitions, (w, p) => {
+            w.appendInt32(p.partition).appendInt64(p.fetchOffset).appendInt64(-1n).appendInt32(p.partitionMaxBytes);
+        }, false, false);
+    }, false, false)
+        .appendArray(forgottenTopicsData, (w, t) => {
+        w.appendString(t.topicId ?? t.topic, false).appendArray(t.partitions, (w, p) => {
+            w.appendInt32(p);
+        }, false, false);
+    }, false, false);
+}
+/*
+  Fetch Response (Version: 8) => throttle_time_ms error_code session_id [responses]
+    throttle_time_ms => INT32
+    error_code => INT16
+    session_id => INT32
+    responses => topic [partitions]
+      topic => STRING
+      partitions => partition_index error_code high_watermark last_stable_offset log_start_offset [aborted_transactions] records
+        partition_index => INT32
+        error_code => INT16
+        high_watermark => INT64
+        last_stable_offset => INT64
+        log_start_offset => INT64
+        aborted_transactions => producer_id first_offset
+          producer_id => INT64
+          first_offset => INT64
+        records => RECORDS
+*/
+export function parseResponse(_correlationId, apiKey, apiVersion, reader) {
+    const errors = [];
+    const throttleTimeMs = reader.readInt32();
+    const errorCode = reader.readInt16();
+    if (errorCode !== 0) {
+        errors.push(['/', [errorCode, null]]);
+    }
+    const response = {
+        throttleTimeMs,
+        errorCode,
+        sessionId: reader.readInt32(),
+        responses: reader.readArray((r, i) => {
+            return {
+                topicId: r.readString(false),
+                partitions: r.readArray((r, j) => {
+                    const partition = {
+                        partitionIndex: r.readInt32(),
+                        errorCode: r.readInt16(),
+                        highWatermark: r.readInt64(),
+                        lastStableOffset: r.readInt64(),
+                        logStartOffset: r.readInt64(),
+                        abortedTransactions: r.readNullableArray(r => {
+                            return {
+                                producerId: r.readInt64(),
+                                firstOffset: r.readInt64()
+                            };
+                        }, false, false),
+                        records: null,
+                        preferredReadReplica: -1
+                    };
+                    if (partition.errorCode !== 0) {
+                        errors.push([`/responses/${i}/partitions/${j}`, [partition.errorCode, null]]);
+                    }
+                    const records = r.readNullableBytes(false);
+                    if (records === null) {
+                        partition.records = null;
+                    }
+                    else if (records.length > 0) {
+                        partition.records = readRecordsBatches(Reader.from(records));
+                    }
+                    else {
+                        partition.records = [];
+                    }
+                    return partition;
+                }, false, false)
+            };
+        }, false, false)
+    };
+    if (errors.length) {
+        throw new ResponseError(apiKey, apiVersion, Object.fromEntries(errors), response);
+    }
+    return response;
+}
+export const api = createAPI(1, 8, createRequest, parseResponse, false, false);

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

@@ -0,0 +1,51 @@
+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 type FetchRequestForgottenTopicsData = {
+    topicId: string; /** @deprecated Use topicId instead. */
+    topic?: string;
+    partitions: number[];
+} | {
+    topic: string;
+    topicId?: never;
+    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[] | null;
+    preferredReadReplica: number;
+    records: RecordsBatch[] | null;
+}
+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-v9.js

@@ -0,0 +1,122 @@
+import { ResponseError } from "../../errors.js";
+import { Reader } from "../../protocol/reader.js";
+import { readRecordsBatches } from "../../protocol/records.js";
+import { Writer } from "../../protocol/writer.js";
+import { createAPI } from "../definitions.js";
+/*
+  Fetch Request (Version: 9) => replica_id max_wait_ms min_bytes max_bytes isolation_level session_id session_epoch [topics] [forgotten_topics_data]
+  replica_id => INT32
+  max_wait_ms => INT32
+  min_bytes => INT32
+  max_bytes => INT32
+  isolation_level => INT8
+  session_id => INT32
+  session_epoch => INT32
+  topics => topic_id [partitions]
+    topic => STRING
+    partitions => partition current_leader_epoch fetch_offset log_start_offset partition_max_bytes
+      partition => INT32
+      current_leader_epoch => INT32
+      fetch_offset => INT64
+      log_start_offset => INT64
+      partition_max_bytes => INT32
+  forgotten_topics_data => topic [partitions]
+    topic => STRING
+    partitions => INT32
+*/
+export function createRequest(maxWaitMs, minBytes, maxBytes, isolationLevel, sessionId, sessionEpoch, topics, forgottenTopicsData, _rackId) {
+    return Writer.create()
+        .appendInt32(-1)
+        .appendInt32(maxWaitMs)
+        .appendInt32(minBytes)
+        .appendInt32(maxBytes)
+        .appendInt8(isolationLevel)
+        .appendInt32(sessionId)
+        .appendInt32(sessionEpoch)
+        .appendArray(topics, (w, t) => {
+        w.appendString(t.topicId, false).appendArray(t.partitions, (w, p) => {
+            w.appendInt32(p.partition)
+                .appendInt32(p.currentLeaderEpoch)
+                .appendInt64(p.fetchOffset)
+                .appendInt64(-1n)
+                .appendInt32(p.partitionMaxBytes);
+        }, false, false);
+    }, false, false)
+        .appendArray(forgottenTopicsData, (w, t) => {
+        w.appendString(t.topicId ?? t.topic, false).appendArray(t.partitions, (w, p) => {
+            w.appendInt32(p);
+        }, false, false);
+    }, false, false);
+}
+/*
+  Fetch Response (Version: 9) => throttle_time_ms error_code session_id [responses]
+    throttle_time_ms => INT32
+    error_code => INT16
+    session_id => INT32
+    responses => topic [partitions]
+      topic => STRING
+      partitions => partition_index error_code high_watermark last_stable_offset log_start_offset [aborted_transactions] records
+        partition_index => INT32
+        error_code => INT16
+        high_watermark => INT64
+        last_stable_offset => INT64
+        log_start_offset => INT64
+        aborted_transactions => producer_id first_offset
+          producer_id => INT64
+          first_offset => INT64
+        records => RECORDS
+*/
+export function parseResponse(_correlationId, apiKey, apiVersion, reader) {
+    const errors = [];
+    const throttleTimeMs = reader.readInt32();
+    const errorCode = reader.readInt16();
+    if (errorCode !== 0) {
+        errors.push(['/', [errorCode, null]]);
+    }
+    const response = {
+        throttleTimeMs,
+        errorCode,
+        sessionId: reader.readInt32(),
+        responses: reader.readArray((r, i) => {
+            return {
+                topicId: r.readString(false),
+                partitions: r.readArray((r, j) => {
+                    const partition = {
+                        partitionIndex: r.readInt32(),
+                        errorCode: r.readInt16(),
+                        highWatermark: r.readInt64(),
+                        lastStableOffset: r.readInt64(),
+                        logStartOffset: r.readInt64(),
+                        abortedTransactions: r.readNullableArray(r => {
+                            return {
+                                producerId: r.readInt64(),
+                                firstOffset: r.readInt64()
+                            };
+                        }, false, false),
+                        records: null,
+                        preferredReadReplica: -1
+                    };
+                    if (partition.errorCode !== 0) {
+                        errors.push([`/responses/${i}/partitions/${j}`, [partition.errorCode, null]]);
+                    }
+                    const records = r.readNullableBytes(false);
+                    if (records === null) {
+                        partition.records = null;
+                    }
+                    else if (records.length > 0) {
+                        partition.records = readRecordsBatches(Reader.from(records));
+                    }
+                    else {
+                        partition.records = [];
+                    }
+                    return partition;
+                }, false, false)
+            };
+        }, false, false)
+    };
+    if (errors.length) {
+        throw new ResponseError(apiKey, apiVersion, Object.fromEntries(errors), response);
+    }
+    return response;
+}
+export const api = createAPI(1, 9, createRequest, parseResponse, false, false);

package/dist/apis/consumer/heartbeat-v0.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-v0.js

@@ -0,0 +1,24 @@
+import { ResponseError } from "../../errors.js";
+import { Writer } from "../../protocol/writer.js";
+import { createAPI } from "../definitions.js";
+/*
+  Heartbeat Request (Version: 0) => group_id generation_id member_id
+    group_id => STRING
+    generation_id => INT32
+    member_id => STRING
+*/
+export function createRequest(groupId, generationId, memberId, _groupInstanceId) {
+    return Writer.create().appendString(groupId, false).appendInt32(generationId).appendString(memberId, false);
+}
+/*
+  Heartbeat Response (Version: 0) => error_code
+    error_code => INT16
+*/
+export function parseResponse(_correlationId, apiKey, apiVersion, reader) {
+    const response = { throttleTimeMs: 0, errorCode: reader.readInt16() };
+    if (response.errorCode !== 0) {
+        throw new ResponseError(apiKey, apiVersion, { '/': [response.errorCode, null] }, response);
+    }
+    return response;
+}
+export const api = createAPI(12, 0, createRequest, parseResponse, false, false);

package/dist/apis/consumer/heartbeat-v1.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-v1.js

@@ -0,0 +1,31 @@
+import { ResponseError } from "../../errors.js";
+import { Writer } from "../../protocol/writer.js";
+import { createAPI } from "../definitions.js";
+/*
+  Heartbeat Request (Version: 1) => group_id generation_id member_id
+    group_id => STRING
+    generation_id => INT32
+    member_id => STRING
+*/
+export function createRequest(groupId, generationId, memberId, _groupInstanceId) {
+    return Writer.create()
+        .appendString(groupId, false)
+        .appendInt32(generationId)
+        .appendString(memberId, false);
+}
+/*
+  Heartbeat Response (Version: 1) => throttle_time_ms error_code
+    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, null] }, response);
+    }
+    return response;
+}
+export const api = createAPI(12, 1, createRequest, parseResponse, false, false);

package/dist/apis/consumer/heartbeat-v2.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-v2.js

@@ -0,0 +1,31 @@
+import { ResponseError } from "../../errors.js";
+import { Writer } from "../../protocol/writer.js";
+import { createAPI } from "../definitions.js";
+/*
+  Heartbeat Request (Version: 2) => group_id generation_id member_id
+    group_id => STRING
+    generation_id => INT32
+    member_id => STRING
+*/
+export function createRequest(groupId, generationId, memberId, _groupInstanceId) {
+    return Writer.create()
+        .appendString(groupId, false)
+        .appendInt32(generationId)
+        .appendString(memberId, false);
+}
+/*
+  Heartbeat Response (Version: 2) => throttle_time_ms error_code
+    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, null] }, response);
+    }
+    return response;
+}
+export const api = createAPI(12, 2, createRequest, parseResponse, false, false);

package/dist/apis/consumer/heartbeat-v3.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-v3.js

@@ -0,0 +1,33 @@
+import { ResponseError } from "../../errors.js";
+import { Writer } from "../../protocol/writer.js";
+import { createAPI } from "../definitions.js";
+/*
+  Heartbeat Request (Version: 3) => group_id generation_id member_id group_instance_id
+    group_id => STRING
+    generation_id => INT32
+    member_id => STRING
+    group_instance_id => NULLABLE_STRING
+*/
+export function createRequest(groupId, generationId, memberId, groupInstanceId) {
+    return Writer.create()
+        .appendString(groupId, false)
+        .appendInt32(generationId)
+        .appendString(memberId, false)
+        .appendString(groupInstanceId, false);
+}
+/*
+  Heartbeat Response (Version: 3) => throttle_time_ms error_code
+    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, null] }, response);
+    }
+    return response;
+}
+export const api = createAPI(12, 3, createRequest, parseResponse, false, false);

package/dist/apis/consumer/heartbeat-v4.js

@@ -26,6 +26,7 @@ export function parseResponse(_correlationId, apiKey, apiVersion, reader) {
         throttleTimeMs: reader.readInt32(),
         errorCode: reader.readInt16()
     };
+    reader.readTaggedFields();
     if (response.errorCode !== 0) {
         throw new ResponseError(apiKey, apiVersion, { '/': [response.errorCode, null] }, response);
     }

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

@@ -1,5 +1,13 @@
 export * as consumerGroupHeartbeatV0 from './consumer-group-heartbeat-v0.ts';
 export * as consumerGroupHeartbeatV1 from './consumer-group-heartbeat-v1.ts';
+export * as fetchV4 from './fetch-v4.ts';
+export * as fetchV5 from './fetch-v5.ts';
+export * as fetchV6 from './fetch-v6.ts';
+export * as fetchV7 from './fetch-v7.ts';
+export * as fetchV8 from './fetch-v8.ts';
+export * as fetchV9 from './fetch-v9.ts';
+export * as fetchV10 from './fetch-v10.ts';
+export * as fetchV11 from './fetch-v11.ts';
 export * as fetchV12 from './fetch-v12.ts';
 export * as fetchV13 from './fetch-v13.ts';
 export * as fetchV14 from './fetch-v14.ts';
@@ -7,21 +15,64 @@ export * as fetchV15 from './fetch-v15.ts';
 export * as fetchV16 from './fetch-v16.ts';
 export * as fetchV17 from './fetch-v17.ts';
 export * as heartbeatV4 from './heartbeat-v4.ts';
+export * as heartbeatV3 from './heartbeat-v3.ts';
+export * as heartbeatV2 from './heartbeat-v2.ts';
+export * as heartbeatV1 from './heartbeat-v1.ts';
+export * as heartbeatV0 from './heartbeat-v0.ts';
+export * as joinGroupV0 from './join-group-v0.ts';
+export * as joinGroupV1 from './join-group-v1.ts';
+export * as joinGroupV2 from './join-group-v2.ts';
+export * as joinGroupV3 from './join-group-v3.ts';
+export * as joinGroupV4 from './join-group-v4.ts';
+export * as joinGroupV5 from './join-group-v5.ts';
 export * as joinGroupV6 from './join-group-v6.ts';
 export * as joinGroupV7 from './join-group-v7.ts';
 export * as joinGroupV8 from './join-group-v8.ts';
 export * as joinGroupV9 from './join-group-v9.ts';
+export * as leaveGroupV0 from './leave-group-v0.ts';
+export * as leaveGroupV1 from './leave-group-v1.ts';
+export * as leaveGroupV2 from './leave-group-v2.ts';
+export * as leaveGroupV3 from './leave-group-v3.ts';
 export * as leaveGroupV4 from './leave-group-v4.ts';
 export * as leaveGroupV5 from './leave-group-v5.ts';
+export * as listOffsetsV0 from './list-offsets-v0.ts';
+export * as listOffsetsV1 from './list-offsets-v1.ts';
+export * as listOffsetsV2 from './list-offsets-v2.ts';
+export * as listOffsetsV3 from './list-offsets-v3.ts';
+export * as listOffsetsV4 from './list-offsets-v4.ts';
 export * as listOffsetsV5 from './list-offsets-v5.ts';
 export * as listOffsetsV6 from './list-offsets-v6.ts';
 export * as listOffsetsV7 from './list-offsets-v7.ts';
 export * as listOffsetsV8 from './list-offsets-v8.ts';
 export * as listOffsetsV9 from './list-offsets-v9.ts';
+export * as offsetCommitV0 from './offset-commit-v0.ts';
+export * as offsetCommitV1 from './offset-commit-v1.ts';
+export * as offsetCommitV2 from './offset-commit-v2.ts';
 export * as offsetCommitV8 from './offset-commit-v8.ts';
 export * as offsetCommitV9 from './offset-commit-v9.ts';
+export * as offsetCommitV3 from './offset-commit-v3.ts';
+export * as offsetCommitV4 from './offset-commit-v4.ts';
+export * as offsetCommitV5 from './offset-commit-v5.ts';
+export * as offsetCommitV6 from './offset-commit-v6.ts';
+export * as offsetCommitV7 from './offset-commit-v7.ts';
+export * as offsetFetchV0 from './offset-fetch-v0.ts';
+export * as offsetFetchV1 from './offset-fetch-v1.ts';
+export * as offsetFetchV2 from './offset-fetch-v2.ts';
+export * as offsetFetchV3 from './offset-fetch-v3.ts';
+export * as offsetFetchV4 from './offset-fetch-v4.ts';
+export * as offsetFetchV5 from './offset-fetch-v5.ts';
+export * as offsetFetchV6 from './offset-fetch-v6.ts';
+export * as offsetFetchV7 from './offset-fetch-v7.ts';
 export * as offsetFetchV8 from './offset-fetch-v8.ts';
 export * as offsetFetchV9 from './offset-fetch-v9.ts';
+export * as offsetForLeaderEpochV0 from './offset-for-leader-epoch-v0.ts';
+export * as offsetForLeaderEpochV1 from './offset-for-leader-epoch-v1.ts';
+export * as offsetForLeaderEpochV2 from './offset-for-leader-epoch-v2.ts';
+export * as offsetForLeaderEpochV3 from './offset-for-leader-epoch-v3.ts';
 export * as offsetForLeaderEpochV4 from './offset-for-leader-epoch-v4.ts';
+export * as syncGroupV0 from './sync-group-v0.ts';
+export * as syncGroupV1 from './sync-group-v1.ts';
+export * as syncGroupV2 from './sync-group-v2.ts';
+export * as syncGroupV3 from './sync-group-v3.ts';
 export * as syncGroupV4 from './sync-group-v4.ts';
 export * as syncGroupV5 from './sync-group-v5.ts';

package/dist/apis/consumer/index.js

@@ -1,5 +1,13 @@
 export * as consumerGroupHeartbeatV0 from "./consumer-group-heartbeat-v0.js";
 export * as consumerGroupHeartbeatV1 from "./consumer-group-heartbeat-v1.js";
+export * as fetchV4 from "./fetch-v4.js";
+export * as fetchV5 from "./fetch-v5.js";
+export * as fetchV6 from "./fetch-v6.js";
+export * as fetchV7 from "./fetch-v7.js";
+export * as fetchV8 from "./fetch-v8.js";
+export * as fetchV9 from "./fetch-v9.js";
+export * as fetchV10 from "./fetch-v10.js";
+export * as fetchV11 from "./fetch-v11.js";
 export * as fetchV12 from "./fetch-v12.js";
 export * as fetchV13 from "./fetch-v13.js";
 export * as fetchV14 from "./fetch-v14.js";
@@ -7,21 +15,64 @@ export * as fetchV15 from "./fetch-v15.js";
 export * as fetchV16 from "./fetch-v16.js";
 export * as fetchV17 from "./fetch-v17.js";
 export * as heartbeatV4 from "./heartbeat-v4.js";
+export * as heartbeatV3 from "./heartbeat-v3.js";
+export * as heartbeatV2 from "./heartbeat-v2.js";
+export * as heartbeatV1 from "./heartbeat-v1.js";
+export * as heartbeatV0 from "./heartbeat-v0.js";
+export * as joinGroupV0 from "./join-group-v0.js";
+export * as joinGroupV1 from "./join-group-v1.js";
+export * as joinGroupV2 from "./join-group-v2.js";
+export * as joinGroupV3 from "./join-group-v3.js";
+export * as joinGroupV4 from "./join-group-v4.js";
+export * as joinGroupV5 from "./join-group-v5.js";
 export * as joinGroupV6 from "./join-group-v6.js";
 export * as joinGroupV7 from "./join-group-v7.js";
 export * as joinGroupV8 from "./join-group-v8.js";
 export * as joinGroupV9 from "./join-group-v9.js";
+export * as leaveGroupV0 from "./leave-group-v0.js";
+export * as leaveGroupV1 from "./leave-group-v1.js";
+export * as leaveGroupV2 from "./leave-group-v2.js";
+export * as leaveGroupV3 from "./leave-group-v3.js";
 export * as leaveGroupV4 from "./leave-group-v4.js";
 export * as leaveGroupV5 from "./leave-group-v5.js";
+export * as listOffsetsV0 from "./list-offsets-v0.js";
+export * as listOffsetsV1 from "./list-offsets-v1.js";
+export * as listOffsetsV2 from "./list-offsets-v2.js";
+export * as listOffsetsV3 from "./list-offsets-v3.js";
+export * as listOffsetsV4 from "./list-offsets-v4.js";
 export * as listOffsetsV5 from "./list-offsets-v5.js";
 export * as listOffsetsV6 from "./list-offsets-v6.js";
 export * as listOffsetsV7 from "./list-offsets-v7.js";
 export * as listOffsetsV8 from "./list-offsets-v8.js";
 export * as listOffsetsV9 from "./list-offsets-v9.js";
+export * as offsetCommitV0 from "./offset-commit-v0.js";
+export * as offsetCommitV1 from "./offset-commit-v1.js";
+export * as offsetCommitV2 from "./offset-commit-v2.js";
 export * as offsetCommitV8 from "./offset-commit-v8.js";
 export * as offsetCommitV9 from "./offset-commit-v9.js";
+export * as offsetCommitV3 from "./offset-commit-v3.js";
+export * as offsetCommitV4 from "./offset-commit-v4.js";
+export * as offsetCommitV5 from "./offset-commit-v5.js";
+export * as offsetCommitV6 from "./offset-commit-v6.js";
+export * as offsetCommitV7 from "./offset-commit-v7.js";
+export * as offsetFetchV0 from "./offset-fetch-v0.js";
+export * as offsetFetchV1 from "./offset-fetch-v1.js";
+export * as offsetFetchV2 from "./offset-fetch-v2.js";
+export * as offsetFetchV3 from "./offset-fetch-v3.js";
+export * as offsetFetchV4 from "./offset-fetch-v4.js";
+export * as offsetFetchV5 from "./offset-fetch-v5.js";
+export * as offsetFetchV6 from "./offset-fetch-v6.js";
+export * as offsetFetchV7 from "./offset-fetch-v7.js";
 export * as offsetFetchV8 from "./offset-fetch-v8.js";
 export * as offsetFetchV9 from "./offset-fetch-v9.js";
+export * as offsetForLeaderEpochV0 from "./offset-for-leader-epoch-v0.js";
+export * as offsetForLeaderEpochV1 from "./offset-for-leader-epoch-v1.js";
+export * as offsetForLeaderEpochV2 from "./offset-for-leader-epoch-v2.js";
+export * as offsetForLeaderEpochV3 from "./offset-for-leader-epoch-v3.js";
 export * as offsetForLeaderEpochV4 from "./offset-for-leader-epoch-v4.js";
+export * as syncGroupV0 from "./sync-group-v0.js";
+export * as syncGroupV1 from "./sync-group-v1.js";
+export * as syncGroupV2 from "./sync-group-v2.js";
+export * as syncGroupV3 from "./sync-group-v3.js";
 export * as syncGroupV4 from "./sync-group-v4.js";
 export * as syncGroupV5 from "./sync-group-v5.js";

package/dist/apis/consumer/join-group-v0.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: null;
+    metadata: Buffer;
+}
+export interface JoinGroupResponse {
+    throttleTimeMs: number;
+    errorCode: number;
+    generationId: number;
+    protocolType: NullableString;
+    protocolName: NullableString;
+    leader: string;
+    skipAssignment: boolean;
+    memberId: string;
+    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>;