@platformatic/kafka 1.28.0 → 1.30.0

package/dist/clients/admin/admin.js

@@ -4,7 +4,7 @@ import { adminAclsChannel, adminClientQuotasChannel, adminConfigsChannel, adminC
 import { MultipleErrors } from "../../errors.js";
 import { Reader } from "../../protocol/reader.js";
 import { Base, kAfterCreate, kCheckNotClosed, kConnections, kGetApi, kGetBootstrapConnection, kGetConnection, kMetadata, kOptions, kPerformDeduplicated, kPerformWithRetry, kValidateOptions } from "../base/base.js";
-import { adminListOffsetsOptionsValidator, alterClientQuotasOptionsValidator, alterConfigsOptionsValidator, alterConsumerGroupOffsetsOptionsValidator, createAclsOptionsValidator, createPartitionsOptionsValidator, createTopicsOptionsValidator, deleteAclsOptionsValidator, deleteConsumerGroupOffsetsOptionsValidator, deleteGroupsOptionsValidator, deleteTopicsOptionsValidator, describeAclsOptionsValidator, describeClientQuotasOptionsValidator, describeConfigsOptionsValidator, describeGroupsOptionsValidator, describeLogDirsOptionsValidator, incrementalAlterConfigsOptionsValidator, listConsumerGroupOffsetsOptionsValidator, listGroupsOptionsValidator, listTopicsOptionsValidator, removeMembersFromConsumerGroupOptionsValidator } from "./options.js";
+import { adminListOffsetsOptionsValidator, alterClientQuotasOptionsValidator, alterConfigsOptionsValidator, alterConsumerGroupOffsetsOptionsValidator, createAclsOptionsValidator, createPartitionsOptionsValidator, createTopicsOptionsValidator, deleteAclsOptionsValidator, deleteConsumerGroupOffsetsOptionsValidator, deleteRecordsOptionsValidator, deleteGroupsOptionsValidator, deleteTopicsOptionsValidator, describeAclsOptionsValidator, describeClientQuotasOptionsValidator, describeConfigsOptionsValidator, describeGroupsOptionsValidator, describeLogDirsOptionsValidator, incrementalAlterConfigsOptionsValidator, listConsumerGroupOffsetsOptionsValidator, listGroupsOptionsValidator, listTopicsOptionsValidator, removeMembersFromConsumerGroupOptionsValidator } from "./options.js";
 export class Admin extends Base {
     #controller = null;
     constructor(options) {
@@ -334,6 +334,21 @@ export class Admin extends Base {
         adminOffsetsChannel.traceCallback(this.#listOffsets, 1, createDiagnosticContext({ client: this, operation: 'listOffsets', options }), this, options, callback);
         return callback[kCallbackPromise];
     }
+    deleteRecords(options, callback) {
+        if (!callback) {
+            callback = createPromisifiedCallback();
+        }
+        if (this[kCheckNotClosed](callback)) {
+            return callback[kCallbackPromise];
+        }
+        const validationError = this[kValidateOptions](options, deleteRecordsOptionsValidator, '/options', false);
+        if (validationError) {
+            callback(validationError);
+            return callback[kCallbackPromise];
+        }
+        adminOffsetsChannel.traceCallback(this.#deleteRecords, 1, createDiagnosticContext({ client: this, operation: 'deleteRecords', options }), this, options, callback);
+        return callback[kCallbackPromise];
+    }
     #getControllerConnection(callback) {
         if (this.#controller) {
             this[kConnections].get(this.#controller, callback);
@@ -518,12 +533,7 @@ export class Admin extends Base {
                                 return;
                             }
                             /* c8 ignore next 5 */
-                            if (api.version === 4) {
-                                api(connection, options.states ?? [], retryCallback);
-                            }
-                            else {
-                                api(connection, options.states ?? [], options.types, retryCallback);
-                            }
+                            api(connection, options.states ?? [], options.types, retryCallback);
                         });
                     }, concurrentCallback, 0);
                 });
@@ -1276,6 +1286,77 @@ export class Admin extends Base {
             })));
         }, 0);
     }
+    #deleteRecords(options, callback) {
+        this[kMetadata]({ topics: options.topics.map(topic => topic.name) }, (error, metadata) => {
+            if (error) {
+                callback(error);
+                return;
+            }
+            const requestsByLeader = new Map();
+            for (const topic of options.topics) {
+                for (const partition of topic.partitions) {
+                    const { leader } = metadata.topics.get(topic.name).partitions[partition.partition];
+                    let leaderRequests = requestsByLeader.get(leader);
+                    if (!leaderRequests) {
+                        leaderRequests = new Map();
+                        requestsByLeader.set(leader, leaderRequests);
+                    }
+                    let topicRequest = leaderRequests.get(topic.name);
+                    if (!topicRequest) {
+                        topicRequest = { name: topic.name, partitions: [] };
+                        leaderRequests.set(topic.name, topicRequest);
+                    }
+                    topicRequest.partitions.push({
+                        partitionIndex: partition.partition,
+                        offset: partition.offset
+                    });
+                }
+            }
+            const requests = new Map();
+            for (const [leader, topics] of requestsByLeader) {
+                requests.set(leader, Array.from(topics.values()));
+            }
+            runConcurrentCallbacks('Deleting records failed.', requests, ([leader, requests], concurrentCallback) => {
+                this[kGetConnection](metadata.brokers.get(leader), (error, connection) => {
+                    if (error) {
+                        concurrentCallback(error);
+                        return;
+                    }
+                    this[kPerformWithRetry]('deleteRecords', retryCallback => {
+                        this[kGetApi]('DeleteRecords', (error, api) => {
+                            if (error) {
+                                retryCallback(error);
+                                return;
+                            }
+                            api(connection, Array.from(requests.values()), this[kOptions].timeout, retryCallback);
+                        });
+                    }, concurrentCallback, 0);
+                });
+            }, (error, responses) => {
+                if (error) {
+                    callback(error);
+                    return;
+                }
+                const deletedRecordsByTopic = new Map();
+                for (const response of responses) {
+                    for (const topic of response.topics) {
+                        let topicDeletedRecords = deletedRecordsByTopic.get(topic.name);
+                        if (!topicDeletedRecords) {
+                            topicDeletedRecords = { name: topic.name, partitions: [] };
+                            deletedRecordsByTopic.set(topic.name, topicDeletedRecords);
+                        }
+                        for (const partition of topic.partitions) {
+                            topicDeletedRecords.partitions.push({
+                                partition: partition.partitionIndex,
+                                lowWatermark: partition.lowWatermark
+                            });
+                        }
+                    }
+                }
+                callback(null, Array.from(deletedRecordsByTopic.values()));
+            });
+        });
+    }
     #listOffsets(options, callback) {
         this[kMetadata]({ topics: options.topics.map(topic => topic.name) }, (error, metadata) => {
             if (error) {

package/dist/clients/admin/options.d.ts

@@ -484,6 +484,46 @@ export declare const deleteConsumerGroupOffsetsOptionsSchema: {
     required: string[];
     additionalProperties: boolean;
 };
+export declare const deleteRecordsOptionsSchema: {
+    type: string;
+    properties: {
+        topics: {
+            type: string;
+            items: {
+                type: string;
+                properties: {
+                    name: {
+                        type: string;
+                        minLength: number;
+                    };
+                    partitions: {
+                        type: string;
+                        items: {
+                            type: string;
+                            properties: {
+                                partition: {
+                                    type: string;
+                                    minimum: number;
+                                };
+                                offset: {
+                                    bigint: boolean;
+                                };
+                            };
+                            required: string[];
+                            additionalProperties: boolean;
+                        };
+                        minItems: number;
+                    };
+                };
+                required: string[];
+                additionalProperties: boolean;
+            };
+            minItems: number;
+        };
+    };
+    required: string[];
+    additionalProperties: boolean;
+};
 export declare const describeConfigsOptionsSchema: {
     type: string;
     properties: {
@@ -881,6 +921,9 @@ export declare const alterConsumerGroupOffsetsOptionsValidator: import("ajv").Va
 export declare const deleteConsumerGroupOffsetsOptionsValidator: import("ajv").ValidateFunction<{
     [x: string]: {};
 }>;
+export declare const deleteRecordsOptionsValidator: import("ajv").ValidateFunction<{
+    [x: string]: {};
+}>;
 export declare const listConsumerGroupOffsetsOptionsValidator: import("ajv").ValidateFunction<{
     [x: string]: {};
 }>;

package/dist/clients/admin/options.js

@@ -343,6 +343,38 @@ export const deleteConsumerGroupOffsetsOptionsSchema = {
     required: ['groupId', 'topics'],
     additionalProperties: false
 };
+export const deleteRecordsOptionsSchema = {
+    type: 'object',
+    properties: {
+        topics: {
+            type: 'array',
+            items: {
+                type: 'object',
+                properties: {
+                    name: { type: 'string', minLength: 1 },
+                    partitions: {
+                        type: 'array',
+                        items: {
+                            type: 'object',
+                            properties: {
+                                partition: { type: 'number', minimum: 0 },
+                                offset: { bigint: true }
+                            },
+                            required: ['partition', 'offset'],
+                            additionalProperties: false
+                        },
+                        minItems: 1
+                    }
+                },
+                required: ['name', 'partitions'],
+                additionalProperties: false
+            },
+            minItems: 1
+        }
+    },
+    required: ['topics'],
+    additionalProperties: false
+};
 export const describeConfigsOptionsSchema = {
     type: 'object',
     properties: {
@@ -568,6 +600,7 @@ export const alterClientQuotasOptionsValidator = ajv.compile(alterClientQuotasOp
 export const describeLogDirsOptionsValidator = ajv.compile(describeLogDirsOptionsSchema);
 export const alterConsumerGroupOffsetsOptionsValidator = ajv.compile(alterConsumerGroupOffsetsOptionsSchema);
 export const deleteConsumerGroupOffsetsOptionsValidator = ajv.compile(deleteConsumerGroupOffsetsOptionsSchema);
+export const deleteRecordsOptionsValidator = ajv.compile(deleteRecordsOptionsSchema);
 export const listConsumerGroupOffsetsOptionsValidator = ajv.compile(listConsumerGroupOffsetsOptionsSchema);
 export const describeConfigsOptionsValidator = ajv.compile(describeConfigsOptionsSchema);
 export const alterConfigsOptionsValidator = ajv.compile(alterConfigsOptionsSchema);

package/dist/clients/admin/types.d.ts

@@ -139,6 +139,25 @@ export interface DeleteConsumerGroupOffsetsOptions {
         partitionIndexes: number[];
     }[];
 }
+export interface DeleteRecordsPartitionOffset {
+    partition: number;
+    offset: bigint;
+}
+export interface DeleteRecordsTopic {
+    name: string;
+    partitions: DeleteRecordsPartitionOffset[];
+}
+export interface DeleteRecordsOptions {
+    topics: DeleteRecordsTopic[];
+}
+export interface DeletedRecordsPartition {
+    partition: number;
+    lowWatermark: bigint;
+}
+export interface DeletedRecordsTopic {
+    name: string;
+    partitions: DeletedRecordsPartition[];
+}
 export interface DescribeConfigsOptions {
     resources: DescribeConfigsRequestResource[];
     includeSynonyms?: boolean;

package/dist/clients/base/base.js

@@ -312,7 +312,12 @@ export class Base extends TypedEventEmitter {
         this[kConnections].get(broker, callback);
     }
     [kGetBootstrapConnection](callback) {
-        this[kConnections].getFirstAvailable(this[kBootstrapBrokers], callback);
+        if (!this.#metadata) {
+            this[kConnections].getFirstAvailable(this[kBootstrapBrokers], callback);
+            return;
+        }
+        const discovered = Array.from(this.#metadata.brokers.values());
+        this[kConnections].getFirstAvailable([...this[kBootstrapBrokers], ...discovered], callback);
     }
     [kValidateOptions](target, validator, targetName, throwOnErrors = true) {
         if (!this[kOptions].strict) {

package/dist/clients/consumer/consumer.js

@@ -1,3 +1,4 @@
+import { randomUUID } from 'node:crypto';
 import { createPromisifiedCallback, kCallbackPromise, runConcurrentCallbacks } from "../../apis/callbacks.js";
 import { FetchIsolationLevels, FindCoordinatorKeyTypes } from "../../apis/enumerations.js";
 import { consumerCommitsChannel, consumerConsumesChannel, consumerFetchesChannel, consumerGroupChannel, consumerHeartbeatChannel, consumerLagChannel, consumerOffsetsChannel, createDiagnosticContext } from "../../diagnostic.js";
@@ -700,8 +701,9 @@ export class Consumer extends Base {
                     groupCallback(error);
                     return;
                 }
-                api(connection, this.groupId, this.memberId || '', this.#memberEpoch, this.groupInstanceId, null, // rackId
-                options.rebalanceTimeout, this.topics.current, this.#groupRemoteAssignor, this.#assignments, groupCallback);
+                const memberId = this.#getConsumerGroupHeartbeatMemberId(api.version);
+                api(connection, this.groupId, memberId, this.#memberEpoch, this.groupInstanceId, null, // rackId
+                options.rebalanceTimeout, this.topics.current, null, this.#groupRemoteAssignor, this.#assignments, groupCallback);
             });
         }, (error, response) => {
             if (this[kClosed]) {
@@ -849,10 +851,12 @@ export class Consumer extends Base {
                     groupCallback(error);
                     return;
                 }
-                api(connection, this.groupId, this.memberId, -1, // memberEpoch = -1 signals leave
+                const memberId = this.#getConsumerGroupHeartbeatMemberId(api.version);
+                api(connection, this.groupId, memberId, -1, // memberEpoch = -1 signals leave
                 this.groupInstanceId, null, // rackId
                 0, // rebalanceTimeout
                 [], // subscribedTopicNames
+                null, // subscribedTopicRegex
                 this.#groupRemoteAssignor, [], // topicPartitions
                 groupCallback);
             });
@@ -865,6 +869,16 @@ export class Consumer extends Base {
             callback(null);
         });
     }
+    #getConsumerGroupHeartbeatMemberId(apiVersion) {
+        if (this.memberId) {
+            return this.memberId;
+        }
+        if (apiVersion >= 1) {
+            this.memberId = randomUUID();
+            return this.memberId;
+        }
+        return '';
+    }
     #performConsume(options, trackTopics, callback) {
         // Subscribe all topics
         let joinNeeded = this.memberId === null;

package/dist/clients/consumer/messages-stream.js

@@ -599,6 +599,7 @@ export class MessagesStream extends Readable {
     }
     #scheduleRefreshOffsetsAndFetch(destroyOnError = true) {
         this.#refreshOffsetsDestroyOnError ||= destroyOnError;
+        /* c8 ignore next 4 - Hard to test */
         if (this.#refreshOffsetsInflight) {
             this.#refreshOffsetsPending = true;
             return;
@@ -707,6 +708,10 @@ export class MessagesStream extends Readable {
                 }
             }
         }
+        if (requests.length === 0) {
+            this.#pushRecords(metadata, topicIds, response, requestedOffsets);
+            return;
+        }
         runAsyncSeries((request, cb) => {
             const [data, type, message] = request;
             const result = hook(data, type, message, cb);

package/dist/clients/producer/producer.js

@@ -726,6 +726,10 @@ export class Producer extends Base {
                 }
             }
         }
+        if (requests.length === 0) {
+            this.#send(options, callback);
+            return;
+        }
         runAsyncSeries((request, cb) => {
             const [data, type, message] = request;
             const result = hook(data, type, message, cb);

package/dist/network/connection.js

@@ -126,7 +126,14 @@ export class Connection extends TypedEventEmitter {
                 connectionsConnectsChannel.asyncEnd.publish(diagnosticContext);
             };
             const connectingSocketErrorHandler = (error) => {
-                this.#onConnectionError(host, port, diagnosticContext, error);
+                let cause = error;
+                const tlsConnectionError = error;
+                if (this.#options.tls &&
+                    tlsConnectionError.code === 'ECONNRESET' &&
+                    tlsConnectionError.message.includes('secure TLS connection was established')) {
+                    cause = new UserError('TLS handshake failed. Please verify the broker supports TLS.', { cause: error });
+                }
+                this.#onConnectionError(host, port, diagnosticContext, cause);
             };
             this.emit('connecting');
             this.#host = host;
@@ -404,9 +411,13 @@ export class Connection extends TypedEventEmitter {
         if (sessionLifetimeMs > 0) {
             this.#reauthenticationTimeout = setTimeout(this.reauthenticate.bind(this), Number(sessionLifetimeMs) * 0.8);
         }
-        if (this.#status === ConnectionStatuses.CONNECTED || this.#status === ConnectionStatuses.REAUTHENTICATING) {
+        const isReauthenticating = this.#status === ConnectionStatuses.REAUTHENTICATING;
+        if (this.#status === ConnectionStatuses.CONNECTED || isReauthenticating) {
             this.#status = ConnectionStatuses.CONNECTED;
             this.emit('sasl:authentication:extended', authBytes);
+            if (isReauthenticating) {
+                this.emit('connect');
+            }
         }
         else {
             this.emit('sasl:authentication', authBytes);

package/dist/protocol/sasl/scram-sha.d.ts

@@ -8,7 +8,7 @@ export interface ScramAlgorithmDefinition {
 }
 export interface ScramCryptoModule {
     h: (definition: ScramAlgorithmDefinition, data: string | Buffer) => Buffer;
-    hi: (definition: ScramAlgorithmDefinition, password: string, salt: Buffer, iterations: number) => Buffer;
+    hi: (definition: ScramAlgorithmDefinition, password: string, salt: Buffer, iterations: number) => Promise<Buffer>;
     hmac: (definition: ScramAlgorithmDefinition, key: Buffer, data: string | Buffer) => Buffer;
     xor: (a: Buffer, b: Buffer) => Buffer;
 }
@@ -31,7 +31,7 @@ export declare function createNonce(): string;
 export declare function sanitizeString(str: string): string;
 export declare function parseParameters(data: Buffer): Record<string, string>;
 export declare function h(definition: ScramAlgorithmDefinition, data: string | Buffer): Buffer;
-export declare function hi(definition: ScramAlgorithmDefinition, password: string, salt: Buffer, iterations: number): Buffer;
+export declare function hi(definition: ScramAlgorithmDefinition, password: string, salt: Buffer, iterations: number): Promise<Buffer>;
 export declare function hmac(definition: ScramAlgorithmDefinition, key: Buffer, data: string | Buffer): Buffer;
 export declare function xor(a: Buffer, b: Buffer): Buffer;
 export declare const defaultCrypto: ScramCryptoModule;

package/dist/protocol/sasl/scram-sha.js

@@ -1,4 +1,5 @@
-import { createHash, createHmac, pbkdf2Sync, randomBytes } from 'node:crypto';
+import { createHash, createHmac, pbkdf2, randomBytes } from 'node:crypto';
+import { promisify } from 'node:util';
 import { createPromisifiedCallback, kCallbackPromise } from "../../apis/callbacks.js";
 import { AuthenticationError } from "../../errors.js";
 import { getCredential } from "./utils.js";
@@ -38,8 +39,9 @@ export function parseParameters(data) {
 export function h(definition, data) {
     return createHash(definition.algorithm).update(data).digest();
 }
+const pbkdf2Async = promisify(pbkdf2);
 export function hi(definition, password, salt, iterations) {
-    return pbkdf2Sync(password, salt, iterations, definition.keyLength, definition.algorithm);
+    return pbkdf2Async(password, salt, iterations, definition.keyLength, definition.algorithm);
 }
 export function hmac(definition, key, data) {
     return createHmac(definition.algorithm, key).update(data).digest();
@@ -93,31 +95,37 @@ function performAuthentication(connection, algorithm, definition, authenticateAP
         // ClientProof     := ClientKey XOR ClientSignature
         // ServerKey       := HMAC(SaltedPassword, "Server Key")
         // ServerSignature := HMAC(ServerKey, AuthMessage)
-        const saltedPassword = hi(definition, password, salt, iterations);
-        const clientKey = hmac(definition, saltedPassword, HMAC_CLIENT_KEY);
-        const storedKey = h(definition, clientKey);
-        const clientFinalMessageWithoutProof = `c=${GS2_HEADER_BASE64},r=${serverNonce}`;
-        const authMessage = `${clientFirstMessageBare},${serverFirstMessage},${clientFinalMessageWithoutProof}`;
-        const clientSignature = hmac(definition, storedKey, authMessage);
-        const clientProof = xor(clientKey, clientSignature);
-        const serverKey = hmac(definition, saltedPassword, HMAC_SERVER_KEY);
-        const serverSignature = hmac(definition, serverKey, authMessage);
-        authenticateAPI(connection, Buffer.from(`${clientFinalMessageWithoutProof},p=${clientProof.toString('base64')}`), (error, lastResponse) => {
-            if (error) {
-                callback(new AuthenticationError('SASL authentication failed.', { cause: error }));
-                return;
-            }
-            // Send the last message to the server
-            const lastData = parseParameters(lastResponse.authBytes);
-            if (lastData.e) {
-                callback(new AuthenticationError(lastData.e));
-                return;
-            }
-            else if (lastData.v !== serverSignature.toString('base64')) {
-                callback(new AuthenticationError('Invalid server signature.'));
-                return;
-            }
-            callback(null, lastResponse);
+        hi(definition, password, salt, iterations)
+            .then(saltedPassword => {
+            const clientKey = hmac(definition, saltedPassword, HMAC_CLIENT_KEY);
+            const storedKey = h(definition, clientKey);
+            const clientFinalMessageWithoutProof = `c=${GS2_HEADER_BASE64},r=${serverNonce}`;
+            const authMessage = `${clientFirstMessageBare},${serverFirstMessage},${clientFinalMessageWithoutProof}`;
+            const clientSignature = hmac(definition, storedKey, authMessage);
+            const clientProof = xor(clientKey, clientSignature);
+            const serverKey = hmac(definition, saltedPassword, HMAC_SERVER_KEY);
+            const serverSignature = hmac(definition, serverKey, authMessage);
+            authenticateAPI(connection, Buffer.from(`${clientFinalMessageWithoutProof},p=${clientProof.toString('base64')}`), (error, lastResponse) => {
+                if (error) {
+                    callback(new AuthenticationError('SASL authentication failed.', { cause: error }));
+                    return;
+                }
+                // Send the last message to the server
+                const lastData = parseParameters(lastResponse.authBytes);
+                if (lastData.e) {
+                    callback(new AuthenticationError(lastData.e));
+                    return;
+                }
+                else if (lastData.v !== serverSignature.toString('base64')) {
+                    callback(new AuthenticationError('Invalid server signature.'));
+                    return;
+                }
+                callback(null, lastResponse);
+            });
+        })
+            /* c8 ignore next 3 - Hard to test */
+            .catch(error => {
+            callback(new AuthenticationError('SASL authentication failed.', { cause: error }));
         });
     });
 }

package/dist/registries/abstract.js

@@ -1,4 +1,8 @@
 export function runAsyncSeries(operation, collection, index, callback) {
+    if (collection.length === 0 || index >= collection.length) {
+        callback(null);
+        return;
+    }
     operation(collection[index], error => {
         if (error) {
             callback(error);

package/dist/typescript-4/dist/apis/admin/alter-partition-reassignments-v0.d.ts

@@ -25,6 +25,6 @@ export interface AlterPartitionReassignmentsResponse {
   errorMessage: NullableString;
   responses: AlterPartitionReassignmentsResponseResponse[];
 }
-export declare function createRequest(timeoutMs: number, topics: AlterPartitionReassignmentsRequestTopic[]): Writer;
+export declare function createRequest(timeoutMs: number, _allowReplicationFactorChange: boolean, topics: AlterPartitionReassignmentsRequestTopic[]): Writer;
 export declare function parseResponse(_correlationId: number, apiKey: number, apiVersion: number, reader: Reader): AlterPartitionReassignmentsResponse;
-export declare const api: import("../definitions").API<[timeoutMs: number, topics: AlterPartitionReassignmentsRequestTopic[]], AlterPartitionReassignmentsResponse>;
+export declare const api: import("../definitions").API<[timeoutMs: number, _allowReplicationFactorChange: boolean, topics: AlterPartitionReassignmentsRequestTopic[]], AlterPartitionReassignmentsResponse>;

package/dist/typescript-4/dist/apis/admin/alter-partition-reassignments-v1.d.ts

@@ -0,0 +1,30 @@
+import { type NullableString } from "../../protocol/definitions";
+import { type Reader } from "../../protocol/reader";
+import { Writer } from "../../protocol/writer";
+export interface AlterPartitionReassignmentsRequestPartition {
+  partitionIndex: number;
+  replicas: number[];
+}
+export interface AlterPartitionReassignmentsRequestTopic {
+  name: string;
+  partitions: AlterPartitionReassignmentsRequestPartition[];
+}
+export type AlterPartitionReassignmentsRequest = Parameters<typeof createRequest>;
+export interface AlterPartitionReassignmentsResponsePartition {
+  partitionIndex: number;
+  errorCode: number;
+  errorMessage: NullableString;
+}
+export interface AlterPartitionReassignmentsResponseResponse {
+  name: string;
+  partitions: AlterPartitionReassignmentsResponsePartition[];
+}
+export interface AlterPartitionReassignmentsResponse {
+  throttleTimeMs: number;
+  errorCode: number;
+  errorMessage: NullableString;
+  responses: AlterPartitionReassignmentsResponseResponse[];
+}
+export declare function createRequest(timeoutMs: number, allowReplicationFactorChange: boolean, topics: AlterPartitionReassignmentsRequestTopic[]): Writer;
+export declare function parseResponse(_correlationId: number, apiKey: number, apiVersion: number, reader: Reader): AlterPartitionReassignmentsResponse;
+export declare const api: import("../definitions").API<[timeoutMs: number, allowReplicationFactorChange: boolean, topics: AlterPartitionReassignmentsRequestTopic[]], AlterPartitionReassignmentsResponse>;

package/dist/typescript-4/dist/apis/admin/describe-cluster-v0.d.ts

@@ -18,6 +18,6 @@ export interface DescribeClusterResponse {
   brokers: DescribeClusterResponseBroker[];
   clusterAuthorizedOperations: number;
 }
-export declare function createRequest(includeClusterAuthorizedOperations: boolean): Writer;
+export declare function createRequest(includeClusterAuthorizedOperations: boolean, _endpointType: number): Writer;
 export declare function parseResponse(_correlationId: number, apiKey: number, apiVersion: number, reader: Reader): DescribeClusterResponse;
-export declare const api: import("../definitions").API<[includeClusterAuthorizedOperations: boolean], DescribeClusterResponse>;
+export declare const api: import("../definitions").API<[includeClusterAuthorizedOperations: boolean, _endpointType: number], DescribeClusterResponse>;

package/dist/typescript-4/dist/apis/admin/index.d.ts

@@ -1,6 +1,7 @@
 export * as alterClientQuotasV1 from "./alter-client-quotas-v1";
 export * as alterConfigsV2 from "./alter-configs-v2";
 export * as alterPartitionReassignmentsV0 from "./alter-partition-reassignments-v0";
+export * as alterPartitionReassignmentsV1 from "./alter-partition-reassignments-v1";
 export * as alterPartitionV3 from "./alter-partition-v3";
 export * as alterReplicaLogDirsV2 from "./alter-replica-log-dirs-v2";
 export * as alterUserScramCredentialsV0 from "./alter-user-scram-credentials-v0";
@@ -43,6 +44,7 @@ export * as listGroupsV5 from "./list-groups-v5";
 export * as listPartitionReassignmentsV0 from "./list-partition-reassignments-v0";
 export * as listTransactionsV0 from "./list-transactions-v0";
 export * as listTransactionsV1 from "./list-transactions-v1";
+export * as listTransactionsV2 from "./list-transactions-v2";
 export * as offsetDeleteV0 from "./offset-delete-v0";
 export * as renewDelegationTokenV2 from "./renew-delegation-token-v2";
 export * as unregisterBrokerV0 from "./unregister-broker-v0";

package/dist/typescript-4/dist/apis/admin/list-groups-v4.d.ts

@@ -12,6 +12,6 @@ export interface ListGroupsResponse {
   errorCode: number;
   groups: ListGroupsResponseGroup[];
 }
-export declare function createRequest(statesFilter: ConsumerGroupStateValue[]): Writer;
+export declare function createRequest(statesFilter: ConsumerGroupStateValue[], _typesFilter: string[]): Writer;
 export declare function parseResponse(_correlationId: number, apiKey: number, apiVersion: number, reader: Reader): ListGroupsResponse;
-export declare const api: import("../definitions").API<[statesFilter: ("PREPARING_REBALANCE" | "COMPLETING_REBALANCE" | "STABLE" | "DEAD" | "EMPTY")[]], ListGroupsResponse>;
+export declare const api: import("../definitions").API<[statesFilter: ("PREPARING_REBALANCE" | "COMPLETING_REBALANCE" | "STABLE" | "DEAD" | "EMPTY")[], _typesFilter: string[]], ListGroupsResponse>;

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

@@ -1,3 +1,4 @@
+import { type NullableString } from "../../protocol/definitions";
 import { type Reader } from "../../protocol/reader";
 import { Writer } from "../../protocol/writer";
 import { type TransactionState } from "../enumerations";
@@ -13,6 +14,6 @@ export interface ListTransactionsResponse {
   unknownStateFilters: string[];
   transactionStates: ListTransactionsResponseTransactionState[];
 }
-export declare function createRequest(stateFilters: TransactionState[], producerIdFilters: bigint[]): Writer;
+export declare function createRequest(stateFilters: TransactionState[], 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").API<[stateFilters: ("EMPTY" | "ONGOING" | "PREPARE_ABORT" | "COMMITTING" | "ABORTING" | "COMPLETE_COMMIT" | "COMPLETE_ABORT")[], producerIdFilters: bigint[]], ListTransactionsResponse>;
+export declare const api: import("../definitions").API<[stateFilters: ("EMPTY" | "ONGOING" | "PREPARE_ABORT" | "COMMITTING" | "ABORTING" | "COMPLETE_COMMIT" | "COMPLETE_ABORT")[], producerIdFilters: bigint[], _durationFilter: bigint, _transactionalIdPattern: NullableString], ListTransactionsResponse>;

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

@@ -1,3 +1,4 @@
+import { type NullableString } from "../../protocol/definitions";
 import { type Reader } from "../../protocol/reader";
 import { Writer } from "../../protocol/writer";
 import { type TransactionState } from "../enumerations";
@@ -13,6 +14,6 @@ export interface ListTransactionsResponse {
   unknownStateFilters: string[];
   transactionStates: ListTransactionsResponseTransactionState[];
 }
-export declare function createRequest(stateFilters: TransactionState[], producerIdFilters: bigint[], durationFilter: bigint): Writer;
+export declare function createRequest(stateFilters: TransactionState[], 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").API<[stateFilters: ("EMPTY" | "ONGOING" | "PREPARE_ABORT" | "COMMITTING" | "ABORTING" | "COMPLETE_COMMIT" | "COMPLETE_ABORT")[], producerIdFilters: bigint[], durationFilter: bigint], ListTransactionsResponse>;
+export declare const api: import("../definitions").API<[stateFilters: ("EMPTY" | "ONGOING" | "PREPARE_ABORT" | "COMMITTING" | "ABORTING" | "COMPLETE_COMMIT" | "COMPLETE_ABORT")[], producerIdFilters: bigint[], durationFilter: bigint, _transactionalIdPattern: NullableString], ListTransactionsResponse>;

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

@@ -0,0 +1,20 @@
+import { type NullableString } from "../../protocol/definitions";
+import { type Reader } from "../../protocol/reader";
+import { Writer } from "../../protocol/writer";
+import { type TransactionState } from "../enumerations";
+export type ListTransactionsRequest = Parameters<typeof createRequest>;
+export interface ListTransactionsResponseTransactionState {
+  transactionalId: string;
+  producerId: bigint;
+  transactionState: string;
+}
+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 parseResponse(_correlationId: number, apiKey: number, apiVersion: number, reader: Reader): ListTransactionsResponse;
+export declare const api: import("../definitions").API<[stateFilters: ("EMPTY" | "ONGOING" | "PREPARE_ABORT" | "COMMITTING" | "ABORTING" | "COMPLETE_COMMIT" | "COMPLETE_ABORT")[], producerIdFilters: bigint[], durationFilter: bigint, transactionalIdPattern: NullableString], ListTransactionsResponse>;

package/dist/typescript-4/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, 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[]): Writer;
 export declare function parseResponse(_correlationId: number, apiKey: number, apiVersion: number, reader: Reader): ConsumerGroupHeartbeatResponse;
-export declare const api: import("../definitions").API<[groupId: string, memberId: string, memberEpoch: number, instanceId: NullableString, rackId: NullableString, rebalanceTimeoutMs: number, subscribedTopicNames: string[] | null, serverAssignor: NullableString, topicPartitions: ConsumerGroupHeartbeatRequestTopicPartition[]], ConsumerGroupHeartbeatResponse>;
+export declare const api: import("../definitions").API<[groupId: string, memberId: string, memberEpoch: number, instanceId: NullableString, rackId: NullableString, rebalanceTimeoutMs: number, subscribedTopicNames: string[] | null, _subscribedTopicRegex: NullableString, serverAssignor: NullableString, topicPartitions: ConsumerGroupHeartbeatRequestTopicPartition[]], ConsumerGroupHeartbeatResponse>;