@platformatic/kafka 2.7.0 → 2.9.0-alpha.1

package/dist/network/connection.js

@@ -4,7 +4,8 @@ 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 { saslAuthenticateV2, saslHandshakeV1 } from "../apis/index.js";
+import { clientSoftwareName, clientSoftwareVersion } from "../clients/base/options.js";
+import { apiVersionsV1, saslAuthenticateV0, saslAuthenticateV1, 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";
@@ -52,6 +53,8 @@ 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);
@@ -340,28 +343,71 @@ export class Connection extends TypedEventEmitter {
             this.#onConnectionError(host, port, diagnosticContext, new UserError(`SASL mechanism ${mechanism} not supported.`));
             return;
         }
-        saslHandshakeV1.api(this, mechanism, (error, response) => {
+        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 */
             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, 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.'));
+                selected = undefined;
             }
             else {
-                saslScramSha.authenticate(saslAuthenticateV2.api, this, mechanism.substring(6), username, password, defaultCrypto, callback);
+                const advertised = response.apiKeys.find(api => api.apiKey === saslAuthenticateV2.api.key);
+                selected = candidates.find(([version]) => advertised && version >= advertised.minVersion && version <= advertised.maxVersion)?.[1];
             }
+            // 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/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;
-// TODO: Tagged fields are not supported yet
+// Flexible-version messages use this zero-length tagged-field section.
 export const EMPTY_TAGGED_FIELDS_BUFFER = Buffer.from([0]);

package/dist/protocol/reader.js

@@ -300,7 +300,7 @@ export class Reader {
         }
         return reader();
     }
-    // TODO: Tagged fields are not supported yet
+    // Skip unknown tagged fields because codecs do not expose them to callers.
     readTaggedFields() {
         const length = this.readUnsignedVarInt();
         for (let i = 0; i < length; i++) {

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 } from "./definitions.js";
+import { EMPTY_TAGGED_FIELDS_BUFFER, EMPTY_UUID, UUID_SIZE } from "./definitions.js";
 const instanceIdentifier = Symbol('plt.kafka.writer.instanceIdentifier');
 export class Writer {
     context;
@@ -125,6 +125,12 @@ 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;
     }
@@ -138,7 +144,9 @@ export class Writer {
         else {
             this.appendInt32(value.length);
         }
-        this.#buffer.append(value);
+        if (value.length > 0) {
+            this.#buffer.append(value);
+        }
         return this;
     }
     // Note that this does not follow the wire protocol specification and thus the length is not +1ed
@@ -147,7 +155,12 @@ export class Writer {
             return this.appendVarInt(-1);
         }
         this.appendVarInt(value.length);
-        this.#buffer.append(value);
+        // 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);
+        }
         return this;
     }
     appendArray(value, entryWriter, compact = true, appendTrailingTaggedFields = true) {
@@ -210,7 +223,7 @@ export class Writer {
         }
         return this;
     }
-    // TODO: Tagged fields are not supported yet
+    // This client emits only empty tagged-field sections; it does not expose tagged fields to callers.
     appendTaggedFields(_ = []) {
         return this.append(EMPTY_TAGGED_FIELDS_BUFFER);
     }

package/dist/registries/confluent-schema-registry.d.ts

@@ -1,9 +1,9 @@
-import { type Options, type ValidateFunction } from 'ajv';
+import { type ErrorObject, type Options, type ValidateFunction } from 'ajv';
 import { type Type } from 'avsc';
 import { type Root } from 'protobufjs';
 import { type Callback } from '../apis/definitions.ts';
 import { type BeforeDeserializationHook, type BeforeHookPayloadType, type BeforeSerializationHook, type Deserializers, type Serializers } from '../clients/serde.ts';
-import { type CredentialProvider } from '../index.ts';
+import { type CredentialProvider, UserError } from '../index.ts';
 import { type MessageToConsume, type MessageToProduce } from '../protocol/records.ts';
 import { AbstractSchemaRegistry } from './abstract.ts';
 type ConfluentSchemaRegistryMessageToProduce = MessageToProduce<unknown, unknown, unknown, unknown>;
@@ -22,6 +22,28 @@ export interface ConfluentSchemaRegistryOptions {
     jsonValidateSend?: boolean;
     jsonAjvOptions?: Options;
 }
+export type SchemaValidationPhase = 'serialization' | 'deserialization';
+export interface SchemaValidationErrorProperties {
+    schemaId: number;
+    schemaType: 'json';
+    phase: SchemaValidationPhase;
+    payloadType: BeforeHookPayloadType;
+    type: BeforeHookPayloadType;
+    data: unknown;
+    headers?: ReadonlyMap<unknown, unknown>;
+    validationErrors: ErrorObject[] | null | undefined;
+}
+export declare class SchemaValidationError extends UserError {
+    readonly schemaId: number;
+    readonly schemaType: 'json';
+    readonly phase: SchemaValidationPhase;
+    readonly payloadType: BeforeHookPayloadType;
+    readonly type: BeforeHookPayloadType;
+    readonly data: unknown;
+    readonly headers?: ReadonlyMap<unknown, unknown>;
+    readonly validationErrors: ErrorObject[] | null | undefined;
+    constructor(message: string, properties: SchemaValidationErrorProperties);
+}
 export interface Schema {
     id: number;
     type: 'avro' | 'protobuf' | 'json';

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

@@ -1,3 +1,4 @@
+import { Ajv } from 'ajv';
 import { Ajv2020 } from 'ajv/dist/2020.js';
 import avro from 'avsc';
 import { createRequire } from 'node:module';
@@ -6,6 +7,14 @@ import { EMPTY_BUFFER, UnsupportedFormatError, UserError } from "../index.js";
 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');
+export class SchemaValidationError extends UserError {
+    constructor(message, properties) {
+        super(message, properties);
+        this.name = 'SchemaValidationError';
+    }
+}
 /* c8 ignore next 8 */
 export function defaultProtobufTypeMapper(_, type, context) {
     // Confluent Schema Registry convention
@@ -18,6 +27,8 @@ export class ConfluentSchemaRegistry extends AbstractSchemaRegistry {
     #protobufTypeMapper;
     #jsonValidateSend;
     #jsonAjv;
+    #jsonAjvDraft7;
+    #jsonAjvDraft04;
     #pendingFetches;
     #auth;
     constructor(options) {
@@ -26,7 +37,11 @@ export class ConfluentSchemaRegistry extends AbstractSchemaRegistry {
         this.#schemas = new Map();
         this.#protobufTypeMapper = options.protobufTypeMapper ?? defaultProtobufTypeMapper;
         this.#jsonValidateSend = options.jsonValidateSend ?? false;
-        this.#jsonAjv = new Ajv2020({ allErrors: true, coerceTypes: false, strict: true, ...options.jsonAjvOptions });
+        const jsonAjvOptions = { allErrors: true, coerceTypes: false, strict: true, ...options.jsonAjvOptions };
+        this.#jsonAjv = new Ajv2020(jsonAjvOptions);
+        this.#jsonAjvDraft7 = new Ajv(jsonAjvOptions);
+        this.#jsonAjvDraft7.addMetaSchema(draft06MetaSchema);
+        this.#jsonAjvDraft04 = new AjvDraft04(jsonAjvOptions);
         this.#auth = options.auth;
         this.#pendingFetches = new Map();
     }
@@ -145,10 +160,24 @@ export class ConfluentSchemaRegistry extends AbstractSchemaRegistry {
                 this.#protobufParse ??= this.#loadProtobuf();
                 this.#schemas.set(id, { id, type: 'protobuf', schema: this.#protobufParse(schema).root });
                 break;
-            case 'JSON':
-                this.#schemas.set(id, { id, type: 'json', schema: this.#jsonAjv.compile(JSON.parse(schema)) });
+            case 'JSON': {
+                const jsonSchema = JSON.parse(schema);
+                this.#schemas.set(id, { id, type: 'json', schema: this.#getJsonAjv(jsonSchema).compile(jsonSchema) });
                 break;
+            }
+        }
+    }
+    #getJsonAjv(schema) {
+        if (typeof schema !== 'object' || schema === null || typeof schema.$schema !== 'string') {
+            return this.#jsonAjv;
+        }
+        if (schema.$schema.includes('draft-04')) {
+            return this.#jsonAjvDraft04;
+        }
+        if (schema.$schema.includes('draft-06') || schema.$schema.includes('draft-07')) {
+            return this.#jsonAjvDraft7;
         }
+        return this.#jsonAjv;
     }
     #schemaSerializer(type, fallbackSerializer, data, headers, message) {
         /* c8 ignore next 3 - Hard to test */
@@ -183,7 +212,16 @@ export class ConfluentSchemaRegistry extends AbstractSchemaRegistry {
                     const validate = schema.schema;
                     const valid = validate(data);
                     if (!valid) {
-                        throw new UserError(`JSON Schema validation failed before serialization: ${this.#jsonAjv.errorsText(validate.errors)}`, { type, data, headers, validationErrors: validate.errors });
+                        throw new SchemaValidationError(`JSON Schema validation failed before serialization: ${this.#jsonAjv.errorsText(validate.errors)}`, {
+                            schemaId,
+                            schemaType: 'json',
+                            phase: 'serialization',
+                            payloadType: type,
+                            type,
+                            data,
+                            headers,
+                            validationErrors: validate.errors
+                        });
                     }
                 }
                 encodedMessage = Buffer.from(JSON.stringify(data));
@@ -222,7 +260,16 @@ export class ConfluentSchemaRegistry extends AbstractSchemaRegistry {
                 const validate = schema.schema;
                 const valid = validate(parsed);
                 if (!valid) {
-                    throw new UserError(`JSON Schema validation failed before deserialization: ${this.#jsonAjv.errorsText(validate.errors)}`, { type, data: parsed, headers, validationErrors: validate.errors });
+                    throw new SchemaValidationError(`JSON Schema validation failed before deserialization: ${this.#jsonAjv.errorsText(validate.errors)}`, {
+                        schemaId,
+                        schemaType: 'json',
+                        phase: 'deserialization',
+                        payloadType: type,
+                        type,
+                        data: parsed,
+                        headers,
+                        validationErrors: validate.errors
+                    });
                 }
                 return parsed;
             }

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

@@ -0,0 +1,40 @@
+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";
+export interface AlterClientQuotasRequestEntity {
+  entityType: ClientQuotaEntityType;
+  entityName?: NullableString;
+}
+export interface AlterClientQuotaRequestOpAddition {
+  key: ClientQuotaKey;
+  value: number;
+  remove: false;
+}
+export interface AlterClientQuotaRequestOpRemoval {
+  key: ClientQuotaKey;
+  remove: true;
+}
+export type AlterClientQuotasRequestOp = AlterClientQuotaRequestOpAddition | AlterClientQuotaRequestOpRemoval;
+export interface AlterClientQuotasRequestEntry {
+  entities: AlterClientQuotasRequestEntity[];
+  ops: AlterClientQuotasRequestOp[];
+}
+export type AlterClientQuotasRequest = Parameters<typeof createRequest>;
+export interface AlterClientQuotasResponseEntity {
+  entityType: ClientQuotaEntityType;
+  entityName: NullableString;
+}
+export interface AlterClientQuotasResponseEntries {
+  errorCode: number;
+  errorMessage: NullableString;
+  entity: AlterClientQuotasResponseEntity[];
+}
+export interface AlterClientQuotasResponse {
+  throttleTimeMs: number;
+  entries: AlterClientQuotasResponseEntries[];
+}
+export declare function createRequest(entries: AlterClientQuotasRequestEntry[], validateOnly: boolean): Writer;
+export declare function parseResponse(_correlationId: number, apiKey: number, apiVersion: number, reader: Reader): AlterClientQuotasResponse;
+export declare const api: import("../definitions").API<[entries: AlterClientQuotasRequestEntry[], validateOnly: boolean], AlterClientQuotasResponse>;

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

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

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

@@ -0,0 +1,7 @@
+import { type Reader } from "../../protocol/reader";
+import { Writer } from "../../protocol/writer";
+import { type AlterConfigsRequestResource, type AlterConfigsResponse } from "./alter-configs-v2";
+export * from "./alter-configs-v2";
+export declare function createRequest(resources: AlterConfigsRequestResource[], validateOnly: boolean): Writer;
+export declare function parseResponse(_: number, apiKey: number, apiVersion: number, reader: Reader): AlterConfigsResponse;
+export declare const api: import("../definitions").API<unknown[], AlterConfigsResponse>;

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

@@ -0,0 +1,2 @@
+export * from "./alter-configs-v0";
+export declare const api: import("../definitions").API<unknown[], import("./alter-configs-v2").AlterConfigsResponse>;

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

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

@@ -0,0 +1,40 @@
+import { type Reader } from "../../protocol/reader";
+import { Writer } from "../../protocol/writer";
+export interface AlterPartitionRequestPartition {
+  partitionIndex: number;
+  leaderEpoch: number;
+  newIsrWithEpochs: AlterPartitionRequestBroker[];
+  leaderRecoveryState?: number;
+  partitionEpoch: number;
+}
+export interface AlterPartitionRequestBroker {
+  brokerId: number;
+  brokerEpoch: bigint;
+}
+export interface AlterPartitionRequestTopic {
+  topicName: string;
+  partitions: AlterPartitionRequestPartition[];
+}
+export type AlterPartitionRequest = Parameters<typeof createRequest>;
+export interface AlterPartitionResponsePartition {
+  partitionIndex: number;
+  errorCode: number;
+  leaderId: number;
+  leaderEpoch: number;
+  isr: number[];
+  leaderRecoveryState: number;
+  partitionEpoch: number;
+}
+export interface AlterPartitionResponseTopic {
+  topicName: string;
+  topicId: string;
+  partitions: AlterPartitionResponsePartition[];
+}
+export interface AlterPartitionResponse {
+  throttleTimeMs: number;
+  errorCode: number;
+  topics: AlterPartitionResponseTopic[];
+}
+export declare function createRequest(brokerId: number, brokerEpoch: bigint, topics: 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>;

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

@@ -0,0 +1,37 @@
+import { type Reader } from "../../protocol/reader";
+import { Writer } from "../../protocol/writer";
+import type { AlterPartitionRequestBroker } from "./alter-partition-v0";
+export interface AlterPartitionRequestPartition {
+  partitionIndex: number;
+  leaderEpoch: number;
+  newIsrWithEpochs: AlterPartitionRequestBroker[];
+  leaderRecoveryState: number;
+  partitionEpoch: number;
+}
+export interface AlterPartitionRequestTopic {
+  topicName: string;
+  partitions: AlterPartitionRequestPartition[];
+}
+export type AlterPartitionRequest = Parameters<typeof createRequest>;
+export interface AlterPartitionResponsePartition {
+  partitionIndex: number;
+  errorCode: number;
+  leaderId: number;
+  leaderEpoch: number;
+  isr: number[];
+  leaderRecoveryState: number;
+  partitionEpoch: number;
+}
+export interface AlterPartitionResponseTopic {
+  topicName: string;
+  topicId: string;
+  partitions: AlterPartitionResponsePartition[];
+}
+export interface AlterPartitionResponse {
+  throttleTimeMs: number;
+  errorCode: number;
+  topics: AlterPartitionResponseTopic[];
+}
+export declare function createRequest(brokerId: number, brokerEpoch: bigint, topics: 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>;

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

@@ -0,0 +1,36 @@
+import { type Reader } from "../../protocol/reader";
+import { Writer } from "../../protocol/writer";
+import type { AlterPartitionRequestBroker } from "./alter-partition-v0";
+export interface AlterPartitionRequestPartition {
+  partitionIndex: number;
+  leaderEpoch: number;
+  newIsrWithEpochs: AlterPartitionRequestBroker[];
+  leaderRecoveryState: number;
+  partitionEpoch: number;
+}
+export interface AlterPartitionRequestTopic {
+  topicId: string;
+  partitions: AlterPartitionRequestPartition[];
+}
+export type AlterPartitionRequest = Parameters<typeof createRequest>;
+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, topics: 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>;

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

@@ -1,39 +1,10 @@
 import { type Reader } from "../../protocol/reader";
 import { Writer } from "../../protocol/writer";
-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[];
-}
+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 type AlterPartitionRequest = Parameters<typeof createRequest>;
-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 createRequest(brokerId: number, brokerEpoch: bigint, topics: 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, topic: AlterPartitionRequestTopic[]], AlterPartitionResponse>;
+export declare const api: import("../definitions").API<[brokerId: number, brokerEpoch: bigint, topics: AlterPartitionRequestTopic[]], AlterPartitionResponse>;

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

@@ -0,0 +1,23 @@
+import { type Reader } from "../../protocol/reader";
+import { Writer } from "../../protocol/writer";
+export interface AlterReplicaLogDirsRequestDir {
+  path: string;
+  topics: {
+    name: string;
+    partitions: number[];
+  }[];
+}
+export type AlterReplicaLogDirsRequest = Parameters<typeof createRequest>;
+export interface AlterReplicaLogDirsResponse {
+  throttleTimeMs: number;
+  results: {
+    topicName: string;
+    partitions: {
+      partitionIndex: number;
+      errorCode: number;
+    }[];
+  }[];
+}
+export declare function createRequest(dirs: AlterReplicaLogDirsRequestDir[]): Writer;
+export declare function parseResponse(_: number, apiKey: number, apiVersion: number, reader: Reader): AlterReplicaLogDirsResponse;
+export declare const api: import("../definitions").API<[dirs: AlterReplicaLogDirsRequestDir[]], AlterReplicaLogDirsResponse>;