@platformatic/kafka 1.17.0 → 1.18.0

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

@@ -1,15 +1,21 @@
 import { type NullableString } from '../../protocol/definitions.ts';
 import { type Reader } from '../../protocol/reader.ts';
 import { Writer } from '../../protocol/writer.ts';
+import { type ClientQuotaEntityType, type ClientQuotaKey } from '../enumerations.ts';
 export interface AlterClientQuotasRequestEntity {
-    entityType: string;
-    entityName: NullableString;
+    entityType: ClientQuotaEntityType;
+    entityName?: NullableString;
 }
-export interface AlterClientQuotasRequestOp {
-    key: string;
+export interface AlterClientQuotaRequestOpAddition {
+    key: ClientQuotaKey;
     value: number;
-    remove: boolean;
+    remove: false;
+}
+export interface AlterClientQuotaRequestOpRemoval {
+    key: ClientQuotaKey;
+    remove: true;
 }
+export type AlterClientQuotasRequestOp = AlterClientQuotaRequestOpAddition | AlterClientQuotaRequestOpRemoval;
 export interface AlterClientQuotasRequestEntry {
     entities: AlterClientQuotasRequestEntity[];
     ops: AlterClientQuotasRequestOp[];

package/dist/apis/admin/alter-client-quotas-v1.js

@@ -19,7 +19,9 @@ export function createRequest(entries, validateOnly) {
         w.appendArray(e.entities, (w, e) => {
             w.appendString(e.entityType).appendString(e.entityName);
         }).appendArray(e.ops, (w, o) => {
-            w.appendString(o.key).appendFloat64(o.value).appendBoolean(o.remove);
+            w.appendString(o.key)
+                .appendFloat64(o.value ?? 0)
+                .appendBoolean(o.remove);
         });
     })
         .appendBoolean(validateOnly)

package/dist/apis/admin/describe-client-quotas-v0.d.ts

@@ -1,18 +1,24 @@
 import { type NullableString } from '../../protocol/definitions.ts';
 import { type Reader } from '../../protocol/reader.ts';
 import { Writer } from '../../protocol/writer.ts';
-export interface DescribeClientQuotasRequestComponent {
-    entityType: string;
-    matchType: number;
-    match: string | null;
+import { type ClientQuotaEntityType, type ClientQuotaKey, type ClientQuotaMatchTypes } from '../enumerations.ts';
+export interface DescribeClientQuotasRequestMatchComponent {
+    entityType: ClientQuotaEntityType;
+    matchType: typeof ClientQuotaMatchTypes.EXACT;
+    match: string;
 }
+export interface DescribeClientQuotasRequestSpecialComponent {
+    entityType: ClientQuotaEntityType;
+    matchType: typeof ClientQuotaMatchTypes.DEFAULT | typeof ClientQuotaMatchTypes.ANY;
+}
+export type DescribeClientQuotasRequestComponent = DescribeClientQuotasRequestMatchComponent | DescribeClientQuotasRequestSpecialComponent;
 export type DescribeClientQuotasRequest = Parameters<typeof createRequest>;
 export interface DescribeClientQuotasResponseValue {
-    key: string;
+    key: ClientQuotaKey;
     value: number;
 }
 export interface DescribeClientQuotasResponseEntity {
-    entityType: string;
+    entityType: ClientQuotaEntityType;
     entityName: NullableString;
 }
 export interface DescribeClientQuotasResponseEntry {

package/dist/apis/admin/describe-client-quotas-v0.js

@@ -12,6 +12,7 @@ import { createAPI } from "../definitions.js";
 export function createRequest(components, strict) {
     return Writer.create()
         .appendArray(components, (w, c) => {
+        // @ts-ignore - TS complains that 'match' is not available in all variants of DescribeClientQuotasRequestComponent
         w.appendString(c.entityType).appendInt8(c.matchType).appendString(c.match);
     })
         .appendBoolean(strict)

package/dist/apis/callbacks.d.ts

@@ -7,3 +7,4 @@ export type CallbackWithPromise<ReturnType> = Callback<ReturnType> & {
 };
 export declare function createPromisifiedCallback<ReturnType>(): CallbackWithPromise<ReturnType>;
 export declare function runConcurrentCallbacks<ReturnType>(errorMessage: string, collection: unknown[] | Set<unknown> | Map<unknown, unknown>, operation: (item: any, cb: Callback<ReturnType>) => void, callback: Callback<ReturnType[]>): void;
+export declare function createTimeoutCallback<ReturnType>(callback: Callback<ReturnType>, timeout: number, errorMessage: string): Callback<ReturnType>;

package/dist/apis/callbacks.js

@@ -1,4 +1,4 @@
-import { MultipleErrors } from "../errors.js";
+import { MultipleErrors, TimeoutError } from "../errors.js";
 import { PromiseWithResolvers } from "../utils.js";
 export const kCallbackPromise = Symbol('plt.kafka.callbackPromise');
 // This is only meaningful for testing
@@ -45,3 +45,17 @@ export function runConcurrentCallbacks(errorMessage, collection, operation, call
         operation(item, operationCallback.bind(null, i++));
     }
 }
+export function createTimeoutCallback(callback, timeout, errorMessage) {
+    let timeoutFired = false;
+    const timeoutHandle = setTimeout(() => {
+        timeoutFired = true;
+        callback(new TimeoutError(errorMessage), undefined);
+    }, timeout);
+    return (error, result) => {
+        if (timeoutFired) {
+            return;
+        }
+        clearTimeout(timeoutHandle);
+        callback(error, result);
+    };
+}

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

@@ -20,7 +20,7 @@ export interface ConsumerGroupHeartbeatResponse {
     memberId: NullableString;
     memberEpoch: number;
     heartbeatIntervalMs: number;
-    assignment: ConsumerGroupHeartbeatResponseAssignment[];
+    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 parseResponse(_correlationId: number, apiKey: number, apiVersion: number, reader: Reader): ConsumerGroupHeartbeatResponse;

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

@@ -51,16 +51,14 @@ export function parseResponse(_correlationId, apiKey, apiVersion, reader) {
         memberId: reader.readNullableString(),
         memberEpoch: reader.readInt32(),
         heartbeatIntervalMs: reader.readInt32(),
-        assignment: reader.readArray(r => {
-            return {
-                topicPartitions: r.readArray(r => {
-                    return {
-                        topicId: r.readUUID(),
-                        partitions: r.readArray(r => r.readInt32(), true, false)
-                    };
-                })
-            };
-        })
+        assignment: reader.readNullableStruct(() => ({
+            topicPartitions: reader.readArray(r => {
+                return {
+                    topicId: r.readUUID(),
+                    partitions: r.readArray(r => r.readInt32(), true, false)
+                };
+            })
+        }))
     };
     if (response.errorCode !== 0) {
         throw new ResponseError(apiKey, apiVersion, { '': response.errorCode }, response);

package/dist/apis/enumerations.d.ts

@@ -20,6 +20,12 @@ export declare const ProduceAcks: {
 };
 export declare const allowedProduceAcks: number[];
 export type ProduceAck = keyof typeof ProduceAcks;
+export declare const GroupProtocols: {
+    readonly CLASSIC: "classic";
+    readonly CONSUMER: "consumer";
+};
+export declare const allowedGroupProtocols: ("consumer" | "classic")[];
+export type GroupProtocol = keyof typeof GroupProtocols;
 export declare const FetchIsolationLevels: {
     READ_UNCOMMITTED: number;
     READ_COMMITTED: number;
@@ -101,7 +107,18 @@ export declare const ClientQuotaMatchTypes: {
     readonly DEFAULT: 1;
     readonly ANY: 2;
 };
-export type ClientQuotaMatchType = keyof typeof ClientQuotaMatchTypes;
+export type ClientQuotaMatchType = (typeof ClientQuotaMatchTypes)[keyof typeof ClientQuotaMatchTypes];
+export declare const ClientQuotaEntityTypes: {
+    readonly CLIENT_ID: "client-id";
+    readonly USER: "user";
+};
+export type ClientQuotaEntityType = (typeof ClientQuotaEntityTypes)[keyof typeof ClientQuotaEntityTypes];
+export declare const ClientQuotaKeys: {
+    readonly PRODUCER_BYTE_RATE: "producer_byte_rate";
+    readonly CONSUMER_BYTE_RATE: "consumer_byte_rate";
+    readonly REQUEST_PERCENTAGE: "request_percentage";
+};
+export type ClientQuotaKey = (typeof ClientQuotaKeys)[keyof typeof ClientQuotaKeys];
 export declare const ScramMechanisms: {
     readonly UNKNOWN: 0;
     readonly SCRAM_SHA_256: 1;

package/dist/apis/enumerations.js

@@ -17,6 +17,8 @@ export const ProduceAcks = {
 };
 export const allowedProduceAcks = Object.values(ProduceAcks);
 // Consumer API
+export const GroupProtocols = { CLASSIC: 'classic', CONSUMER: 'consumer' };
+export const allowedGroupProtocols = Object.values(GroupProtocols);
 // ./consumer/fetch.ts
 export const FetchIsolationLevels = { READ_UNCOMMITTED: 0, READ_COMMITTED: 1 };
 export const allowedFetchIsolationLevels = Object.values(FetchIsolationLevels);
@@ -68,6 +70,12 @@ export const ConfigTypes = {
 export const IncrementalAlterConfigTypes = { SET: 0, DELETE: 1, APPEND: 2, SUBTRACT: 3 };
 // ./admin/*-client-quotas.ts
 export const ClientQuotaMatchTypes = { EXACT: 0, DEFAULT: 1, ANY: 2 };
+export const ClientQuotaEntityTypes = { CLIENT_ID: 'client-id', USER: 'user' };
+export const ClientQuotaKeys = {
+    PRODUCER_BYTE_RATE: 'producer_byte_rate',
+    CONSUMER_BYTE_RATE: 'consumer_byte_rate',
+    REQUEST_PERCENTAGE: 'request_percentage'
+};
 // ./admin/*-scram-credentials.ts
 export const ScramMechanisms = { UNKNOWN: 0, SCRAM_SHA_256: 1, SCRAM_SHA_512: 2 };
 // ./admin/describe-cluster.ts

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

@@ -1,7 +1,9 @@
+import { type AlterClientQuotasResponseEntries } from '../../apis/admin/alter-client-quotas-v1.ts';
+import { type DescribeClientQuotasResponseEntry } from '../../apis/admin/describe-client-quotas-v0.ts';
 import { type CallbackWithPromise } from '../../apis/callbacks.ts';
 import { type Callback } from '../../apis/definitions.ts';
 import { Base } from '../base/base.ts';
-import { type AdminOptions, type CreatedTopic, type CreateTopicsOptions, type DeleteGroupsOptions, type DeleteTopicsOptions, type DescribeGroupsOptions, type Group, type GroupBase, type ListGroupsOptions, type ListTopicsOptions } from './types.ts';
+import { type AdminOptions, type AlterClientQuotasOptions, type BrokerLogDirDescription, type CreatedTopic, type CreateTopicsOptions, type DeleteGroupsOptions, type DeleteTopicsOptions, type DescribeClientQuotasOptions, type DescribeGroupsOptions, type DescribeLogDirsOptions, type Group, type GroupBase, type ListGroupsOptions, type ListTopicsOptions } from './types.ts';
 export declare class Admin extends Base<AdminOptions> {
     #private;
     constructor(options: AdminOptions);
@@ -17,4 +19,10 @@ export declare class Admin extends Base<AdminOptions> {
     describeGroups(options: DescribeGroupsOptions): Promise<Map<string, Group>>;
     deleteGroups(options: DeleteGroupsOptions, callback: CallbackWithPromise<void>): void;
     deleteGroups(options: DeleteGroupsOptions): Promise<void>;
+    describeClientQuotas(options: DescribeClientQuotasOptions, callback: CallbackWithPromise<DescribeClientQuotasResponseEntry[]>): void;
+    describeClientQuotas(options: DescribeClientQuotasOptions): Promise<DescribeClientQuotasResponseEntry[]>;
+    alterClientQuotas(options: AlterClientQuotasOptions, callback: CallbackWithPromise<AlterClientQuotasResponseEntries[]>): void;
+    alterClientQuotas(options: AlterClientQuotasOptions): Promise<AlterClientQuotasResponseEntries[]>;
+    describeLogDirs(options: DescribeLogDirsOptions, callback: CallbackWithPromise<BrokerLogDirDescription[]>): void;
+    describeLogDirs(options: DescribeLogDirsOptions): Promise<BrokerLogDirDescription[]>;
 }

package/dist/clients/admin/admin.js

@@ -1,9 +1,10 @@
 import { createPromisifiedCallback, kCallbackPromise, runConcurrentCallbacks } from "../../apis/callbacks.js";
 import { FindCoordinatorKeyTypes } from "../../apis/enumerations.js";
-import { adminGroupsChannel, adminTopicsChannel, createDiagnosticContext } from "../../diagnostic.js";
+import { adminClientQuotasChannel, adminGroupsChannel, adminLogDirsChannel, adminTopicsChannel, createDiagnosticContext } from "../../diagnostic.js";
+import { MultipleErrors } from "../../errors.js";
 import { Reader } from "../../protocol/reader.js";
 import { Base, kAfterCreate, kCheckNotClosed, kGetApi, kGetBootstrapConnection, kGetConnection, kMetadata, kOptions, kPerformDeduplicated, kPerformWithRetry, kValidateOptions } from "../base/base.js";
-import { createTopicsOptionsValidator, deleteGroupsOptionsValidator, deleteTopicsOptionsValidator, describeGroupsOptionsValidator, listGroupsOptionsValidator, listTopicsOptionsValidator } from "./options.js";
+import { alterClientQuotasOptionsValidator, createTopicsOptionsValidator, deleteGroupsOptionsValidator, deleteTopicsOptionsValidator, describeClientQuotasOptionsValidator, describeGroupsOptionsValidator, describeLogDirsOptionsValidator, listGroupsOptionsValidator, listTopicsOptionsValidator } from "./options.js";
 export class Admin extends Base {
     constructor(options) {
         super(options);
@@ -106,6 +107,52 @@ export class Admin extends Base {
         adminGroupsChannel.traceCallback(this.#deleteGroups, 1, createDiagnosticContext({ client: this, operation: 'deleteGroups', options }), this, options, callback);
         return callback[kCallbackPromise];
     }
+    describeClientQuotas(options, callback) {
+        if (!callback) {
+            callback = createPromisifiedCallback();
+        }
+        if (this[kCheckNotClosed](callback)) {
+            return callback[kCallbackPromise];
+        }
+        const validationError = this[kValidateOptions](options, describeClientQuotasOptionsValidator, '/options', false);
+        if (validationError) {
+            callback(validationError, undefined);
+            return callback[kCallbackPromise];
+        }
+        adminClientQuotasChannel.traceCallback(this.#describeClientQuotas, 1, createDiagnosticContext({ client: this, operation: 'describeClientQuotas', options }), this, options, callback);
+        return callback[kCallbackPromise];
+    }
+    alterClientQuotas(options, callback) {
+        if (!callback) {
+            callback = createPromisifiedCallback();
+        }
+        if (this[kCheckNotClosed](callback)) {
+            return callback[kCallbackPromise];
+        }
+        const validationError = this[kValidateOptions](options, alterClientQuotasOptionsValidator, '/options', false);
+        if (validationError) {
+            callback(validationError, undefined);
+            return callback[kCallbackPromise];
+        }
+        adminClientQuotasChannel.traceCallback(this.#alterClientQuotas, 1, createDiagnosticContext({ client: this, operation: 'alterClientQuotas', options }), this, options, callback);
+        return callback[kCallbackPromise];
+    }
+    describeLogDirs(options, callback) {
+        if (!callback) {
+            callback = createPromisifiedCallback();
+        }
+        /* c8 ignore next 3 - Hard to test */
+        if (this[kCheckNotClosed](callback)) {
+            return callback[kCallbackPromise];
+        }
+        const validationError = this[kValidateOptions](options, describeLogDirsOptionsValidator, '/options', false);
+        if (validationError) {
+            callback(validationError, undefined);
+            return callback[kCallbackPromise];
+        }
+        adminLogDirsChannel.traceCallback(this.#describeLogDirs, 1, createDiagnosticContext({ client: this, operation: 'describeLogDirs', options }), this, options, callback);
+        return callback[kCallbackPromise];
+    }
     #listTopics(options, callback) {
         const includeInternals = options.includeInternals ?? false;
         this[kPerformDeduplicated]('metadata', deduplicateCallback => {
@@ -410,4 +457,91 @@ export class Admin extends Base {
             callback(null, response);
         }, 0);
     }
+    #describeClientQuotas(options, callback) {
+        this[kPerformWithRetry]('describeClientQuotas', retryCallback => {
+            this[kGetBootstrapConnection]((error, connection) => {
+                if (error) {
+                    retryCallback(error, undefined);
+                    return;
+                }
+                this[kGetApi]('DescribeClientQuotas', (error, api) => {
+                    if (error) {
+                        retryCallback(error, undefined);
+                        return;
+                    }
+                    api(connection, options.components, options.strict ?? false, retryCallback);
+                });
+            });
+        }, (error, response) => {
+            if (error) {
+                callback(new MultipleErrors('Describing client quotas failed.', [error]), undefined);
+                return;
+            }
+            callback(null, response.entries);
+        }, 0);
+    }
+    #alterClientQuotas(options, callback) {
+        this[kPerformWithRetry]('alterClientQuotas', retryCallback => {
+            this[kGetBootstrapConnection]((error, connection) => {
+                if (error) {
+                    retryCallback(error, undefined);
+                    return;
+                }
+                this[kGetApi]('AlterClientQuotas', (error, api) => {
+                    if (error) {
+                        retryCallback(error, undefined);
+                        return;
+                    }
+                    api(connection, options.entries, options.validateOnly ?? false, retryCallback);
+                });
+            });
+        }, (error, response) => {
+            if (error) {
+                callback(new MultipleErrors('Altering client quotas failed.', [error]), undefined);
+                return;
+            }
+            callback(null, response.entries);
+        }, 0);
+    }
+    #describeLogDirs(options, callback) {
+        this[kMetadata]({ topics: [] }, (error, metadata) => {
+            /* c8 ignore next 4 - Hard to test */
+            if (error) {
+                callback(error, undefined);
+                return;
+            }
+            runConcurrentCallbacks('Describing log dirs failed.', metadata.brokers, ([id, broker], concurrentCallback) => {
+                this[kGetConnection](broker, (error, connection) => {
+                    if (error) {
+                        concurrentCallback(error, undefined);
+                        return;
+                    }
+                    this[kPerformWithRetry]('describeLogDirs', retryCallback => {
+                        this[kGetApi]('DescribeLogDirs', (error, api) => {
+                            if (error) {
+                                retryCallback(error, undefined);
+                                return;
+                            }
+                            api(connection, options.topics, retryCallback);
+                        });
+                    }, (error, response) => {
+                        if (error) {
+                            concurrentCallback(error, undefined);
+                            return;
+                        }
+                        concurrentCallback(null, {
+                            broker: id,
+                            throttleTimeMs: response.throttleTimeMs,
+                            results: response.results.map(result => ({
+                                logDir: result.logDir,
+                                topics: result.topics,
+                                totalBytes: result.totalBytes,
+                                usableBytes: result.usableBytes
+                            }))
+                        });
+                    }, 0);
+                });
+            }, callback);
+        });
+    }
 }

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

@@ -132,6 +132,146 @@ export declare const deleteGroupsOptionsSchema: {
     required: string[];
     additionalProperties: boolean;
 };
+export declare const describeClientQuotasOptionsSchema: {
+    type: string;
+    properties: {
+        components: {
+            type: string;
+            items: {
+                type: string;
+                properties: {
+                    entityType: {
+                        type: string;
+                        minLength: number;
+                    };
+                    matchType: {
+                        type: string;
+                        enum: (0 | 1 | 2)[];
+                    };
+                    match: {
+                        type: string;
+                    };
+                };
+                required: string[];
+                additionalProperties: boolean;
+            };
+            minItems: number;
+        };
+        strict: {
+            type: string;
+        };
+    };
+    required: string[];
+    additionalProperties: boolean;
+};
+export declare const alterClientQuotasOptionsSchema: {
+    type: string;
+    properties: {
+        entries: {
+            type: string;
+            items: {
+                type: string;
+                properties: {
+                    entities: {
+                        type: string;
+                        items: {
+                            type: string;
+                            properties: {
+                                entityType: {
+                                    type: string;
+                                    minLength: number;
+                                };
+                                entityName: {
+                                    type: string[];
+                                };
+                            };
+                            required: string[];
+                            additionalProperties: boolean;
+                        };
+                        minItems: number;
+                    };
+                    ops: {
+                        type: string;
+                        items: {
+                            oneOf: ({
+                                type: string;
+                                properties: {
+                                    key: {
+                                        type: string;
+                                        minLength: number;
+                                    };
+                                    value: {
+                                        type: string;
+                                    };
+                                    remove: {
+                                        type: string;
+                                        const: boolean;
+                                    };
+                                };
+                                required: string[];
+                                additionalProperties: boolean;
+                            } | {
+                                type: string;
+                                properties: {
+                                    key: {
+                                        type: string;
+                                        minLength: number;
+                                    };
+                                    remove: {
+                                        type: string;
+                                        const: boolean;
+                                    };
+                                    value?: undefined;
+                                };
+                                required: string[];
+                                additionalProperties: boolean;
+                            })[];
+                        };
+                        minItems: number;
+                    };
+                };
+                required: string[];
+                additionalProperties: boolean;
+            };
+            minItems: number;
+        };
+        validateOnly: {
+            type: string;
+        };
+    };
+    required: string[];
+    additionalProperties: boolean;
+};
+export declare const describeLogDirsOptionsSchema: {
+    type: string;
+    properties: {
+        topics: {
+            type: string;
+            items: {
+                type: string;
+                properties: {
+                    name: {
+                        type: string;
+                        minLength: number;
+                    };
+                    partitions: {
+                        type: string;
+                        items: {
+                            type: string;
+                            minimum: number;
+                        };
+                        minItems: number;
+                    };
+                };
+                required: string[];
+                additionalProperties: boolean;
+            };
+            minItems: number;
+        };
+    };
+    required: string[];
+    additionalProperties: boolean;
+};
 export declare const createTopicsOptionsValidator: import("ajv").ValidateFunction<{
     [x: string]: {};
 }>;
@@ -146,3 +286,12 @@ export declare const describeGroupsOptionsValidator: import("ajv").ValidateFunct
 export declare const deleteGroupsOptionsValidator: import("ajv").ValidateFunction<{
     [x: string]: {};
 }>;
+export declare const describeClientQuotasOptionsValidator: import("ajv").ValidateFunction<{
+    [x: string]: {};
+}>;
+export declare const alterClientQuotasOptionsValidator: import("ajv").ValidateFunction<{
+    [x: string]: {};
+}>;
+export declare const describeLogDirsOptionsValidator: import("ajv").ValidateFunction<{
+    [x: string]: {};
+}>;

package/dist/clients/admin/options.js

@@ -1,4 +1,4 @@
-import { ConsumerGroupStates } from "../../apis/enumerations.js";
+import { ClientQuotaMatchTypes, ConsumerGroupStates } from "../../apis/enumerations.js";
 import { ajv, listErrorMessage } from "../../utils.js";
 import { idProperty } from "../base/options.js";
 export const groupsProperties = {
@@ -83,9 +83,117 @@ export const deleteGroupsOptionsSchema = {
     required: ['groups'],
     additionalProperties: false
 };
+export const describeClientQuotasOptionsSchema = {
+    type: 'object',
+    properties: {
+        components: {
+            type: 'array',
+            items: {
+                type: 'object',
+                properties: {
+                    entityType: { type: 'string', minLength: 1 },
+                    matchType: { type: 'number', enum: Object.values(ClientQuotaMatchTypes) },
+                    match: { type: 'string' }
+                },
+                required: ['entityType', 'matchType'],
+                additionalProperties: false
+            },
+            minItems: 1
+        },
+        strict: { type: 'boolean' }
+    },
+    required: ['components'],
+    additionalProperties: false
+};
+export const alterClientQuotasOptionsSchema = {
+    type: 'object',
+    properties: {
+        entries: {
+            type: 'array',
+            items: {
+                type: 'object',
+                properties: {
+                    entities: {
+                        type: 'array',
+                        items: {
+                            type: 'object',
+                            properties: {
+                                entityType: { type: 'string', minLength: 1 },
+                                entityName: { type: ['string', 'null'] }
+                            },
+                            required: ['entityType'],
+                            additionalProperties: false
+                        },
+                        minItems: 1
+                    },
+                    ops: {
+                        type: 'array',
+                        items: {
+                            oneOf: [
+                                {
+                                    type: 'object',
+                                    properties: {
+                                        key: { type: 'string', minLength: 1 },
+                                        value: { type: 'number' },
+                                        remove: { type: 'boolean', const: false }
+                                    },
+                                    required: ['key', 'value', 'remove'],
+                                    additionalProperties: false
+                                },
+                                {
+                                    type: 'object',
+                                    properties: {
+                                        key: { type: 'string', minLength: 1 },
+                                        remove: { type: 'boolean', const: true }
+                                    },
+                                    required: ['key', 'remove'],
+                                    additionalProperties: false
+                                }
+                            ]
+                        },
+                        minItems: 1
+                    }
+                },
+                required: ['entities', 'ops'],
+                additionalProperties: false
+            },
+            minItems: 1
+        },
+        validateOnly: { type: 'boolean' }
+    },
+    required: ['entries'],
+    additionalProperties: false
+};
+export const describeLogDirsOptionsSchema = {
+    type: 'object',
+    properties: {
+        topics: {
+            type: 'array',
+            items: {
+                type: 'object',
+                properties: {
+                    name: { type: 'string', minLength: 1 },
+                    partitions: {
+                        type: 'array',
+                        items: { type: 'number', minimum: 0 },
+                        minItems: 1
+                    }
+                },
+                required: ['name', 'partitions'],
+                additionalProperties: false
+            },
+            minItems: 1
+        }
+    },
+    required: ['topics'],
+    additionalProperties: false
+};
 export const createTopicsOptionsValidator = ajv.compile(createTopicOptionsSchema);
 export const listTopicsOptionsValidator = ajv.compile(listTopicOptionsSchema);
 export const deleteTopicsOptionsValidator = ajv.compile(deleteTopicOptionsSchema);
 export const listGroupsOptionsValidator = ajv.compile(listGroupsOptionsSchema);
 export const describeGroupsOptionsValidator = ajv.compile(describeGroupsOptionsSchema);
 export const deleteGroupsOptionsValidator = ajv.compile(deleteGroupsOptionsSchema);
+export const describeClientQuotasOptionsValidator = ajv.compile(describeClientQuotasOptionsSchema);
+export const alterClientQuotasOptionsValidator = ajv.compile(alterClientQuotasOptionsSchema);
+export const describeLogDirsOptionsValidator = ajv.compile(describeLogDirsOptionsSchema);