@platformatic/kafka 2.10.0-alpha.1 → 2.10.0

package/dist/clients/producer/producer.js

@@ -2,7 +2,7 @@ import { randomUUID } from 'crypto';
 import { createPromisifiedCallback, kCallbackPromise, runConcurrentCallbacks } from "../../apis/callbacks.js";
 import { FindCoordinatorKeyTypes, ProduceAcks } from "../../apis/enumerations.js";
 import { createDiagnosticContext, producerInitIdempotentChannel, producerSendsChannel, producerTransactionsChannel } from "../../diagnostic.js";
-import { findErrorBy, UserError } from "../../errors.js";
+import { findErrorBy, NetworkError, UserError } from "../../errors.js";
 import { runAsyncSeries } from "../../registries/abstract.js";
 import { kInstance, kTransaction, kTransactionAddOffsets, kTransactionAddPartitions, kTransactionCancel, kTransactionCommitOffset, kTransactionEnd, kTransactionFindCoordinator, kTransactionPrepare } from "../../symbols.js";
 import { emitExperimentalApiWarning, NumericMap } from "../../utils.js";
@@ -353,12 +353,7 @@ export class Producer extends Base {
                             retryCallback(error);
                             return;
                         }
-                        api(connection, FindCoordinatorKeyTypes.TRANSACTION, [transactionalId], (error, response) => {
-                            if (response && api.version < 4) {
-                                response.coordinators[0].key = transactionalId;
-                            }
-                            retryCallback(error, response);
-                        });
+                        api(connection, FindCoordinatorKeyTypes.TRANSACTION, [transactionalId], retryCallback);
                     });
                 }, attempt);
             }, (error, response) => {
@@ -749,65 +744,71 @@ export class Producer extends Base {
         });
     }
     #performSingleDestinationSend(topics, messages, timeout, acks, autocreateTopics, repeatOnStaleMetadata, produceOptions, recoverOnProducerStateLoss, callback) {
-        // Get the metadata with the topic/partitions informations
-        this[kMetadata]({ topics, autocreateTopics }, (error, metadata) => {
-            if (error) {
-                callback(error);
-                return;
-            }
-            const { topic, partition } = messages[0];
-            const leader = metadata.topics.get(topic).partitions[partition].leader;
-            this[kPerformWithRetry]('produce', retryCallback => {
+        const { topic, partition } = messages[0];
+        let refreshMetadata = false;
+        this[kPerformWithRetry]('produce', retryCallback => {
+            this[kMetadata]({ topics, autocreateTopics, forceUpdate: refreshMetadata }, (error, metadata) => {
+                if (error) {
+                    refreshMetadata = NetworkError.isRetryable(error);
+                    retryCallback(error);
+                    return;
+                }
+                refreshMetadata = false;
+                const leader = metadata.topics.get(topic).partitions[partition].leader;
                 this[kGetConnection](metadata.brokers.get(leader), (error, connection) => {
                     if (error) {
+                        refreshMetadata = NetworkError.isRetryable(error);
                         retryCallback(error);
                         return;
                     }
                     this[kGetApi]('Produce', (error, api) => {
                         if (error) {
+                            refreshMetadata = NetworkError.isRetryable(error);
                             retryCallback(error);
                             return;
                         }
-                        api(connection, acks, timeout, messages, produceOptions, retryCallback);
+                        api(connection, acks, timeout, messages, produceOptions, (error, response) => {
+                            refreshMetadata = NetworkError.isRetryable(error);
+                            retryCallback(error, response);
+                        });
                     });
                 });
-            }, (error, results) => {
-                if (error) {
-                    // If the last error was due to stale metadata, we retry the operation with this set of messages
-                    // since the partition is already set, it should attempt on the new destination
-                    /* c8 ignore next - Hard to test */
-                    const hasStaleMetadata = findErrorBy(error, 'hasStaleMetadata', true);
-                    if (hasStaleMetadata && repeatOnStaleMetadata) {
-                        this.clearMetadata();
-                        this.#performSingleDestinationSend(topics, messages, timeout, acks, autocreateTopics, false, produceOptions, recoverOnProducerStateLoss, callback);
-                        return;
-                    }
-                    if (recoverOnProducerStateLoss && !this.#transaction && this.#isProducerStateLost(error)) {
-                        this.#recoverIdempotentProducer(messages, produceOptions, (error, recoveredProduceOptions) => {
-                            if (error) {
-                                callback(error);
-                                return;
-                            }
-                            this.#performSingleDestinationSend(topics, messages, timeout, acks, autocreateTopics, repeatOnStaleMetadata, recoveredProduceOptions, false, callback);
-                        });
-                        return;
-                    }
-                    callback(error, results);
+            });
+        }, (error, results) => {
+            if (error) {
+                // If the last error was due to stale metadata, we retry the operation with this set of messages
+                // since the partition is already set, it should attempt on the new destination
+                /* c8 ignore next - Hard to test */
+                const hasStaleMetadata = findErrorBy(error, 'hasStaleMetadata', true);
+                if (hasStaleMetadata && repeatOnStaleMetadata) {
+                    this.clearMetadata();
+                    this.#performSingleDestinationSend(topics, messages, timeout, acks, autocreateTopics, false, produceOptions, recoverOnProducerStateLoss, callback);
                     return;
                 }
-                callback(error, results);
-            }, 0, [], error => {
-                /* c8 ignore next 3 - Hard to test */
-                if (!repeatOnStaleMetadata) {
-                    return false;
+                if (recoverOnProducerStateLoss && !this.#transaction && this.#isProducerStateLost(error)) {
+                    this.#recoverIdempotentProducer(messages, produceOptions, (error, recoveredProduceOptions) => {
+                        if (error) {
+                            callback(error);
+                            return;
+                        }
+                        this.#performSingleDestinationSend(topics, messages, timeout, acks, autocreateTopics, repeatOnStaleMetadata, recoveredProduceOptions, false, callback);
+                    });
+                    return;
                 }
-                return !!findErrorBy(error, 'hasStaleMetadata', true);
-            });
+                callback(error, results);
+                return;
+            }
+            callback(error, results);
+        }, 0, [], error => {
+            /* c8 ignore next 3 - Hard to test */
+            if (!repeatOnStaleMetadata) {
+                return false;
+            }
+            return !!findErrorBy(error, 'hasStaleMetadata', true);
         });
     }
     #isProducerStateLost(error) {
-        return !!(findErrorBy(error, 'apiId', 'UNKNOWN_PRODUCER_ID') ||
-            findErrorBy(error, 'apiId', 'OUT_OF_ORDER_SEQUENCE_NUMBER'));
+        return !!(findErrorBy(error, 'apiId', 'UNKNOWN_PRODUCER_ID') || findErrorBy(error, 'apiId', 'OUT_OF_ORDER_SEQUENCE_NUMBER'));
     }
     #recoverIdempotentProducer(messages, produceOptions, callback) {
         this.#producerInfo = undefined;

package/dist/errors.d.ts

@@ -36,6 +36,7 @@ export declare class AuthenticationError extends GenericError {
 }
 export declare class NetworkError extends GenericError {
     static code: ErrorCode;
+    static isRetryable(error: Error | null | undefined): boolean;
     constructor(message: string, properties?: ErrorProperties);
 }
 export declare class ProtocolError extends GenericError {

package/dist/errors.js

@@ -119,6 +119,10 @@ export class AuthenticationError extends GenericError {
 }
 export class NetworkError extends GenericError {
     static code = 'PLT_KFK_NETWORK';
+    static isRetryable(error) {
+        const networkError = findErrorBy(error, 'code', NetworkError.code);
+        return networkError?.canRetry === true;
+    }
     constructor(message, properties = {}) {
         super(NetworkError.code, message, { canRetry: true, ...properties });
     }

package/dist/network/connection.js

@@ -4,8 +4,7 @@ import { createConnection } from 'node:net';
 import { connect as createTLSConnection } from 'node:tls';
 import { createPromisifiedCallback, kCallbackPromise } from "../apis/callbacks.js";
 import { allowedSASLMechanisms, SASLMechanisms } from "../apis/enumerations.js";
-import { clientSoftwareName, clientSoftwareVersion } from "../clients/base/options.js";
-import { apiVersionsV1, saslAuthenticateV0, saslAuthenticateV1, saslAuthenticateV2, saslHandshakeV1 } from "../apis/index.js";
+import { saslAuthenticateV2, saslHandshakeV1 } from "../apis/index.js";
 import { connectionsApiChannel, connectionsConnectsChannel, createDiagnosticContext, notifyCreation } from "../diagnostic.js";
 import { AuthenticationError, NetworkError, TimeoutError, UnexpectedCorrelationIdError, UserError } from "../errors.js";
 import { TypedEventEmitter } from "../events.js";
@@ -53,8 +52,6 @@ export class Connection extends TypedEventEmitter {
     #socketMustBeDrained;
     #detectMissingTLS;
     #reauthenticationTimeout;
-    // Negotiated once per connection: reauthentication runs the same path again.
-    #saslAuthenticateApi;
     constructor(clientId, options = {}) {
         super();
         this.setMaxListeners(0);
@@ -343,71 +340,28 @@ export class Connection extends TypedEventEmitter {
             this.#onConnectionError(host, port, diagnosticContext, new UserError(`SASL mechanism ${mechanism} not supported.`));
             return;
         }
-        this.#negotiateSaslAuthenticate(saslAuthenticate => {
-            saslHandshakeV1.api(this, mechanism, (error, response) => {
-                if (error) {
-                    this.#onConnectionError(host, port, diagnosticContext, new AuthenticationError('Cannot find a suitable SASL mechanism.', { cause: error }));
-                    return;
-                }
-                this.emit('sasl:handshake', response.mechanisms);
-                const callback = this.#onSaslAuthenticate.bind(this, host, port, diagnosticContext);
-                if (authenticate) {
-                    authenticate(mechanism, this, saslAuthenticate, username, password, token, callback);
-                }
-                else if (mechanism === SASLMechanisms.PLAIN) {
-                    saslPlain.authenticate(saslAuthenticate, this, username, password, callback);
-                }
-                else if (mechanism === SASLMechanisms.OAUTHBEARER) {
-                    saslOAuthBearer.authenticate(saslAuthenticate, this, token, oauthBearerExtensions, callback);
-                }
-                else if (mechanism === SASLMechanisms.GSSAPI) {
-                    callback(new UserError('No custom SASL/GSSAPI authenticator provided.'));
-                }
-                else {
-                    saslScramSha.authenticate(saslAuthenticate, this, mechanism.substring(6), username, password, defaultCrypto, callback);
-                }
-            });
-        });
-    }
-    /**
-     * Chooses the SaslAuthenticate version to authenticate with.
-     *
-     * The version cannot be assumed: v1 arrived in Apache Kafka 2.0 and v2 in 2.4, so pinning the
-     * newest makes authentication fail outright on older brokers, which answer an unparseable request
-     * with InvalidRequestException and drop the connection.
-     *
-     * Brokers accept ApiVersions before authentication precisely so that clients can ask, and it has
-     * to happen before SaslHandshake: once the handshake is sent the connection only accepts
-     * SaslAuthenticate. The result is cached because reauthentication runs this path again.
-     *
-     * SaslHandshake itself stays at v1. v0 signals the pre-1.0 flow, where the SASL tokens are written
-     * raw on the wire rather than wrapped in SaslAuthenticate requests, which this package does not
-     * implement.
-     */
-    #negotiateSaslAuthenticate(callback) {
-        if (this.#saslAuthenticateApi) {
-            callback(this.#saslAuthenticateApi);
-            return;
-        }
-        const candidates = [
-            [2, saslAuthenticateV2.api],
-            [1, saslAuthenticateV1.api],
-            [0, saslAuthenticateV0.api]
-        ];
-        apiVersionsV1.api(this, clientSoftwareName, clientSoftwareVersion, (error, response) => {
-            let selected;
-            /* c8 ignore next 3 - Only reachable against a broker which refuses ApiVersions before authentication */
+        saslHandshakeV1.api(this, mechanism, (error, response) => {
             if (error) {
-                selected = undefined;
+                this.#onConnectionError(host, port, diagnosticContext, new AuthenticationError('Cannot find a suitable SASL mechanism.', { cause: error }));
+                return;
+            }
+            this.emit('sasl:handshake', response.mechanisms);
+            const callback = this.#onSaslAuthenticate.bind(this, host, port, diagnosticContext);
+            if (authenticate) {
+                authenticate(mechanism, this, saslAuthenticateV2.api, username, password, token, callback);
+            }
+            else if (mechanism === SASLMechanisms.PLAIN) {
+                saslPlain.authenticate(saslAuthenticateV2.api, this, username, password, callback);
+            }
+            else if (mechanism === SASLMechanisms.OAUTHBEARER) {
+                saslOAuthBearer.authenticate(saslAuthenticateV2.api, this, token, oauthBearerExtensions, callback);
+            }
+            else if (mechanism === SASLMechanisms.GSSAPI) {
+                callback(new UserError('No custom SASL/GSSAPI authenticator provided.'));
             }
             else {
-                const advertised = response.apiKeys.find(api => api.apiKey === saslAuthenticateV2.api.key);
-                selected = candidates.find(([version]) => advertised && version >= advertised.minVersion && version <= advertised.maxVersion)?.[1];
+                saslScramSha.authenticate(saslAuthenticateV2.api, this, mechanism.substring(6), username, password, defaultCrypto, callback);
             }
-            // Falling back to the newest version keeps the previous behaviour for brokers which do not
-            // answer the probe, rather than failing a connection which would otherwise have worked.
-            this.#saslAuthenticateApi = selected ?? saslAuthenticateV2.api;
-            callback(this.#saslAuthenticateApi);
         });
     }
     /*

package/dist/network/utils.js

@@ -1,12 +1,30 @@
+const BRACKETED_BROKER_RE = /^\[([^\]]+)](?::(\d*))?$/;
 export function parseBroker(broker, defaultPort = 9092) {
-    if (typeof broker === 'string') {
-        if (broker.includes(':')) {
-            const [host, port] = broker.split(':');
-            return { host, port: Number(port) };
-        }
-        else {
-            return { host: broker, port: defaultPort };
+    if (typeof broker !== 'string') {
+        const host = stripBrackets(broker.host);
+        if (host === broker.host) {
+            return broker;
         }
+        return { ...broker, host };
+    }
+    const bracketed = BRACKETED_BROKER_RE.exec(broker);
+    if (bracketed) {
+        return { host: bracketed[1], port: parsePort(bracketed[2], defaultPort) };
+    }
+    const separator = broker.lastIndexOf(':');
+    // Bare IPv6 addresses contain multiple colons and no port. The host:port form
+    // is unambiguous only with a single colon, or with brackets around the host.
+    if (separator === -1 || broker.indexOf(':') !== separator) {
+        return { host: broker, port: defaultPort };
+    }
+    return { host: broker.slice(0, separator), port: parsePort(broker.slice(separator + 1), defaultPort) };
+}
+function parsePort(port, defaultPort) {
+    return port === undefined || port.length === 0 ? defaultPort : Number(port);
+}
+function stripBrackets(host) {
+    if (host.startsWith('[') && host.endsWith(']')) {
+        return host.slice(1, -1);
     }
-    return broker;
+    return host;
 }

package/dist/protocol/definitions.js

@@ -7,5 +7,5 @@ export const EMPTY_BUFFER = Buffer.alloc(0);
 export const EMPTY_UUID = Buffer.alloc(UUID_SIZE);
 // Since it is serialized at either 0 (for nullable) or 1 (since length is stored as length + 1), it always uses a single byte
 export const EMPTY_OR_SINGLE_COMPACT_LENGTH_SIZE = INT8_SIZE;
-// Flexible-version messages use this zero-length tagged-field section.
+// TODO: Tagged fields are not supported yet
 export const EMPTY_TAGGED_FIELDS_BUFFER = Buffer.from([0]);

package/dist/protocol/reader.js

@@ -187,13 +187,9 @@ export class Reader {
         return this.readNullableString(compact, encoding) || '';
     }
     readUUID() {
-        const hex = this.peekUUID();
+        const value = this.peekUUID();
         this.position += UUID_SIZE;
-        // Hyphenated by slicing rather than by a capture group regex. This runs once per topic per
-        // Fetch response from v13 up, and the regex form measured about fourteen times the cost, which
-        // made the newest Fetch versions measurably slower to decode than the ones identifying topics
-        // by name.
-        return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
+        return value.replace(/(.{8})(.{4})(.{4})(.{4})(.{12})/, '$1-$2-$3-$4-$5');
     }
     readNullableBytes(compact = true) {
         let length;
@@ -304,7 +300,7 @@ export class Reader {
         }
         return reader();
     }
-    // Skip unknown tagged fields because codecs do not expose them to callers.
+    // TODO: Tagged fields are not supported yet
     readTaggedFields() {
         const length = this.readUnsignedVarInt();
         for (let i = 0; i < length; i++) {

package/dist/protocol/records.d.ts

@@ -33,11 +33,14 @@ export interface MessageJSON<Key = unknown, Value = unknown, HeaderKey = unknown
     partition: number;
     timestamp: string;
     offset: string;
+    leaderEpoch: number;
     metadata: Record<string, unknown>;
 }
 export interface Message<Key = Buffer, Value = Buffer, HeaderKey = Buffer, HeaderValue = Buffer> extends Required<MessageBase<Key, Value>> {
     headers: Map<HeaderKey, HeaderValue>;
+    headerEntries: Array<[HeaderKey, HeaderValue]>;
     offset: bigint;
+    leaderEpoch: number;
     metadata: Record<string, unknown>;
     commit(callback?: (error?: Error) => void): void | Promise<void>;
     toJSON(): MessageJSON<Key, Value, HeaderKey, HeaderValue>;

package/dist/protocol/writer.js

@@ -1,6 +1,6 @@
 import { DynamicBuffer } from '@platformatic/dynamic-buffer';
 import { humanize } from "../utils.js";
-import { EMPTY_TAGGED_FIELDS_BUFFER, EMPTY_UUID, UUID_SIZE } from "./definitions.js";
+import { EMPTY_TAGGED_FIELDS_BUFFER, EMPTY_UUID } from "./definitions.js";
 const instanceIdentifier = Symbol('plt.kafka.writer.instanceIdentifier');
 export class Writer {
     context;
@@ -125,12 +125,6 @@ export class Writer {
             return this.append(EMPTY_UUID);
         }
         const buffer = Buffer.from(value.replaceAll('-', ''), 'hex');
-        // UUIDs are fixed width and carry no length prefix, so anything that is not exactly 16 bytes
-        // would silently desync the rest of the request. Buffer.from() stops at the first non hex
-        // character, so a topic name used as a topic id would append nothing at all here.
-        if (buffer.length !== UUID_SIZE) {
-            throw new RangeError(`Expected a UUID, got ${JSON.stringify(value)}.`);
-        }
         this.#buffer.append(buffer);
         return this;
     }
@@ -144,9 +138,7 @@ export class Writer {
         else {
             this.appendInt32(value.length);
         }
-        if (value.length > 0) {
-            this.#buffer.append(value);
-        }
+        this.#buffer.append(value);
         return this;
     }
     // Note that this does not follow the wire protocol specification and thus the length is not +1ed
@@ -155,12 +147,7 @@ export class Writer {
             return this.appendVarInt(-1);
         }
         this.appendVarInt(value.length);
-        // Appending an empty buffer corrupts DynamicBuffer's positional reads, so it must be skipped:
-        // see https://github.com/platformatic/dynamic-buffer/issues/12. Record keys and values are
-        // allowed to be empty without being null, so this is reachable.
-        if (value.length > 0) {
-            this.#buffer.append(value);
-        }
+        this.#buffer.append(value);
         return this;
     }
     appendArray(value, entryWriter, compact = true, appendTrailingTaggedFields = true) {
@@ -223,7 +210,7 @@ export class Writer {
         }
         return this;
     }
-    // This client emits only empty tagged-field sections; it does not expose tagged fields to callers.
+    // TODO: Tagged fields are not supported yet
     appendTaggedFields(_ = []) {
         return this.append(EMPTY_TAGGED_FIELDS_BUFFER);
     }

package/dist/registries/abstract.js

@@ -1,19 +1,38 @@
 export function runAsyncSeries(operation, collection, index, callback) {
-    if (collection.length === 0 || index >= collection.length) {
+    const length = collection.length;
+    if (length === 0 || index >= length) {
         callback(null);
         return;
     }
-    operation(collection[index], error => {
-        if (error) {
-            callback(error);
+    while (index < length) {
+        let invocationReturned = false;
+        let cbCalled = false;
+        let cbError;
+        operation(collection[index], error => {
+            if (invocationReturned) {
+                // The callback was invoked asynchronously, so continuing recursively does not grow the current stack.
+                if (error) {
+                    callback(error);
+                    return;
+                }
+                runAsyncSeries(operation, collection, index + 1, callback);
+                return;
+            }
+            cbCalled = true;
+            cbError = error;
+        });
+        invocationReturned = true;
+        if (!cbCalled) {
+            // Wait for the async callback to continue the series.
             return;
         }
-        else if (index === collection.length - 1) {
-            callback(null);
+        if (cbError) {
+            callback(cbError);
             return;
         }
-        runAsyncSeries(operation, collection, index + 1, callback);
-    });
+        index++;
+    }
+    callback(null);
 }
 /* c8 ignore start */
 export class AbstractSchemaRegistry {

package/dist/registries/confluent-schema-registry.js

@@ -1,3 +1,5 @@
+import * as AjvDraft04Module from 'ajv-draft-04';
+import draft06MetaSchema from 'ajv/dist/refs/json-schema-draft-06.json' with { type: 'json' };
 import { Ajv } from 'ajv';
 import { Ajv2020 } from 'ajv/dist/2020.js';
 import avro from 'avsc';
@@ -8,8 +10,7 @@ import { EMPTY_BUFFER, MultipleErrors, NetworkError, TimeoutError, UnsupportedFo
 import { getCredential } from "../protocol/sasl/utils.js";
 import { AbstractSchemaRegistry } from "./abstract.js";
 const require = createRequire(import.meta.url);
-const AjvDraft04 = require('ajv-draft-04');
-const draft06MetaSchema = require('ajv/dist/refs/json-schema-draft-06.json');
+const AjvDraft04 = AjvDraft04Module.default;
 const undiciGlobalDispatcherSymbol = /^undici\.globalDispatcher\.(\d+)$/;
 export function createUndiciAgent(options) {
     /*

package/dist/symbols.d.ts

@@ -2,6 +2,7 @@ export declare const kInstance: unique symbol;
 export declare const kRefreshOffsetsAndFetch: unique symbol;
 export declare const kAutocommit: unique symbol;
 export declare const kGetFetchNode: unique symbol;
+export declare const kDeserializationError: unique symbol;
 export declare const kTransaction: unique symbol;
 export declare const kTransactionPrepare: unique symbol;
 export declare const kTransactionAddPartitions: unique symbol;

package/dist/symbols.js

@@ -3,6 +3,7 @@ export const kInstance = Symbol('plt.kafka.base.instance');
 export const kRefreshOffsetsAndFetch = Symbol('plt.kafka.messagesStream.refreshOffsetsAndFetch');
 export const kAutocommit = Symbol('plt.kafka.messagesStream.autocommit');
 export const kGetFetchNode = Symbol('plt.kafka.consumer.getFetchNode');
+export const kDeserializationError = Symbol('plt.kafka.messagesStream.deserializationError');
 export const kTransaction = Symbol('plt.kafka.producer.transactions');
 export const kTransactionPrepare = Symbol('plt.kafka.producer.transactions.prepare');
 export const kTransactionAddPartitions = Symbol('plt.kafka.producer.transactions.addPartitions');

package/dist/typescript-4/dist/apis/admin/alter-client-quotas-v1.d.ts

@@ -1,19 +1,18 @@
 import { type NullableString } from "../../protocol/definitions";
 import { type Reader } from "../../protocol/reader";
 import { Writer } from "../../protocol/writer";
-import type { ClientQuotaEntityType, ClientQuotaKey } from "../enumerations";
-export type { ClientQuotaEntityType, ClientQuotaKey } from "../enumerations";
+import { type ClientQuotaEntityTypeValue, type ClientQuotaKeyValue } from "../enumerations";
 export interface AlterClientQuotasRequestEntity {
-  entityType: ClientQuotaEntityType;
+  entityType: ClientQuotaEntityTypeValue;
   entityName?: NullableString;
 }
 export interface AlterClientQuotaRequestOpAddition {
-  key: ClientQuotaKey;
+  key: ClientQuotaKeyValue;
   value: number;
   remove: false;
 }
 export interface AlterClientQuotaRequestOpRemoval {
-  key: ClientQuotaKey;
+  key: ClientQuotaKeyValue;
   remove: true;
 }
 export type AlterClientQuotasRequestOp = AlterClientQuotaRequestOpAddition | AlterClientQuotaRequestOpRemoval;
@@ -23,7 +22,7 @@ export interface AlterClientQuotasRequestEntry {
 }
 export type AlterClientQuotasRequest = Parameters<typeof createRequest>;
 export interface AlterClientQuotasResponseEntity {
-  entityType: ClientQuotaEntityType;
+  entityType: string;
   entityName: NullableString;
 }
 export interface AlterClientQuotasResponseEntries {

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

@@ -1,9 +1,9 @@
-import { type Nullable, type NullableString } from "../../protocol/definitions";
+import { type NullableString } from "../../protocol/definitions";
 import { type Reader } from "../../protocol/reader";
 import { Writer } from "../../protocol/writer";
 export interface AlterPartitionReassignmentsRequestPartition {
   partitionIndex: number;
-  replicas: Nullable<number[]>;
+  replicas: number[];
 }
 export interface AlterPartitionReassignmentsRequestTopic {
   name: string;
@@ -21,7 +21,6 @@ export interface AlterPartitionReassignmentsResponseResponse {
 }
 export interface AlterPartitionReassignmentsResponse {
   throttleTimeMs: number;
-  allowReplicationFactorChange: boolean;
   errorCode: number;
   errorMessage: NullableString;
   responses: AlterPartitionReassignmentsResponseResponse[];

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

@@ -1,9 +1,9 @@
-import { type Nullable, type NullableString } from "../../protocol/definitions";
+import { type NullableString } from "../../protocol/definitions";
 import { type Reader } from "../../protocol/reader";
 import { Writer } from "../../protocol/writer";
 export interface AlterPartitionReassignmentsRequestPartition {
   partitionIndex: number;
-  replicas: Nullable<number[]>;
+  replicas: number[];
 }
 export interface AlterPartitionReassignmentsRequestTopic {
   name: string;
@@ -15,17 +15,15 @@ export interface AlterPartitionReassignmentsResponsePartition {
   errorCode: number;
   errorMessage: NullableString;
 }
-export interface AlterPartitionReassignmentsResponseTopic {
+export interface AlterPartitionReassignmentsResponseResponse {
   name: string;
   partitions: AlterPartitionReassignmentsResponsePartition[];
 }
-export type AlterPartitionReassignmentsResponseResponse = AlterPartitionReassignmentsResponseTopic;
 export interface AlterPartitionReassignmentsResponse {
   throttleTimeMs: number;
-  allowReplicationFactorChange: boolean;
   errorCode: number;
   errorMessage: NullableString;
-  responses: AlterPartitionReassignmentsResponseTopic[];
+  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;

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

@@ -1,10 +1,39 @@
 import { type Reader } from "../../protocol/reader";
 import { Writer } from "../../protocol/writer";
-import type { AlterPartitionRequestPartition, AlterPartitionRequestTopic, AlterPartitionResponse, AlterPartitionResponsePartition, AlterPartitionResponseTopic } from "./alter-partition-v2";
-import type { AlterPartitionRequestBroker } from "./alter-partition-v0";
-export type { AlterPartitionRequestPartition, AlterPartitionRequestTopic, AlterPartitionResponse, AlterPartitionResponsePartition, AlterPartitionResponseTopic };
-export type AlterPartitionRequestISR = AlterPartitionRequestBroker;
+export interface AlterPartitionRequestISR {
+  brokerId: number;
+  brokerEpoch: bigint;
+}
+export interface AlterPartitionRequestPartition {
+  partitionIndex: number;
+  leaderEpoch: number;
+  newIsrWithEpochs: AlterPartitionRequestISR[];
+  leaderRecoveryState: number;
+  partitionEpoch: number;
+}
+export interface AlterPartitionRequestTopic {
+  topicId: string;
+  partitions: AlterPartitionRequestPartition[];
+}
 export type AlterPartitionRequest = Parameters<typeof createRequest>;
-export declare function createRequest(brokerId: number, brokerEpoch: bigint, topics: AlterPartitionRequestTopic[]): Writer;
+export interface AlterPartitionResponsePartition {
+  partitionIndex: number;
+  errorCode: number;
+  leaderId: number;
+  leaderEpoch: number;
+  isr: number;
+  leaderRecoveryState: number;
+  partitionEpoch: number;
+}
+export interface AlterPartitionResponseTopic {
+  topicId: string;
+  partitions: AlterPartitionResponsePartition[];
+}
+export interface AlterPartitionResponse {
+  throttleTimeMs: number;
+  errorCode: number;
+  topics: AlterPartitionResponseTopic[];
+}
+export declare function createRequest(brokerId: number, brokerEpoch: bigint, topic: AlterPartitionRequestTopic[]): Writer;
 export declare function parseResponse(_correlationId: number, apiKey: number, apiVersion: number, reader: Reader): AlterPartitionResponse;
-export declare const api: import("../definitions").API<[brokerId: number, brokerEpoch: bigint, topics: AlterPartitionRequestTopic[]], AlterPartitionResponse>;
+export declare const api: import("../definitions").API<[brokerId: number, brokerEpoch: bigint, topic: AlterPartitionRequestTopic[]], AlterPartitionResponse>;

package/dist/typescript-4/dist/apis/admin/alter-replica-log-dirs-v2.d.ts

@@ -18,7 +18,7 @@ export interface AlterReplicaLogDirsResponseResult {
   partitions: AlterReplicaLogDirsResponsePartition[];
 }
 export interface AlterReplicaLogDirsResponse {
-  throttleTimeMs: number;
+  throttleTimeMs?: number;
   results: AlterReplicaLogDirsResponseResult[];
 }
 export declare function createRequest(dirs: AlterReplicaLogDirsRequestDir[]): Writer;