@platformatic/kafka 2.7.0 → 2.9.0-alpha.1

package/dist/apis/admin/list-partition-reassignments-v0.d.ts

@@ -1,4 +1,4 @@
-import { type NullableString } from '../../protocol/definitions.ts';
+import { type Nullable, type NullableString } from '../../protocol/definitions.ts';
 import { type Reader } from '../../protocol/reader.ts';
 import { Writer } from '../../protocol/writer.ts';
 export interface ListPartitionReassignmentsRequestTopic {
@@ -22,6 +22,6 @@ export interface ListPartitionReassignmentsResponse {
     errorMessage: NullableString;
     topics: ListPartitionReassignmentsResponseTopic[];
 }
-export declare function createRequest(timeoutMs: number, topics: ListPartitionReassignmentsRequestTopic[]): Writer;
+export declare function createRequest(timeoutMs: number, topics: Nullable<ListPartitionReassignmentsRequestTopic[]>): Writer;
 export declare function parseResponse(_correlationId: number, apiKey: number, apiVersion: number, reader: Reader): ListPartitionReassignmentsResponse;
-export declare const api: import("../definitions.ts").API<[timeoutMs: number, topics: ListPartitionReassignmentsRequestTopic[]], ListPartitionReassignmentsResponse>;
+export declare const api: import("../definitions.ts").API<[timeoutMs: number, topics: Nullable<ListPartitionReassignmentsRequestTopic[]>], ListPartitionReassignmentsResponse>;

package/dist/apis/admin/list-partition-reassignments-v0.js

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

package/dist/apis/admin/list-transactions-v0.d.ts

@@ -1,7 +1,9 @@
 import { type NullableString } from '../../protocol/definitions.ts';
 import { type Reader } from '../../protocol/reader.ts';
 import { Writer } from '../../protocol/writer.ts';
-import { type TransactionState } from '../enumerations.ts';
+export declare const TransactionStates: readonly ["EMPTY", "ONGOING", "PREPARE_ABORT", "COMMITTING", "ABORTING", "COMPLETE_COMMIT", "COMPLETE_ABORT"];
+export type KafkaTransactionState = 'Empty' | 'Ongoing' | 'PrepareCommit' | 'PrepareAbort' | 'CompleteCommit' | 'CompleteAbort' | 'Dead' | 'PrepareEpochFence';
+export type TransactionState = (typeof TransactionStates)[number] | KafkaTransactionState;
 export type ListTransactionsRequest = Parameters<typeof createRequest>;
 export interface ListTransactionsResponseTransactionState {
     transactionalId: string;
@@ -14,6 +16,6 @@ export interface ListTransactionsResponse {
     unknownStateFilters: string[];
     transactionStates: ListTransactionsResponseTransactionState[];
 }
-export declare function createRequest(stateFilters: TransactionState[], producerIdFilters: bigint[], _durationFilter: bigint, _transactionalIdPattern: NullableString): Writer;
+export declare function createRequest(stateFilters: Array<TransactionState | KafkaTransactionState>, producerIdFilters: bigint[], _durationFilter: bigint, _transactionalIdPattern: NullableString): Writer;
 export declare function parseResponse(_correlationId: number, apiKey: number, apiVersion: number, reader: Reader): ListTransactionsResponse;
-export declare const api: import("../definitions.ts").API<[stateFilters: ("EMPTY" | "ONGOING" | "PREPARE_ABORT" | "COMMITTING" | "ABORTING" | "COMPLETE_COMMIT" | "COMPLETE_ABORT")[], producerIdFilters: bigint[], _durationFilter: bigint, _transactionalIdPattern: NullableString], ListTransactionsResponse>;
+export declare const api: import("../definitions.ts").API<[stateFilters: ("Dead" | "Empty" | "EMPTY" | "ONGOING" | "PREPARE_ABORT" | "COMMITTING" | "ABORTING" | "COMPLETE_COMMIT" | "COMPLETE_ABORT" | "Ongoing" | "PrepareCommit" | "PrepareAbort" | "CompleteCommit" | "CompleteAbort" | "PrepareEpochFence")[], producerIdFilters: bigint[], _durationFilter: bigint, _transactionalIdPattern: NullableString], ListTransactionsResponse>;

package/dist/apis/admin/list-transactions-v0.js

@@ -1,6 +1,15 @@
 import { ResponseError } from "../../errors.js";
 import { Writer } from "../../protocol/writer.js";
 import { createAPI } from "../definitions.js";
+export const TransactionStates = [
+    'EMPTY',
+    'ONGOING',
+    'PREPARE_ABORT',
+    'COMMITTING',
+    'ABORTING',
+    'COMPLETE_COMMIT',
+    'COMPLETE_ABORT'
+];
 /*
   ListTransactions Request (Version: 0) => [state_filters] [producer_id_filters] TAG_BUFFER
     state_filters => COMPACT_STRING
@@ -8,7 +17,7 @@ import { createAPI } from "../definitions.js";
 */
 export function createRequest(stateFilters, producerIdFilters, _durationFilter, _transactionalIdPattern) {
     return Writer.create()
-        .appendArray(stateFilters, (w, t) => w.appendString(t), true, false)
+        .appendArray(stateFilters, (w, state) => w.appendString(normalizeState(state)), true, false)
         .appendArray(producerIdFilters, (w, p) => w.appendInt64(p), true, false)
         .appendTaggedFields();
 }
@@ -35,9 +44,22 @@ export function parseResponse(_correlationId, apiKey, apiVersion, reader) {
             };
         })
     };
+    reader.readTaggedFields();
     if (response.errorCode !== 0) {
         throw new ResponseError(apiKey, apiVersion, { '/': [response.errorCode, null] }, response);
     }
     return response;
 }
+function normalizeState(state) {
+    switch (state) {
+        case 'EMPTY': return 'Empty';
+        case 'ONGOING': return 'Ongoing';
+        case 'PREPARE_ABORT': return 'PrepareAbort';
+        case 'COMMITTING': return 'PrepareCommit';
+        case 'ABORTING': return 'PrepareAbort';
+        case 'COMPLETE_COMMIT': return 'CompleteCommit';
+        case 'COMPLETE_ABORT': return 'CompleteAbort';
+        default: return state;
+    }
+}
 export const api = createAPI(66, 0, createRequest, parseResponse);

package/dist/apis/admin/list-transactions-v1.d.ts

@@ -1,7 +1,9 @@
 import { type NullableString } from '../../protocol/definitions.ts';
 import { type Reader } from '../../protocol/reader.ts';
 import { Writer } from '../../protocol/writer.ts';
-import { type TransactionState } from '../enumerations.ts';
+import { type KafkaTransactionState, type TransactionState } from './list-transactions-v0.ts';
+export { TransactionStates } from './list-transactions-v0.ts';
+export type { TransactionState } from './list-transactions-v0.ts';
 export type ListTransactionsRequest = Parameters<typeof createRequest>;
 export interface ListTransactionsResponseTransactionState {
     transactionalId: string;
@@ -14,6 +16,6 @@ export interface ListTransactionsResponse {
     unknownStateFilters: string[];
     transactionStates: ListTransactionsResponseTransactionState[];
 }
-export declare function createRequest(stateFilters: TransactionState[], producerIdFilters: bigint[], durationFilter: bigint, _transactionalIdPattern: NullableString): Writer;
+export declare function createRequest(stateFilters: Array<TransactionState | KafkaTransactionState>, producerIdFilters: bigint[], durationFilter: bigint, _transactionalIdPattern: NullableString): Writer;
 export declare function parseResponse(_correlationId: number, apiKey: number, apiVersion: number, reader: Reader): ListTransactionsResponse;
-export declare const api: import("../definitions.ts").API<[stateFilters: ("EMPTY" | "ONGOING" | "PREPARE_ABORT" | "COMMITTING" | "ABORTING" | "COMPLETE_COMMIT" | "COMPLETE_ABORT")[], producerIdFilters: bigint[], durationFilter: bigint, _transactionalIdPattern: NullableString], ListTransactionsResponse>;
+export declare const api: import("../definitions.ts").API<[stateFilters: ("Dead" | "Empty" | "EMPTY" | "ONGOING" | "PREPARE_ABORT" | "COMMITTING" | "ABORTING" | "COMPLETE_COMMIT" | "COMPLETE_ABORT" | "Ongoing" | "PrepareCommit" | "PrepareAbort" | "CompleteCommit" | "CompleteAbort" | "PrepareEpochFence")[], producerIdFilters: bigint[], durationFilter: bigint, _transactionalIdPattern: NullableString], ListTransactionsResponse>;

package/dist/apis/admin/list-transactions-v1.js

@@ -1,6 +1,7 @@
 import { ResponseError } from "../../errors.js";
 import { Writer } from "../../protocol/writer.js";
 import { createAPI } from "../definitions.js";
+export { TransactionStates } from "./list-transactions-v0.js";
 /*
   ListTransactions Request (Version: 1) => [state_filters] [producer_id_filters] duration_filter TAG_BUFFER
     state_filters => COMPACT_STRING
@@ -9,7 +10,7 @@ import { createAPI } from "../definitions.js";
 */
 export function createRequest(stateFilters, producerIdFilters, durationFilter, _transactionalIdPattern) {
     return Writer.create()
-        .appendArray(stateFilters, (w, t) => w.appendString(t), true, false)
+        .appendArray(stateFilters, (w, state) => w.appendString(normalizeState(state)), true, false)
         .appendArray(producerIdFilters, (w, p) => w.appendInt64(p), true, false)
         .appendInt64(durationFilter)
         .appendTaggedFields();
@@ -37,9 +38,22 @@ export function parseResponse(_correlationId, apiKey, apiVersion, reader) {
             };
         })
     };
+    reader.readTaggedFields();
     if (response.errorCode !== 0) {
         throw new ResponseError(apiKey, apiVersion, { '/': [response.errorCode, null] }, response);
     }
     return response;
 }
+function normalizeState(state) {
+    switch (state) {
+        case 'EMPTY': return 'Empty';
+        case 'ONGOING': return 'Ongoing';
+        case 'PREPARE_ABORT': return 'PrepareAbort';
+        case 'COMMITTING': return 'PrepareCommit';
+        case 'ABORTING': return 'PrepareAbort';
+        case 'COMPLETE_COMMIT': return 'CompleteCommit';
+        case 'COMPLETE_ABORT': return 'CompleteAbort';
+        default: return state;
+    }
+}
 export const api = createAPI(66, 1, createRequest, parseResponse);

package/dist/apis/admin/list-transactions-v2.d.ts

@@ -1,7 +1,9 @@
 import { type NullableString } from '../../protocol/definitions.ts';
 import { type Reader } from '../../protocol/reader.ts';
 import { Writer } from '../../protocol/writer.ts';
-import { type TransactionState } from '../enumerations.ts';
+import { type KafkaTransactionState, type TransactionState } from './list-transactions-v0.ts';
+export { TransactionStates } from './list-transactions-v0.ts';
+export type { TransactionState } from './list-transactions-v0.ts';
 export type ListTransactionsRequest = Parameters<typeof createRequest>;
 export interface ListTransactionsResponseTransactionState {
     transactionalId: string;
@@ -11,10 +13,9 @@ export interface ListTransactionsResponseTransactionState {
 export interface ListTransactionsResponse {
     throttleTimeMs: number;
     errorCode: number;
-    errorMessage: NullableString;
     unknownStateFilters: string[];
     transactionStates: ListTransactionsResponseTransactionState[];
 }
-export declare function createRequest(stateFilters: TransactionState[], producerIdFilters: bigint[], durationFilter: bigint, transactionalIdPattern: NullableString): Writer;
+export declare function createRequest(stateFilters: Array<TransactionState | KafkaTransactionState>, producerIdFilters: bigint[], durationFilter: bigint, transactionalIdPattern: NullableString): Writer;
 export declare function parseResponse(_correlationId: number, apiKey: number, apiVersion: number, reader: Reader): ListTransactionsResponse;
-export declare const api: import("../definitions.ts").API<[stateFilters: ("EMPTY" | "ONGOING" | "PREPARE_ABORT" | "COMMITTING" | "ABORTING" | "COMPLETE_COMMIT" | "COMPLETE_ABORT")[], producerIdFilters: bigint[], durationFilter: bigint, transactionalIdPattern: NullableString], ListTransactionsResponse>;
+export declare const api: import("../definitions.ts").API<[stateFilters: ("Dead" | "Empty" | "EMPTY" | "ONGOING" | "PREPARE_ABORT" | "COMMITTING" | "ABORTING" | "COMPLETE_COMMIT" | "COMPLETE_ABORT" | "Ongoing" | "PrepareCommit" | "PrepareAbort" | "CompleteCommit" | "CompleteAbort" | "PrepareEpochFence")[], producerIdFilters: bigint[], durationFilter: bigint, transactionalIdPattern: NullableString], ListTransactionsResponse>;

package/dist/apis/admin/list-transactions-v2.js

@@ -1,6 +1,7 @@
 import { ResponseError } from "../../errors.js";
 import { Writer } from "../../protocol/writer.js";
 import { createAPI } from "../definitions.js";
+export { TransactionStates } from "./list-transactions-v0.js";
 /*
   ListTransactions Request (Version: 2) => [state_filters] [producer_id_filters] duration_filter transactional_id_pattern TAG_BUFFER
     state_filters => COMPACT_STRING
@@ -10,17 +11,16 @@ import { createAPI } from "../definitions.js";
 */
 export function createRequest(stateFilters, producerIdFilters, durationFilter, transactionalIdPattern) {
     return Writer.create()
-        .appendArray(stateFilters, (w, t) => w.appendString(t), true, false)
+        .appendArray(stateFilters, (w, state) => w.appendString(normalizeState(state)), true, false)
         .appendArray(producerIdFilters, (w, p) => w.appendInt64(p), true, false)
         .appendInt64(durationFilter)
         .appendString(transactionalIdPattern)
         .appendTaggedFields();
 }
 /*
-  ListTransactions Response (Version: 2) => throttle_time_ms error_code error_message [unknown_state_filters] [transaction_states] TAG_BUFFER
+  ListTransactions Response (Version: 2) => throttle_time_ms error_code [unknown_state_filters] [transaction_states] TAG_BUFFER
     throttle_time_ms => INT32
     error_code => INT16
-    error_message => COMPACT_NULLABLE_STRING
     unknown_state_filters => COMPACT_STRING
     transaction_states => transactional_id producer_id transaction_state TAG_BUFFER
       transactional_id => COMPACT_STRING
@@ -31,7 +31,6 @@ export function parseResponse(_correlationId, apiKey, apiVersion, reader) {
     const response = {
         throttleTimeMs: reader.readInt32(),
         errorCode: reader.readInt16(),
-        errorMessage: reader.readNullableString(),
         unknownStateFilters: reader.readArray(r => r.readString(), true, false),
         transactionStates: reader.readArray(r => {
             return {
@@ -41,9 +40,22 @@ export function parseResponse(_correlationId, apiKey, apiVersion, reader) {
             };
         })
     };
+    reader.readTaggedFields();
     if (response.errorCode !== 0) {
-        throw new ResponseError(apiKey, apiVersion, { '/': [response.errorCode, response.errorMessage] }, response);
+        throw new ResponseError(apiKey, apiVersion, { '/': [response.errorCode, null] }, response);
     }
     return response;
 }
+function normalizeState(state) {
+    switch (state) {
+        case 'EMPTY': return 'Empty';
+        case 'ONGOING': return 'Ongoing';
+        case 'PREPARE_ABORT': return 'PrepareAbort';
+        case 'COMMITTING': return 'PrepareCommit';
+        case 'ABORTING': return 'PrepareAbort';
+        case 'COMPLETE_COMMIT': return 'CompleteCommit';
+        case 'COMPLETE_ABORT': return 'CompleteAbort';
+        default: return state;
+    }
+}
 export const api = createAPI(66, 2, createRequest, parseResponse);

package/dist/apis/admin/renew-delegation-token-v0.d.ts

@@ -0,0 +1,11 @@
+import { type Reader } from '../../protocol/reader.ts';
+import { Writer } from '../../protocol/writer.ts';
+export type RenewDelegationTokenRequest = Parameters<typeof createRequest>;
+export interface RenewDelegationTokenResponse {
+    errorCode: number;
+    expiryTimestampMs: bigint;
+    throttleTimeMs: number;
+}
+export declare function createRequest(hmac: Buffer, renewPeriodMs: bigint): Writer;
+export declare function parseResponse(_correlationId: number, apiKey: number, apiVersion: number, reader: Reader): RenewDelegationTokenResponse;
+export declare const api: import("../definitions.ts").API<[hmac: Buffer<ArrayBufferLike>, renewPeriodMs: bigint], RenewDelegationTokenResponse>;

package/dist/apis/admin/renew-delegation-token-v0.js

@@ -0,0 +1,29 @@
+import { ResponseError } from "../../errors.js";
+import { Writer } from "../../protocol/writer.js";
+import { createAPI } from "../definitions.js";
+/*
+  RenewDelegationToken Request (Version: 0) => hmac renew_period_ms
+    hmac => BYTES
+    renew_period_ms => INT64
+*/
+export function createRequest(hmac, renewPeriodMs) {
+    return Writer.create().appendBytes(hmac, false).appendInt64(renewPeriodMs);
+}
+/*
+  RenewDelegationToken Response (Version: 0) => error_code expiry_timestamp_ms throttle_time_ms
+    error_code => INT16
+    expiry_timestamp_ms => INT64
+    throttle_time_ms => INT32
+*/
+export function parseResponse(_correlationId, apiKey, apiVersion, reader) {
+    const response = {
+        errorCode: reader.readInt16(),
+        expiryTimestampMs: reader.readInt64(),
+        throttleTimeMs: reader.readInt32()
+    };
+    if (response.errorCode !== 0) {
+        throw new ResponseError(apiKey, apiVersion, { '/': [response.errorCode, null] }, response);
+    }
+    return response;
+}
+export const api = createAPI(39, 0, createRequest, parseResponse, false, false);

package/dist/apis/admin/renew-delegation-token-v1.d.ts

@@ -0,0 +1,4 @@
+import { createRequest, parseResponse } from './renew-delegation-token-v0.ts';
+export type { RenewDelegationTokenRequest, RenewDelegationTokenResponse } from './renew-delegation-token-v0.ts';
+export { createRequest, parseResponse };
+export declare const api: import("../definitions.ts").API<unknown[], import("./renew-delegation-token-v0.ts").RenewDelegationTokenResponse>;

package/dist/apis/admin/renew-delegation-token-v1.js

@@ -0,0 +1,8 @@
+import { createAPI } from "../definitions.js";
+import { createRequest, parseResponse } from "./renew-delegation-token-v0.js";
+/*
+  RenewDelegationToken Request (Version: 1) => hmac renew_period_ms
+  RenewDelegationToken Response (Version: 1) => error_code expiry_timestamp_ms throttle_time_ms
+*/
+export { createRequest, parseResponse };
+export const api = createAPI(39, 1, createRequest, parseResponse, false, false);

package/dist/apis/admin/renew-delegation-token-v2.js

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

package/dist/apis/admin/unregister-broker-v0.js

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

package/dist/apis/admin/update-features-v0.d.ts

@@ -0,0 +1,24 @@
+import { type NullableString } from '../../protocol/definitions.ts';
+import { type Reader } from '../../protocol/reader.ts';
+import { Writer } from '../../protocol/writer.ts';
+import { type FeatureUpgradeTypeValue } from '../enumerations.ts';
+export interface UpdateFeaturesRequestFeature {
+    feature: string;
+    maxVersionLevel: number;
+    upgradeType: FeatureUpgradeTypeValue;
+}
+export type UpdateFeaturesRequest = Parameters<typeof createRequest>;
+export interface UpdateFeaturesResponseResult {
+    feature: string;
+    errorCode: number;
+    errorMessage: NullableString;
+}
+export interface UpdateFeaturesResponse {
+    throttleTimeMs: number;
+    errorCode: number;
+    errorMessage: NullableString;
+    results: UpdateFeaturesResponseResult[];
+}
+export declare function createRequest(timeoutMs: number, featureUpdates: UpdateFeaturesRequestFeature[], _validateOnly: boolean): Writer;
+export declare function parseResponse(_correlationId: number, apiKey: number, apiVersion: number, reader: Reader): UpdateFeaturesResponse;
+export declare const api: import("../definitions.ts").API<[timeoutMs: number, featureUpdates: UpdateFeaturesRequestFeature[], _validateOnly: boolean], UpdateFeaturesResponse>;

package/dist/apis/admin/update-features-v0.js

@@ -0,0 +1,59 @@
+import { ResponseError } from "../../errors.js";
+import { Writer } from "../../protocol/writer.js";
+import { createAPI } from "../definitions.js";
+import { FeatureUpgradeTypes } from "../enumerations.js";
+/*
+  UpdateFeatures Request (Version: 0) => timeout_ms [feature_updates] TAG_BUFFER
+    timeout_ms => INT32
+    feature_updates => feature max_version_level allow_downgrade
+      feature => COMPACT_STRING
+      max_version_level => INT16
+      allow_downgrade => BOOLEAN
+*/
+export function createRequest(timeoutMs, featureUpdates, _validateOnly) {
+    return Writer.create().appendInt32(timeoutMs).appendArray(featureUpdates, (writer, feature) => {
+        writer.appendString(feature.feature).appendInt16(feature.maxVersionLevel)
+            .appendBoolean(feature.upgradeType !== FeatureUpgradeTypes.UPGRADE);
+    }).appendTaggedFields();
+}
+/*
+  UpdateFeatures Response (Version: 0) => throttle_time_ms error_code error_message [results] TAG_BUFFER
+    throttle_time_ms => INT32
+    error_code => INT16
+    error_message => COMPACT_NULLABLE_STRING
+    results => feature error_code error_message TAG_BUFFER
+      feature => COMPACT_STRING
+      error_code => INT16
+      error_message => COMPACT_NULLABLE_STRING
+*/
+export function parseResponse(_correlationId, apiKey, apiVersion, reader) {
+    const errors = [];
+    const throttleTimeMs = reader.readInt32();
+    const errorCode = reader.readInt16();
+    const errorMessage = reader.readNullableString();
+    if (errorCode !== 0) {
+        errors.push(['', [errorCode, errorMessage]]);
+    }
+    const response = {
+        throttleTimeMs,
+        errorCode,
+        errorMessage,
+        results: reader.readArray((reader, index) => {
+            const result = {
+                feature: reader.readString(),
+                errorCode: reader.readInt16(),
+                errorMessage: reader.readNullableString()
+            };
+            if (result.errorCode !== 0) {
+                errors.push([`/results/${index}`, [result.errorCode, result.errorMessage]]);
+            }
+            return result;
+        })
+    };
+    reader.readTaggedFields();
+    if (errors.length) {
+        throw new ResponseError(apiKey, apiVersion, Object.fromEntries(errors), response);
+    }
+    return response;
+}
+export const api = createAPI(57, 0, createRequest, parseResponse);

package/dist/apis/admin/update-features-v1.d.ts

@@ -1,10 +1,11 @@
 import { type NullableString } from '../../protocol/definitions.ts';
 import { type Reader } from '../../protocol/reader.ts';
 import { Writer } from '../../protocol/writer.ts';
+import { type FeatureUpgradeTypeValue } from '../enumerations.ts';
 export interface UpdateFeaturesRequestFeature {
     feature: string;
     maxVersionLevel: number;
-    upgradeType: number;
+    upgradeType: FeatureUpgradeTypeValue;
 }
 export type UpdateFeaturesRequest = Parameters<typeof createRequest>;
 export interface UpdateFeaturesResponseResult {

package/dist/apis/admin/update-features-v1.js

@@ -53,6 +53,7 @@ export function parseResponse(_correlationId, apiKey, apiVersion, reader) {
             return result;
         })
     };
+    reader.readTaggedFields();
     if (errors.length) {
         throw new ResponseError(apiKey, apiVersion, Object.fromEntries(errors), response);
     }

package/dist/apis/consumer/consumer-group-heartbeat-v0.d.ts

@@ -22,6 +22,6 @@ export interface ConsumerGroupHeartbeatResponse {
     heartbeatIntervalMs: number;
     assignment: ConsumerGroupHeartbeatResponseAssignment | null;
 }
-export declare function createRequest(groupId: string, memberId: string, memberEpoch: number, instanceId: NullableString, rackId: NullableString, rebalanceTimeoutMs: number, subscribedTopicNames: string[] | null, _subscribedTopicRegex: NullableString, serverAssignor: NullableString, topicPartitions: ConsumerGroupHeartbeatRequestTopicPartition[]): Writer;
+export declare function createRequest(groupId: string, memberId: string, memberEpoch: number, instanceId: NullableString, rackId: NullableString, rebalanceTimeoutMs: number, subscribedTopicNames: string[] | null, _subscribedTopicRegex: NullableString, serverAssignor: NullableString, topicPartitions: ConsumerGroupHeartbeatRequestTopicPartition[] | null): Writer;
 export declare function parseResponse(_correlationId: number, apiKey: number, apiVersion: number, reader: Reader): ConsumerGroupHeartbeatResponse;
-export declare const api: import("../definitions.ts").API<[groupId: string, memberId: string, memberEpoch: number, instanceId: NullableString, rackId: NullableString, rebalanceTimeoutMs: number, subscribedTopicNames: string[] | null, _subscribedTopicRegex: NullableString, serverAssignor: NullableString, topicPartitions: ConsumerGroupHeartbeatRequestTopicPartition[]], ConsumerGroupHeartbeatResponse>;
+export declare const api: import("../definitions.ts").API<[groupId: string, memberId: string, memberEpoch: number, instanceId: NullableString, rackId: NullableString, rebalanceTimeoutMs: number, subscribedTopicNames: string[] | null, _subscribedTopicRegex: NullableString, serverAssignor: NullableString, topicPartitions: ConsumerGroupHeartbeatRequestTopicPartition[] | null], ConsumerGroupHeartbeatResponse>;

package/dist/apis/consumer/consumer-group-heartbeat-v0.js

@@ -26,8 +26,8 @@ export function createRequest(groupId, memberId, memberEpoch, instanceId, rackId
         .appendArray(subscribedTopicNames, (w, t) => w.appendString(t), true, false)
         .appendString(serverAssignor)
         .appendArray(topicPartitions, (w, t) => {
-        return w.appendUUID(t.topicId).appendArray(t.partitions, (w, p) => w.appendInt32(p), true, false);
-    })
+        return w.appendUUID(t.topicId).appendArray(t.partitions, (w, p) => w.appendInt32(p), true, false).appendTaggedFields();
+    }, true, false)
         .appendTaggedFields();
 }
 /*
@@ -51,15 +51,22 @@ export function parseResponse(_correlationId, apiKey, apiVersion, reader) {
         memberId: reader.readNullableString(),
         memberEpoch: reader.readInt32(),
         heartbeatIntervalMs: reader.readInt32(),
-        assignment: reader.readNullableStruct(() => ({
-            topicPartitions: reader.readArray(r => {
-                return {
-                    topicId: r.readUUID(),
-                    partitions: r.readArray(r => r.readInt32(), true, false)
-                };
-            })
-        }))
+        assignment: reader.readNullableStruct(() => {
+            const assignment = {
+                topicPartitions: reader.readArray(r => {
+                    const topicPartition = {
+                        topicId: r.readUUID(),
+                        partitions: r.readArray(r => r.readInt32(), true, false)
+                    };
+                    r.readTaggedFields();
+                    return topicPartition;
+                }, true, false)
+            };
+            reader.readTaggedFields();
+            return assignment;
+        })
     };
+    reader.readTaggedFields();
     if (response.errorCode !== 0) {
         throw new ResponseError(apiKey, apiVersion, { '/': [response.errorCode, response.errorMessage] }, response);
     }

package/dist/apis/consumer/consumer-group-heartbeat-v1.d.ts

@@ -22,6 +22,6 @@ export interface ConsumerGroupHeartbeatResponse {
     heartbeatIntervalMs: number;
     assignment: ConsumerGroupHeartbeatResponseAssignment | null;
 }
-export declare function createRequest(groupId: string, memberId: string, memberEpoch: number, instanceId: NullableString, rackId: NullableString, rebalanceTimeoutMs: number, subscribedTopicNames: string[] | null, subscribedTopicRegex: NullableString, serverAssignor: NullableString, topicPartitions: ConsumerGroupHeartbeatRequestTopicPartition[]): Writer;
+export declare function createRequest(groupId: string, memberId: string, memberEpoch: number, instanceId: NullableString, rackId: NullableString, rebalanceTimeoutMs: number, subscribedTopicNames: string[] | null, subscribedTopicRegex: NullableString, serverAssignor: NullableString, topicPartitions: ConsumerGroupHeartbeatRequestTopicPartition[] | null): Writer;
 export declare function parseResponse(_correlationId: number, apiKey: number, apiVersion: number, reader: Reader): ConsumerGroupHeartbeatResponse;
-export declare const api: import("../definitions.ts").API<[groupId: string, memberId: string, memberEpoch: number, instanceId: NullableString, rackId: NullableString, rebalanceTimeoutMs: number, subscribedTopicNames: string[] | null, subscribedTopicRegex: NullableString, serverAssignor: NullableString, topicPartitions: ConsumerGroupHeartbeatRequestTopicPartition[]], ConsumerGroupHeartbeatResponse>;
+export declare const api: import("../definitions.ts").API<[groupId: string, memberId: string, memberEpoch: number, instanceId: NullableString, rackId: NullableString, rebalanceTimeoutMs: number, subscribedTopicNames: string[] | null, subscribedTopicRegex: NullableString, serverAssignor: NullableString, topicPartitions: ConsumerGroupHeartbeatRequestTopicPartition[] | null], ConsumerGroupHeartbeatResponse>;

package/dist/apis/consumer/consumer-group-heartbeat-v1.js

@@ -28,8 +28,8 @@ export function createRequest(groupId, memberId, memberEpoch, instanceId, rackId
         .appendString(subscribedTopicRegex)
         .appendString(serverAssignor)
         .appendArray(topicPartitions, (w, t) => {
-        return w.appendUUID(t.topicId).appendArray(t.partitions, (w, p) => w.appendInt32(p), true, false);
-    })
+        return w.appendUUID(t.topicId).appendArray(t.partitions, (w, p) => w.appendInt32(p), true, false).appendTaggedFields();
+    }, true, false)
         .appendTaggedFields();
 }
 /*
@@ -53,15 +53,22 @@ export function parseResponse(_correlationId, apiKey, apiVersion, reader) {
         memberId: reader.readNullableString(),
         memberEpoch: reader.readInt32(),
         heartbeatIntervalMs: reader.readInt32(),
-        assignment: reader.readNullableStruct(() => ({
-            topicPartitions: reader.readArray(r => {
-                return {
-                    topicId: r.readUUID(),
-                    partitions: r.readArray(r => r.readInt32(), true, false)
-                };
-            })
-        }))
+        assignment: reader.readNullableStruct(() => {
+            const assignment = {
+                topicPartitions: reader.readArray(r => {
+                    const topicPartition = {
+                        topicId: r.readUUID(),
+                        partitions: r.readArray(r => r.readInt32(), true, false)
+                    };
+                    r.readTaggedFields();
+                    return topicPartition;
+                }, true, false)
+            };
+            reader.readTaggedFields();
+            return assignment;
+        })
     };
+    reader.readTaggedFields();
     if (response.errorCode !== 0) {
         throw new ResponseError(apiKey, apiVersion, { '/': [response.errorCode, response.errorMessage] }, response);
     }

package/dist/apis/consumer/fetch-v10.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>;