@platformatic/kafka 2.8.0 → 2.9.0-alpha.1

package/dist/apis/producer/produce-v3.js

@@ -0,0 +1,88 @@
+import { ResponseError } from "../../errors.js";
+import { createRecordsBatch } from "../../protocol/records.js";
+import { Writer } from "../../protocol/writer.js";
+import { groupByProperty } from "../../utils.js";
+import { createAPI } from "../definitions.js";
+import { ProduceAcks } from "../enumerations.js";
+/*
+  Produce Request (Version: 3) => transactional_id acks timeout_ms [topic_data]
+    transactional_id => NULLABLE_STRING
+    acks => INT16
+    timeout_ms => INT32
+    topic_data => name [partition_data]
+      name => STRING
+      partition_data => index records
+        index => INT32
+        records => RECORDS
+*/
+export function createRequest(acks = 1, timeout = 0, topicData, options = {}) {
+    // Normalize the messages
+    const now = BigInt(Date.now());
+    for (const message of topicData) {
+        if (typeof message.partition === 'undefined') {
+            message.partition = 0;
+        }
+        if (typeof message.timestamp === 'undefined') {
+            message.timestamp = now;
+        }
+    }
+    const writer = Writer.create()
+        .appendString(options.transactionalId, false)
+        .appendInt16(acks)
+        .appendInt32(timeout)
+        .appendArray(groupByProperty(topicData, 'topic'), (w, [topic, messages]) => {
+        w.appendString(topic, false).appendArray(groupByProperty(messages, 'partition'), (w, [partition, messages]) => {
+            const records = createRecordsBatch(messages, options);
+            w.appendInt32(partition).appendInt32(records.length).appendFrom(records);
+        }, false, false);
+    }, false, false);
+    if (acks === ProduceAcks.NO_RESPONSE) {
+        writer.context.noResponse = true;
+    }
+    return writer;
+}
+/*
+  Produce Response (Version: 3) => [responses] throttle_time_ms
+    responses => name [partition_responses]
+      name => STRING
+      partition_responses => index error_code base_offset log_append_time_ms
+        index => INT32
+        error_code => INT16
+        base_offset => INT64
+        log_append_time_ms => INT64
+    throttle_time_ms => INT32
+*/
+export function parseResponse(_correlationId, apiKey, apiVersion, reader) {
+    const errors = [];
+    const response = {
+        responses: reader.readArray((r, i) => {
+            const topicResponse = {
+                name: r.readString(false),
+                partitionResponses: r.readArray((r, j) => {
+                    const index = r.readInt32();
+                    const errorCode = r.readInt16();
+                    if (errorCode !== 0) {
+                        errors.push([`/responses/${i}/partition_responses/${j}`, [errorCode, null]]);
+                    }
+                    return {
+                        index,
+                        errorCode,
+                        baseOffset: r.readInt64(),
+                        logAppendTimeMs: r.readInt64(),
+                        logStartOffset: -1n,
+                        // These fields were introduced in Produce v8; retain the producer's current response API.
+                        recordErrors: [],
+                        errorMessage: null
+                    };
+                }, false, false)
+            };
+            return topicResponse;
+        }, false, false),
+        throttleTimeMs: reader.readInt32()
+    };
+    if (errors.length) {
+        throw new ResponseError(apiKey, apiVersion, Object.fromEntries(errors), response);
+    }
+    return response;
+}
+export const api = createAPI(0, 3, createRequest, parseResponse, false, false);

package/dist/apis/producer/produce-v4.d.ts

@@ -0,0 +1,29 @@
+import { type NullableString } from '../../protocol/definitions.ts';
+import { type Reader } from '../../protocol/reader.ts';
+import { type CreateRecordsBatchOptions, type MessageRecord } from '../../protocol/records.ts';
+import { Writer } from '../../protocol/writer.ts';
+export type ProduceRequest = Parameters<typeof createRequest>;
+export interface ProduceResponsePartitionRecordError {
+    batchIndex: number;
+    batchIndexErrorMessage: NullableString;
+}
+export interface ProduceResponsePartition {
+    index: number;
+    errorCode: number;
+    baseOffset: bigint;
+    logAppendTimeMs: bigint;
+    logStartOffset: bigint;
+    recordErrors: ProduceResponsePartitionRecordError[];
+    errorMessage: NullableString;
+}
+export interface ProduceResponseTopic {
+    name: string;
+    partitionResponses: ProduceResponsePartition[];
+}
+export interface ProduceResponse {
+    responses: ProduceResponseTopic[];
+    throttleTimeMs: number;
+}
+export declare function createRequest(acks: number | undefined, timeout: number | undefined, topicData: MessageRecord[], options?: Partial<CreateRecordsBatchOptions>): Writer;
+export declare function parseResponse(_correlationId: number, apiKey: number, apiVersion: number, reader: Reader): ProduceResponse;
+export declare const api: import("../definitions.ts").API<[acks: number | undefined, timeout: number | undefined, topicData: MessageRecord[], options?: Partial<CreateRecordsBatchOptions> | undefined], boolean | ProduceResponse>;

package/dist/apis/producer/produce-v4.js

@@ -0,0 +1,88 @@
+import { ResponseError } from "../../errors.js";
+import { createRecordsBatch } from "../../protocol/records.js";
+import { Writer } from "../../protocol/writer.js";
+import { groupByProperty } from "../../utils.js";
+import { createAPI } from "../definitions.js";
+import { ProduceAcks } from "../enumerations.js";
+/*
+  Produce Request (Version: 4) => transactional_id acks timeout_ms [topic_data]
+    transactional_id => NULLABLE_STRING
+    acks => INT16
+    timeout_ms => INT32
+    topic_data => name [partition_data]
+      name => STRING
+      partition_data => index records
+        index => INT32
+        records => RECORDS
+*/
+export function createRequest(acks = 1, timeout = 0, topicData, options = {}) {
+    // Normalize the messages
+    const now = BigInt(Date.now());
+    for (const message of topicData) {
+        if (typeof message.partition === 'undefined') {
+            message.partition = 0;
+        }
+        if (typeof message.timestamp === 'undefined') {
+            message.timestamp = now;
+        }
+    }
+    const writer = Writer.create()
+        .appendString(options.transactionalId, false)
+        .appendInt16(acks)
+        .appendInt32(timeout)
+        .appendArray(groupByProperty(topicData, 'topic'), (w, [topic, messages]) => {
+        w.appendString(topic, false).appendArray(groupByProperty(messages, 'partition'), (w, [partition, messages]) => {
+            const records = createRecordsBatch(messages, options);
+            w.appendInt32(partition).appendInt32(records.length).appendFrom(records);
+        }, false, false);
+    }, false, false);
+    if (acks === ProduceAcks.NO_RESPONSE) {
+        writer.context.noResponse = true;
+    }
+    return writer;
+}
+/*
+  Produce Response (Version: 4) => [responses] throttle_time_ms
+    responses => name [partition_responses]
+      name => STRING
+      partition_responses => index error_code base_offset log_append_time_ms
+        index => INT32
+        error_code => INT16
+        base_offset => INT64
+        log_append_time_ms => INT64
+    throttle_time_ms => INT32
+*/
+export function parseResponse(_correlationId, apiKey, apiVersion, reader) {
+    const errors = [];
+    const response = {
+        responses: reader.readArray((r, i) => {
+            const topicResponse = {
+                name: r.readString(false),
+                partitionResponses: r.readArray((r, j) => {
+                    const index = r.readInt32();
+                    const errorCode = r.readInt16();
+                    if (errorCode !== 0) {
+                        errors.push([`/responses/${i}/partition_responses/${j}`, [errorCode, null]]);
+                    }
+                    return {
+                        index,
+                        errorCode,
+                        baseOffset: r.readInt64(),
+                        logAppendTimeMs: r.readInt64(),
+                        logStartOffset: -1n,
+                        // These fields were introduced in Produce v8; retain the producer's current response API.
+                        recordErrors: [],
+                        errorMessage: null
+                    };
+                }, false, false)
+            };
+            return topicResponse;
+        }, false, false),
+        throttleTimeMs: reader.readInt32()
+    };
+    if (errors.length) {
+        throw new ResponseError(apiKey, apiVersion, Object.fromEntries(errors), response);
+    }
+    return response;
+}
+export const api = createAPI(0, 4, createRequest, parseResponse, false, false);

package/dist/apis/producer/produce-v5.d.ts

@@ -0,0 +1,29 @@
+import { type NullableString } from '../../protocol/definitions.ts';
+import { type Reader } from '../../protocol/reader.ts';
+import { type CreateRecordsBatchOptions, type MessageRecord } from '../../protocol/records.ts';
+import { Writer } from '../../protocol/writer.ts';
+export type ProduceRequest = Parameters<typeof createRequest>;
+export interface ProduceResponsePartitionRecordError {
+    batchIndex: number;
+    batchIndexErrorMessage: NullableString;
+}
+export interface ProduceResponsePartition {
+    index: number;
+    errorCode: number;
+    baseOffset: bigint;
+    logAppendTimeMs: bigint;
+    logStartOffset: bigint;
+    recordErrors: ProduceResponsePartitionRecordError[];
+    errorMessage: NullableString;
+}
+export interface ProduceResponseTopic {
+    name: string;
+    partitionResponses: ProduceResponsePartition[];
+}
+export interface ProduceResponse {
+    responses: ProduceResponseTopic[];
+    throttleTimeMs: number;
+}
+export declare function createRequest(acks: number | undefined, timeout: number | undefined, topicData: MessageRecord[], options?: Partial<CreateRecordsBatchOptions>): Writer;
+export declare function parseResponse(_correlationId: number, apiKey: number, apiVersion: number, reader: Reader): ProduceResponse;
+export declare const api: import("../definitions.ts").API<[acks: number | undefined, timeout: number | undefined, topicData: MessageRecord[], options?: Partial<CreateRecordsBatchOptions> | undefined], boolean | ProduceResponse>;

package/dist/apis/producer/produce-v5.js

@@ -0,0 +1,88 @@
+import { ResponseError } from "../../errors.js";
+import { createRecordsBatch } from "../../protocol/records.js";
+import { Writer } from "../../protocol/writer.js";
+import { groupByProperty } from "../../utils.js";
+import { createAPI } from "../definitions.js";
+import { ProduceAcks } from "../enumerations.js";
+/*
+  Produce Request (Version: 5) => transactional_id acks timeout_ms [topic_data]
+    transactional_id => NULLABLE_STRING
+    acks => INT16
+    timeout_ms => INT32
+    topic_data => name [partition_data]
+      name => STRING
+      partition_data => index records
+        index => INT32
+        records => RECORDS
+*/
+export function createRequest(acks = 1, timeout = 0, topicData, options = {}) {
+    // Normalize the messages
+    const now = BigInt(Date.now());
+    for (const message of topicData) {
+        if (typeof message.partition === 'undefined') {
+            message.partition = 0;
+        }
+        if (typeof message.timestamp === 'undefined') {
+            message.timestamp = now;
+        }
+    }
+    const writer = Writer.create()
+        .appendString(options.transactionalId, false)
+        .appendInt16(acks)
+        .appendInt32(timeout)
+        .appendArray(groupByProperty(topicData, 'topic'), (w, [topic, messages]) => {
+        w.appendString(topic, false).appendArray(groupByProperty(messages, 'partition'), (w, [partition, messages]) => {
+            const records = createRecordsBatch(messages, options);
+            w.appendInt32(partition).appendInt32(records.length).appendFrom(records);
+        }, false, false);
+    }, false, false);
+    if (acks === ProduceAcks.NO_RESPONSE) {
+        writer.context.noResponse = true;
+    }
+    return writer;
+}
+/*
+  Produce Response (Version: 5) => [responses] throttle_time_ms
+    responses => name [partition_responses]
+      name => STRING
+      partition_responses => index error_code base_offset log_append_time_ms log_start_offset
+        index => INT32
+        error_code => INT16
+        base_offset => INT64
+        log_append_time_ms => INT64
+        log_start_offset => INT64
+    throttle_time_ms => INT32
+*/
+export function parseResponse(_correlationId, apiKey, apiVersion, reader) {
+    const errors = [];
+    const response = {
+        responses: reader.readArray((r, i) => {
+            const topicResponse = {
+                name: r.readString(false),
+                partitionResponses: r.readArray((r, j) => {
+                    const index = r.readInt32();
+                    const errorCode = r.readInt16();
+                    if (errorCode !== 0) {
+                        errors.push([`/responses/${i}/partition_responses/${j}`, [errorCode, null]]);
+                    }
+                    return {
+                        index,
+                        errorCode,
+                        baseOffset: r.readInt64(),
+                        logAppendTimeMs: r.readInt64(),
+                        logStartOffset: r.readInt64(),
+                        recordErrors: [],
+                        errorMessage: null
+                    };
+                }, false, false)
+            };
+            return topicResponse;
+        }, false, false),
+        throttleTimeMs: reader.readInt32()
+    };
+    if (errors.length) {
+        throw new ResponseError(apiKey, apiVersion, Object.fromEntries(errors), response);
+    }
+    return response;
+}
+export const api = createAPI(0, 5, createRequest, parseResponse, false, false);

package/dist/apis/producer/produce-v6.d.ts

@@ -0,0 +1,29 @@
+import { type NullableString } from '../../protocol/definitions.ts';
+import { type Reader } from '../../protocol/reader.ts';
+import { type CreateRecordsBatchOptions, type MessageRecord } from '../../protocol/records.ts';
+import { Writer } from '../../protocol/writer.ts';
+export type ProduceRequest = Parameters<typeof createRequest>;
+export interface ProduceResponsePartitionRecordError {
+    batchIndex: number;
+    batchIndexErrorMessage: NullableString;
+}
+export interface ProduceResponsePartition {
+    index: number;
+    errorCode: number;
+    baseOffset: bigint;
+    logAppendTimeMs: bigint;
+    logStartOffset: bigint;
+    recordErrors: ProduceResponsePartitionRecordError[];
+    errorMessage: NullableString;
+}
+export interface ProduceResponseTopic {
+    name: string;
+    partitionResponses: ProduceResponsePartition[];
+}
+export interface ProduceResponse {
+    responses: ProduceResponseTopic[];
+    throttleTimeMs: number;
+}
+export declare function createRequest(acks: number | undefined, timeout: number | undefined, topicData: MessageRecord[], options?: Partial<CreateRecordsBatchOptions>): Writer;
+export declare function parseResponse(_correlationId: number, apiKey: number, apiVersion: number, reader: Reader): ProduceResponse;
+export declare const api: import("../definitions.ts").API<[acks: number | undefined, timeout: number | undefined, topicData: MessageRecord[], options?: Partial<CreateRecordsBatchOptions> | undefined], boolean | ProduceResponse>;

package/dist/apis/producer/produce-v6.js

@@ -0,0 +1,88 @@
+import { ResponseError } from "../../errors.js";
+import { createRecordsBatch } from "../../protocol/records.js";
+import { Writer } from "../../protocol/writer.js";
+import { groupByProperty } from "../../utils.js";
+import { createAPI } from "../definitions.js";
+import { ProduceAcks } from "../enumerations.js";
+/*
+  Produce Request (Version: 6) => transactional_id acks timeout_ms [topic_data]
+    transactional_id => NULLABLE_STRING
+    acks => INT16
+    timeout_ms => INT32
+    topic_data => name [partition_data]
+      name => STRING
+      partition_data => index records
+        index => INT32
+        records => RECORDS
+*/
+export function createRequest(acks = 1, timeout = 0, topicData, options = {}) {
+    // Normalize the messages
+    const now = BigInt(Date.now());
+    for (const message of topicData) {
+        if (typeof message.partition === 'undefined') {
+            message.partition = 0;
+        }
+        if (typeof message.timestamp === 'undefined') {
+            message.timestamp = now;
+        }
+    }
+    const writer = Writer.create()
+        .appendString(options.transactionalId, false)
+        .appendInt16(acks)
+        .appendInt32(timeout)
+        .appendArray(groupByProperty(topicData, 'topic'), (w, [topic, messages]) => {
+        w.appendString(topic, false).appendArray(groupByProperty(messages, 'partition'), (w, [partition, messages]) => {
+            const records = createRecordsBatch(messages, options);
+            w.appendInt32(partition).appendInt32(records.length).appendFrom(records);
+        }, false, false);
+    }, false, false);
+    if (acks === ProduceAcks.NO_RESPONSE) {
+        writer.context.noResponse = true;
+    }
+    return writer;
+}
+/*
+  Produce Response (Version: 6) => [responses] throttle_time_ms
+    responses => name [partition_responses]
+      name => STRING
+      partition_responses => index error_code base_offset log_append_time_ms log_start_offset
+        index => INT32
+        error_code => INT16
+        base_offset => INT64
+        log_append_time_ms => INT64
+        log_start_offset => INT64
+    throttle_time_ms => INT32
+*/
+export function parseResponse(_correlationId, apiKey, apiVersion, reader) {
+    const errors = [];
+    const response = {
+        responses: reader.readArray((r, i) => {
+            const topicResponse = {
+                name: r.readString(false),
+                partitionResponses: r.readArray((r, j) => {
+                    const index = r.readInt32();
+                    const errorCode = r.readInt16();
+                    if (errorCode !== 0) {
+                        errors.push([`/responses/${i}/partition_responses/${j}`, [errorCode, null]]);
+                    }
+                    return {
+                        index,
+                        errorCode,
+                        baseOffset: r.readInt64(),
+                        logAppendTimeMs: r.readInt64(),
+                        logStartOffset: r.readInt64(),
+                        recordErrors: [],
+                        errorMessage: null
+                    };
+                }, false, false)
+            };
+            return topicResponse;
+        }, false, false),
+        throttleTimeMs: reader.readInt32()
+    };
+    if (errors.length) {
+        throw new ResponseError(apiKey, apiVersion, Object.fromEntries(errors), response);
+    }
+    return response;
+}
+export const api = createAPI(0, 6, createRequest, parseResponse, false, false);

package/dist/apis/producer/produce-v7.js

@@ -45,7 +45,7 @@ export function createRequest(acks = 1, timeout = 0, topicData, options = {}) {
   Produce Response (Version: 7) => [responses] throttle_time_ms
     responses => name [partition_responses]
       name => STRING
-      partition_responses => index error_code base_offset log_append_time_ms log_start_offset [record_errors] error_message
+      partition_responses => index error_code base_offset log_append_time_ms log_start_offset
         index => INT32
         error_code => INT16
         base_offset => INT64

package/dist/apis/producer/produce-v9.js

@@ -78,6 +78,7 @@ export function parseResponse(_correlationId, apiKey, apiVersion, reader) {
                                 batchIndex: r.readInt32(),
                                 batchIndexErrorMessage: r.readNullableString()
                             };
+                            r.readTaggedFields();
                             if (recordError.batchIndexErrorMessage) {
                                 errors.push([
                                     `/responses/${i}/partition_responses/${j}/record_errors/${k}`,
@@ -85,9 +86,10 @@ export function parseResponse(_correlationId, apiKey, apiVersion, reader) {
                                 ]);
                             }
                             return recordError;
-                        }),
+                        }, true, false),
                         errorMessage: r.readNullableString()
                     };
+                    r.readTaggedFields();
                     if (partitionResponse.errorCode !== 0) {
                         errors.push([
                             `/responses/${i}/partition_responses/${j}`,
@@ -95,12 +97,14 @@ export function parseResponse(_correlationId, apiKey, apiVersion, reader) {
                         ]);
                     }
                     return partitionResponse;
-                })
+                }, true, false)
             };
+            r.readTaggedFields();
             return topicResponse;
-        }),
+        }, true, false),
         throttleTimeMs: reader.readInt32()
     };
+    reader.readTaggedFields();
     if (errors.length) {
         throw new ResponseError(apiKey, apiVersion, Object.fromEntries(errors), response);
     }

package/dist/apis/producer/txn-offset-commit-v0.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 TxnOffsetCommitRequestPartition {
+    partitionIndex: number;
+    committedOffset: bigint;
+    committedLeaderEpoch: number;
+    committedMetadata?: NullableString;
+}
+export interface TxnOffsetCommitRequestTopic {
+    name: string;
+    partitions: TxnOffsetCommitRequestPartition[];
+}
+export type TxnOffsetCommitRequest = Parameters<typeof createRequest>;
+export interface TxnOffsetCommitResponsePartition {
+    partitionIndex: number;
+    errorCode: number;
+}
+export interface TxnOffsetCommitResponseTopic {
+    name: string;
+    partitions: TxnOffsetCommitResponsePartition[];
+}
+export interface TxnOffsetCommitResponse {
+    throttleTimeMs: number;
+    topics: TxnOffsetCommitResponseTopic[];
+}
+export declare function createRequest(transactionalId: string, groupId: string, producerId: bigint, producerEpoch: number, _generationId: number, _memberId: string, _groupInstanceId: NullableString, topics: TxnOffsetCommitRequestTopic[]): Writer;
+export declare function parseResponse(_correlationId: number, apiKey: number, apiVersion: number, reader: Reader): TxnOffsetCommitResponse;
+export declare const api: import("../definitions.ts").API<[transactionalId: string, groupId: string, producerId: bigint, producerEpoch: number, _generationId: number, _memberId: string, _groupInstanceId: NullableString, topics: TxnOffsetCommitRequestTopic[]], TxnOffsetCommitResponse>;

package/dist/apis/producer/txn-offset-commit-v0.js

@@ -0,0 +1,60 @@
+import { ResponseError } from "../../errors.js";
+import { Writer } from "../../protocol/writer.js";
+import { createAPI } from "../definitions.js";
+/*
+  TxnOffsetCommit Request (Version: 0) => transactional_id group_id producer_id producer_epoch [topics]
+    transactional_id => STRING
+    group_id => STRING
+    producer_id => INT64
+    producer_epoch => INT16
+    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(transactionalId, groupId, producerId, producerEpoch, _generationId, _memberId, _groupInstanceId, topics) {
+    return Writer.create()
+        .appendString(transactionalId, false)
+        .appendString(groupId, false)
+        .appendInt64(producerId)
+        .appendInt16(producerEpoch)
+        .appendArray(topics, (w, topic) => {
+        w.appendString(topic.name, false).appendArray(topic.partitions, (w, partition) => {
+            w.appendInt32(partition.partitionIndex)
+                .appendInt64(partition.committedOffset)
+                .appendString(partition.committedMetadata, false);
+        }, false, false);
+    }, false, false);
+}
+/*
+  TxnOffsetCommit Response (Version: 0) => 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, topicIndex) => ({
+            name: r.readString(false),
+            partitions: r.readArray((r, partitionIndex) => {
+                const partition = { partitionIndex: r.readInt32(), errorCode: r.readInt16() };
+                if (partition.errorCode !== 0) {
+                    errors.push([`/topics/${topicIndex}/partitions/${partitionIndex}`, [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(28, 0, createRequest, parseResponse, false, false);

package/dist/apis/producer/txn-offset-commit-v1.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 TxnOffsetCommitRequestPartition {
+    partitionIndex: number;
+    committedOffset: bigint;
+    committedLeaderEpoch: number;
+    committedMetadata?: NullableString;
+}
+export interface TxnOffsetCommitRequestTopic {
+    name: string;
+    partitions: TxnOffsetCommitRequestPartition[];
+}
+export type TxnOffsetCommitRequest = Parameters<typeof createRequest>;
+export interface TxnOffsetCommitResponsePartition {
+    partitionIndex: number;
+    errorCode: number;
+}
+export interface TxnOffsetCommitResponseTopic {
+    name: string;
+    partitions: TxnOffsetCommitResponsePartition[];
+}
+export interface TxnOffsetCommitResponse {
+    throttleTimeMs: number;
+    topics: TxnOffsetCommitResponseTopic[];
+}
+export declare function createRequest(transactionalId: string, groupId: string, producerId: bigint, producerEpoch: number, _generationId: number, _memberId: string, _groupInstanceId: NullableString, topics: TxnOffsetCommitRequestTopic[]): Writer;
+export declare function parseResponse(_correlationId: number, apiKey: number, apiVersion: number, reader: Reader): TxnOffsetCommitResponse;
+export declare const api: import("../definitions.ts").API<[transactionalId: string, groupId: string, producerId: bigint, producerEpoch: number, _generationId: number, _memberId: string, _groupInstanceId: NullableString, topics: TxnOffsetCommitRequestTopic[]], TxnOffsetCommitResponse>;

package/dist/apis/producer/txn-offset-commit-v1.js

@@ -0,0 +1,60 @@
+import { ResponseError } from "../../errors.js";
+import { Writer } from "../../protocol/writer.js";
+import { createAPI } from "../definitions.js";
+/*
+  TxnOffsetCommit Request (Version: 1) => transactional_id group_id producer_id producer_epoch [topics]
+    transactional_id => STRING
+    group_id => STRING
+    producer_id => INT64
+    producer_epoch => INT16
+    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(transactionalId, groupId, producerId, producerEpoch, _generationId, _memberId, _groupInstanceId, topics) {
+    return Writer.create()
+        .appendString(transactionalId, false)
+        .appendString(groupId, false)
+        .appendInt64(producerId)
+        .appendInt16(producerEpoch)
+        .appendArray(topics, (w, topic) => {
+        w.appendString(topic.name, false).appendArray(topic.partitions, (w, partition) => {
+            w.appendInt32(partition.partitionIndex)
+                .appendInt64(partition.committedOffset)
+                .appendString(partition.committedMetadata, false);
+        }, false, false);
+    }, false, false);
+}
+/*
+  TxnOffsetCommit Response (Version: 1) => 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, topicIndex) => ({
+            name: r.readString(false),
+            partitions: r.readArray((r, partitionIndex) => {
+                const partition = { partitionIndex: r.readInt32(), errorCode: r.readInt16() };
+                if (partition.errorCode !== 0) {
+                    errors.push([`/topics/${topicIndex}/partitions/${partitionIndex}`, [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(28, 1, createRequest, parseResponse, false, false);