@platformatic/kafka 0.1.0

package/dist/apis/admin/create-partitions.d.ts

@@ -0,0 +1,24 @@
+import { type NullableString } from '../../protocol/definitions.ts';
+import { type Reader } from '../../protocol/reader.ts';
+import { Writer } from '../../protocol/writer.ts';
+export interface CreatePartitionsRequestAssignment {
+    brokerIds: number[];
+}
+export interface CreatePartitionsRequestTopic {
+    name: string;
+    count: number;
+    assignments: CreatePartitionsRequestAssignment[];
+}
+export type CreatePartitionsRequest = Parameters<typeof createRequest>;
+export interface CreatePartitionsResponseResult {
+    name: string;
+    errorCode: number;
+    errorMessage: NullableString;
+}
+export interface CreatePartitionsResponse {
+    throttleTimeMs: number;
+    results: CreatePartitionsResponseResult[];
+}
+export declare function createRequest(topics: CreatePartitionsRequestTopic[], timeoutMs: number, validateOnly: boolean): Writer;
+export declare function parseResponse(_correlationId: number, apiKey: number, apiVersion: number, reader: Reader): CreatePartitionsResponse;
+export declare const api: import("../definitions.ts").API<[topics: CreatePartitionsRequestTopic[], timeoutMs: number, validateOnly: boolean], CreatePartitionsResponse>;

package/dist/apis/admin/create-partitions.js

@@ -0,0 +1,54 @@
+import { ResponseError } from "../../errors.js";
+import { Writer } from "../../protocol/writer.js";
+import { createAPI } from "../definitions.js";
+/*
+  CreatePartitions Request (Version: 3) => [topics] timeout_ms validate_only TAG_BUFFER
+    topics => name count [assignments] TAG_BUFFER
+      name => COMPACT_STRING
+      count => INT32
+      assignments => [broker_ids] TAG_BUFFER
+        broker_ids => INT32
+    timeout_ms => INT32
+    validate_only => BOOLEAN
+*/
+export function createRequest(topics, timeoutMs, validateOnly) {
+    return Writer.create()
+        .appendArray(topics, (w, t) => {
+        w.appendString(t.name)
+            .appendInt32(t.count)
+            .appendArray(t.assignments, (w, a) => w.appendArray(a.brokerIds, (w, b) => w.appendInt32(b), true, false));
+    })
+        .appendInt32(timeoutMs)
+        .appendBoolean(validateOnly)
+        .appendTaggedFields();
+}
+/*
+  CreatePartitions Response (Version: 3) => throttle_time_ms [results] TAG_BUFFER
+    throttle_time_ms => INT32
+    results => name error_code error_message TAG_BUFFER
+      name => COMPACT_STRING
+      error_code => INT16
+      error_message => COMPACT_NULLABLE_STRING
+*/
+export function parseResponse(_correlationId, apiKey, apiVersion, reader) {
+    const errors = [];
+    const response = {
+        throttleTimeMs: reader.readInt32(),
+        results: reader.readArray((r, i) => {
+            const result = {
+                name: r.readString(),
+                errorCode: r.readInt16(),
+                errorMessage: r.readNullableString()
+            };
+            if (result.errorCode !== 0) {
+                errors.push([`/results/${i}`, result.errorCode]);
+            }
+            return result;
+        })
+    };
+    if (errors.length) {
+        throw new ResponseError(apiKey, apiVersion, Object.fromEntries(errors), response);
+    }
+    return response;
+}
+export const api = createAPI(37, 3, createRequest, parseResponse);

package/dist/apis/admin/create-topics.d.ts

@@ -0,0 +1,42 @@
+import { type NullableString } from '../../protocol/definitions.ts';
+import { type Reader } from '../../protocol/reader.ts';
+import { Writer } from '../../protocol/writer.ts';
+export interface CreateTopicsRequestTopicAssignment {
+    partitionIndex: number;
+    brokerIds: number[];
+}
+export interface CreateTopicsRequestTopicConfig {
+    name: string;
+    value?: NullableString;
+}
+export interface CreateTopicsRequestTopic {
+    name: string;
+    numPartitions: number;
+    replicationFactor: number;
+    assignments: CreateTopicsRequestTopicAssignment[];
+    configs: CreateTopicsRequestTopicConfig[];
+}
+export type CreateTopicsRequest = Parameters<typeof createRequest>;
+export interface CreateTopicsResponseTopicConfig {
+    name: string;
+    value: NullableString;
+    readOnly: boolean;
+    configSource: number;
+    isSensitive: boolean;
+}
+export interface CreateTopicsResponseTopic {
+    name: string;
+    topicId: string;
+    errorCode: number;
+    errorMessage: NullableString;
+    numPartitions: number;
+    replicationFactor: number;
+    configs: CreateTopicsResponseTopicConfig[];
+}
+export interface CreateTopicsResponse {
+    throttleTimeMs: number;
+    topics: CreateTopicsResponseTopic[];
+}
+export declare function createRequest(topics: CreateTopicsRequestTopic[], timeoutMs: number, validateOnly: boolean): Writer;
+export declare function parseResponse(_correlationId: number, apiKey: number, apiVersion: number, reader: Reader): CreateTopicsResponse;
+export declare const api: import("../definitions.ts").API<[topics: CreateTopicsRequestTopic[], timeoutMs: number, validateOnly: boolean], CreateTopicsResponse>;

package/dist/apis/admin/create-topics.js

@@ -0,0 +1,86 @@
+import { ResponseError } from "../../errors.js";
+import { Writer } from "../../protocol/writer.js";
+import { createAPI } from "../definitions.js";
+/*
+  CreateTopics Request (Version: 7) => [topics] timeout_ms validate_only TAG_BUFFER
+    topics => name num_partitions replication_factor [assignments] [configs] TAG_BUFFER
+      name => COMPACT_STRING
+      num_partitions => INT32
+      replication_factor => INT16
+      assignments => partition_index [broker_ids] TAG_BUFFER
+        partition_index => INT32
+        broker_ids => INT32
+      configs => name value TAG_BUFFER
+        name => COMPACT_STRING
+        value => COMPACT_NULLABLE_STRING
+    timeout_ms => INT32
+    validate_only => BOOLEAN
+*/
+export function createRequest(topics, timeoutMs, validateOnly) {
+    return Writer.create()
+        .appendArray(topics, (w, topic) => {
+        w.appendString(topic.name)
+            .appendInt32(topic.numPartitions)
+            .appendInt16(topic.replicationFactor)
+            .appendArray(topic.assignments, (w, assignment) => {
+            w.appendInt32(assignment.partitionIndex).appendArray(assignment.brokerIds, (w, b) => w.appendInt32(b), true, false);
+        })
+            .appendArray(topic.configs, (w, config) => {
+            w.appendString(config.name).appendString(config.value);
+        });
+    })
+        .appendInt32(timeoutMs)
+        .appendBoolean(validateOnly)
+        .appendTaggedFields();
+}
+/*
+  CreateTopics Response (Version: 7) => throttle_time_ms [topics] TAG_BUFFER
+    throttle_time_ms => INT32
+    topics => name topic_id error_code error_message num_partitions replication_factor [configs] TAG_BUFFER
+      name => COMPACT_STRING
+      topic_id => UUID
+      error_code => INT16
+      error_message => COMPACT_NULLABLE_STRING
+      num_partitions => INT32
+      replication_factor => INT16
+      configs => name value read_only config_source is_sensitive TAG_BUFFER
+        name => COMPACT_STRING
+        value => COMPACT_NULLABLE_STRING
+        read_only => BOOLEAN
+        config_source => INT8
+        is_sensitive => BOOLEAN
+*/
+export function parseResponse(_correlationId, apiKey, apiVersion, reader) {
+    const errors = [];
+    const response = {
+        throttleTimeMs: reader.readInt32(),
+        topics: reader.readArray((r, i) => {
+            const topic = {
+                name: r.readString(),
+                topicId: r.readUUID(),
+                errorCode: r.readInt16(),
+                errorMessage: r.readNullableString(),
+                numPartitions: r.readInt32(),
+                replicationFactor: r.readInt16(),
+                configs: r.readArray(r => {
+                    return {
+                        name: r.readString(),
+                        value: r.readNullableString(),
+                        readOnly: r.readBoolean(),
+                        configSource: r.readInt8(),
+                        isSensitive: r.readBoolean()
+                    };
+                })
+            };
+            if (topic.errorCode !== 0) {
+                errors.push([`/topics/${i}`, topic.errorCode]);
+            }
+            return topic;
+        })
+    };
+    if (errors.length) {
+        throw new ResponseError(apiKey, apiVersion, Object.fromEntries(errors), response);
+    }
+    return response;
+}
+export const api = createAPI(19, 7, createRequest, parseResponse);

package/dist/apis/admin/delete-acls.d.ts

@@ -0,0 +1,36 @@
+import { type NullableString } from '../../protocol/definitions.ts';
+import { type Reader } from '../../protocol/reader.ts';
+import { Writer } from '../../protocol/writer.ts';
+export interface DeleteAclsRequestFilter {
+    resourceTypeFilter: number;
+    resourceNameFilter?: NullableString;
+    patternTypeFilter: number;
+    principalFilter?: NullableString;
+    hostFilter?: NullableString;
+    operation: number;
+    permissionType: number;
+}
+export type DeleteAclsRequest = Parameters<typeof createRequest>;
+export interface DeleteAclsResponseMatchingAcl {
+    errorCode: number;
+    errorMessage: NullableString;
+    resourceType: number;
+    resourceName: string;
+    patternType: number;
+    principal: string;
+    host: string;
+    operation: number;
+    permissionType: number;
+}
+export interface DeleteAclsResponseFilterResults {
+    errorCode: number;
+    errorMessage: NullableString;
+    matchingAcls: DeleteAclsResponseMatchingAcl[];
+}
+export interface DeleteAclsResponse {
+    throttleTimeMs: number;
+    filterResults: DeleteAclsResponseFilterResults[];
+}
+export declare function createRequest(filters: DeleteAclsRequestFilter[]): Writer;
+export declare function parseResponse(_correlationId: number, apiKey: number, apiVersion: number, reader: Reader): DeleteAclsResponse;
+export declare const api: import("../definitions.ts").API<[filters: DeleteAclsRequestFilter[]], DeleteAclsResponse>;

package/dist/apis/admin/delete-acls.js

@@ -0,0 +1,82 @@
+import { ResponseError } from "../../errors.js";
+import { Writer } from "../../protocol/writer.js";
+import { createAPI } from "../definitions.js";
+/*
+  DeleteAcls Request (Version: 3) => [filters] TAG_BUFFER
+    filters => resource_type_filter resource_name_filter pattern_type_filter principal_filter host_filter operation permission_type TAG_BUFFER
+      resource_type_filter => INT8
+      resource_name_filter => COMPACT_NULLABLE_STRING
+      pattern_type_filter => INT8
+      principal_filter => COMPACT_NULLABLE_STRING
+      host_filter => COMPACT_NULLABLE_STRING
+      operation => INT8
+      permission_type => INT8
+*/
+export function createRequest(filters) {
+    return Writer.create()
+        .appendArray(filters, (w, f) => {
+        w.appendInt8(f.resourceTypeFilter)
+            .appendString(f.resourceNameFilter)
+            .appendInt8(f.patternTypeFilter)
+            .appendString(f.principalFilter)
+            .appendString(f.hostFilter)
+            .appendInt8(f.operation)
+            .appendInt8(f.permissionType);
+    })
+        .appendTaggedFields();
+}
+/*
+  DeleteAcls Response (Version: 3) => throttle_time_ms [filter_results] TAG_BUFFER
+    throttle_time_ms => INT32
+    filter_results => error_code error_message [matching_acls] TAG_BUFFER
+      error_code => INT16
+      error_message => COMPACT_NULLABLE_STRING
+      matching_acls => error_code error_message resource_type resource_name pattern_type principal host operation permission_type TAG_BUFFER
+        error_code => INT16
+        error_message => COMPACT_NULLABLE_STRING
+        resource_type => INT8
+        resource_name => COMPACT_STRING
+        pattern_type => INT8
+        principal => COMPACT_STRING
+        host => COMPACT_STRING
+        operation => INT8
+        permission_type => INT8
+*/
+export function parseResponse(_correlationId, apiKey, apiVersion, reader) {
+    const errors = [];
+    const response = {
+        throttleTimeMs: reader.readInt32(),
+        filterResults: reader.readArray((r, i) => {
+            const errorCode = r.readInt16();
+            if (errorCode !== 0) {
+                errors.push([`/filter_results/${i}`, errorCode]);
+            }
+            return {
+                errorCode,
+                errorMessage: r.readNullableString(),
+                matchingAcls: r.readArray((r, j) => {
+                    const errorCode = r.readInt16();
+                    if (errorCode !== 0) {
+                        errors.push([`/filter_results/${i}/matching_acls/${j}`, errorCode]);
+                    }
+                    return {
+                        errorCode,
+                        errorMessage: r.readNullableString(),
+                        resourceType: r.readInt8(),
+                        resourceName: r.readString(),
+                        patternType: r.readInt8(),
+                        principal: r.readString(),
+                        host: r.readString(),
+                        operation: r.readInt8(),
+                        permissionType: r.readInt8()
+                    };
+                })
+            };
+        })
+    };
+    if (errors.length) {
+        throw new ResponseError(apiKey, apiVersion, Object.fromEntries(errors), response);
+    }
+    return response;
+}
+export const api = createAPI(31, 3, createRequest, parseResponse);

package/dist/apis/admin/delete-groups.d.ts

@@ -0,0 +1,14 @@
+import { type Reader } from '../../protocol/reader.ts';
+import { Writer } from '../../protocol/writer.ts';
+export type DeleteGroupsRequest = Parameters<typeof createRequest>;
+export interface DeleteGroupsResponseGroup {
+    groupId: string;
+    errorCode: number;
+}
+export interface DeleteGroupsResponse {
+    throttleTimeMs: number;
+    results: DeleteGroupsResponseGroup[];
+}
+export declare function createRequest(groupsNames: string[]): Writer;
+export declare function parseResponse(_correlationId: number, apiKey: number, apiVersion: number, reader: Reader): DeleteGroupsResponse;
+export declare const api: import("../definitions.ts").API<[groupsNames: string[]], DeleteGroupsResponse>;

package/dist/apis/admin/delete-groups.js

@@ -0,0 +1,40 @@
+import { ResponseError } from "../../errors.js";
+import { Writer } from "../../protocol/writer.js";
+import { createAPI } from "../definitions.js";
+/*
+  DeleteGroups Request (Version: 2) => [groups_names] TAG_BUFFER
+    groups_names => COMPACT_STRING
+*/
+export function createRequest(groupsNames) {
+    return Writer.create()
+        .appendArray(groupsNames, (w, r) => w.appendString(r), true, false)
+        .appendTaggedFields();
+}
+/*
+  DeleteGroups Response (Version: 2) => throttle_time_ms [results] TAG_BUFFER
+    throttle_time_ms => INT32
+    results => group_id error_code TAG_BUFFER
+      group_id => COMPACT_STRING
+      error_code => INT16
+*/
+export function parseResponse(_correlationId, apiKey, apiVersion, reader) {
+    const errors = [];
+    const response = {
+        throttleTimeMs: reader.readInt32(),
+        results: reader.readArray((r, i) => {
+            const group = {
+                groupId: r.readString(),
+                errorCode: r.readInt16()
+            };
+            if (group.errorCode !== 0) {
+                errors.push([`/results/${i}`, group.errorCode]);
+            }
+            return group;
+        })
+    };
+    if (errors.length) {
+        throw new ResponseError(apiKey, apiVersion, Object.fromEntries(errors), response);
+    }
+    return response;
+}
+export const api = createAPI(42, 2, createRequest, parseResponse);

package/dist/apis/admin/delete-records.d.ts

@@ -0,0 +1,27 @@
+import { type Reader } from '../../protocol/reader.ts';
+import { Writer } from '../../protocol/writer.ts';
+export interface DeleteRecordsRequestPartitions {
+    partitionIndex: number;
+    offset: bigint;
+}
+export interface DeleteRecordsRequestTopics {
+    name: string;
+    partitions: DeleteRecordsRequestPartitions[];
+}
+export type DeleteRecordsRequest = Parameters<typeof createRequest>;
+export interface DeleteRecordsResponsePartition {
+    partitionIndex: number;
+    lowWatermark: bigint;
+    errorCode: number;
+}
+export interface DeleteRecordsResponseTopic {
+    name: string;
+    partitions: DeleteRecordsResponsePartition[];
+}
+export interface DeleteRecordsResponse {
+    throttleTimeMs: number;
+    topics: DeleteRecordsResponseTopic[];
+}
+export declare function createRequest(topics: DeleteRecordsRequestTopics[], timeoutMs: number): Writer;
+export declare function parseResponse(_correlationId: number, apiKey: number, apiVersion: number, reader: Reader): DeleteRecordsResponse;
+export declare const api: import("../definitions.ts").API<[topics: DeleteRecordsRequestTopics[], timeoutMs: number], DeleteRecordsResponse>;

package/dist/apis/admin/delete-records.js

@@ -0,0 +1,59 @@
+import { ResponseError } from "../../errors.js";
+import { Writer } from "../../protocol/writer.js";
+import { createAPI } from "../definitions.js";
+/*
+  DeleteRecords Request (Version: 2) => [topics] timeout_ms TAG_BUFFER
+    topics => name [partitions] TAG_BUFFER
+      name => COMPACT_STRING
+      partitions => partition_index offset TAG_BUFFER
+        partition_index => INT32
+        offset => INT64
+    timeout_ms => INT32
+*/
+export function createRequest(topics, timeoutMs) {
+    return Writer.create()
+        .appendArray(topics, (w, t) => {
+        w.appendString(t.name).appendArray(t.partitions, (w, p) => {
+            w.appendInt32(p.partitionIndex).appendInt64(p.offset);
+        });
+    })
+        .appendInt32(timeoutMs)
+        .appendTaggedFields();
+}
+/*
+  DeleteRecords Response (Version: 2) => throttle_time_ms [topics] TAG_BUFFER
+    throttle_time_ms => INT32
+    topics => name [partitions] TAG_BUFFER
+      name => COMPACT_STRING
+      partitions => partition_index low_watermark error_code TAG_BUFFER
+        partition_index => INT32
+        low_watermark => INT64
+        error_code => INT16
+*/
+export function parseResponse(_correlationId, apiKey, apiVersion, reader) {
+    const errors = [];
+    const response = {
+        throttleTimeMs: reader.readInt32(),
+        topics: reader.readArray((r, i) => {
+            return {
+                name: r.readString(),
+                partitions: r.readArray((r, j) => {
+                    const partition = {
+                        partitionIndex: r.readInt32(),
+                        lowWatermark: r.readInt64(),
+                        errorCode: r.readInt16()
+                    };
+                    if (partition.errorCode !== 0) {
+                        errors.push([`topics[${i}].partitions[${j}]`, partition.errorCode]);
+                    }
+                    return partition;
+                })
+            };
+        })
+    };
+    if (errors.length) {
+        throw new ResponseError(apiKey, apiVersion, Object.fromEntries(errors), response);
+    }
+    return response;
+}
+export const api = createAPI(21, 2, createRequest, parseResponse);

package/dist/apis/admin/delete-topics.d.ts

@@ -0,0 +1,21 @@
+import { type NullableString } from '../../protocol/definitions.ts';
+import { type Reader } from '../../protocol/reader.ts';
+import { Writer } from '../../protocol/writer.ts';
+export interface DeleteTopicsRequestTopic {
+    name: string;
+    topicId?: NullableString;
+}
+export type DeleteTopicsRequest = Parameters<typeof createRequest>;
+export interface DeleteTopicsResponseResponse {
+    name: NullableString;
+    topicId: string;
+    errorCode: number;
+    errorMessage: NullableString;
+}
+export interface DeleteTopicsResponse {
+    throttleTimeMs: number;
+    responses: DeleteTopicsResponseResponse[];
+}
+export declare function createRequest(topics: DeleteTopicsRequestTopic[], timeoutMs: number): Writer;
+export declare function parseResponse(_correlationId: number, apiKey: number, apiVersion: number, reader: Reader): DeleteTopicsResponse;
+export declare const api: import("../definitions.ts").API<[topics: DeleteTopicsRequestTopic[], timeoutMs: number], DeleteTopicsResponse>;

package/dist/apis/admin/delete-topics.js

@@ -0,0 +1,50 @@
+import { ResponseError } from "../../errors.js";
+import { Writer } from "../../protocol/writer.js";
+import { createAPI } from "../definitions.js";
+/*
+  DeleteTopics Request (Version: 6) => [topics] timeout_ms TAG_BUFFER
+    topics => name topic_id TAG_BUFFER
+      name => COMPACT_NULLABLE_STRING
+      topic_id => UUID
+    timeout_ms => INT32
+*/
+export function createRequest(topics, timeoutMs) {
+    return Writer.create()
+        .appendArray(topics, (w, topic) => {
+        w.appendString(topic.name).appendUUID(topic.topicId);
+    })
+        .appendInt32(timeoutMs)
+        .appendTaggedFields();
+}
+/*
+  DeleteTopics Response (Version: 6) => throttle_time_ms [responses] TAG_BUFFER
+    throttle_time_ms => INT32
+    responses => name topic_id error_code error_message TAG_BUFFER
+      name => COMPACT_NULLABLE_STRING
+      topic_id => UUID
+      error_code => INT16
+      error_message => COMPACT_NULLABLE_STRING
+*/
+export function parseResponse(_correlationId, apiKey, apiVersion, reader) {
+    const errors = [];
+    const response = {
+        throttleTimeMs: reader.readInt32(),
+        responses: reader.readArray((r, i) => {
+            const topicResponse = {
+                name: r.readNullableString(),
+                topicId: r.readUUID(),
+                errorCode: r.readInt16(),
+                errorMessage: r.readNullableString()
+            };
+            if (topicResponse.errorCode !== 0) {
+                errors.push([`/responses/${i}`, topicResponse.errorCode]);
+            }
+            return topicResponse;
+        })
+    };
+    if (errors.length) {
+        throw new ResponseError(apiKey, apiVersion, Object.fromEntries(errors), response);
+    }
+    return response;
+}
+export const api = createAPI(20, 6, createRequest, parseResponse);

package/dist/apis/admin/describe-acls.d.ts

@@ -0,0 +1,25 @@
+import { type NullableString } from '../../protocol/definitions.ts';
+import { type Reader } from '../../protocol/reader.ts';
+import { Writer } from '../../protocol/writer.ts';
+export type DescribeAclsRequest = Parameters<typeof createRequest>;
+export interface DescribeAclsResponseAcl {
+    principal: string;
+    host: string;
+    operation: number;
+    permissionType: number;
+}
+export interface DescribeAclsResponseResource {
+    resourceType: number;
+    resourceName: string;
+    patternType: number;
+    acls: DescribeAclsResponseAcl[];
+}
+export interface DescribeAclsResponse {
+    throttleTimeMs: number;
+    errorCode: number;
+    errorMessage: NullableString;
+    resources: DescribeAclsResponseResource[];
+}
+export declare function createRequest(resourceTypeFilter: number, resourceNameFilter: NullableString, patternTypeFilter: number, principalFilter: NullableString, hostFilter: NullableString, operation: number, permissionType: number): Writer;
+export declare function parseResponse(_correlationId: number, apiKey: number, apiVersion: number, reader: Reader): DescribeAclsResponse;
+export declare const api: import("../definitions.ts").API<[resourceTypeFilter: number, resourceNameFilter: NullableString, patternTypeFilter: number, principalFilter: NullableString, hostFilter: NullableString, operation: number, permissionType: number], DescribeAclsResponse>;

package/dist/apis/admin/describe-acls.js

@@ -0,0 +1,66 @@
+import { ResponseError } from "../../errors.js";
+import { Writer } from "../../protocol/writer.js";
+import { createAPI } from "../definitions.js";
+/*
+  DescribeAcls Request (Version: 3) => resource_type_filter resource_name_filter pattern_type_filter principal_filter host_filter operation permission_type TAG_BUFFER
+    resource_type_filter => INT8
+    resource_name_filter => COMPACT_NULLABLE_STRING
+    pattern_type_filter => INT8
+    principal_filter => COMPACT_NULLABLE_STRING
+    host_filter => COMPACT_NULLABLE_STRING
+    operation => INT8
+    permission_type => INT8
+*/
+export function createRequest(resourceTypeFilter, resourceNameFilter, patternTypeFilter, principalFilter, hostFilter, operation, permissionType) {
+    return Writer.create()
+        .appendInt8(resourceTypeFilter)
+        .appendString(resourceNameFilter)
+        .appendInt8(patternTypeFilter)
+        .appendString(principalFilter)
+        .appendString(hostFilter)
+        .appendInt8(operation)
+        .appendInt8(permissionType)
+        .appendTaggedFields();
+}
+/*
+DescribeAcls Response (Version: 3) => throttle_time_ms error_code error_message [resources] TAG_BUFFER
+  throttle_time_ms => INT32
+  error_code => INT16
+  error_message => COMPACT_NULLABLE_STRING
+  resources => resource_type resource_name pattern_type [acls] TAG_BUFFER
+    resource_type => INT8
+    resource_name => COMPACT_STRING
+    pattern_type => INT8
+    acls => principal host operation permission_type TAG_BUFFER
+      principal => COMPACT_STRING
+      host => COMPACT_STRING
+      operation => INT8
+      permission_type => INT8
+*/
+export function parseResponse(_correlationId, apiKey, apiVersion, reader) {
+    const response = {
+        throttleTimeMs: reader.readInt32(),
+        errorCode: reader.readInt16(),
+        errorMessage: reader.readNullableString(),
+        resources: reader.readArray(r => {
+            return {
+                resourceType: r.readInt8(),
+                resourceName: r.readString(),
+                patternType: r.readInt8(),
+                acls: r.readArray(r => {
+                    return {
+                        principal: r.readString(),
+                        host: r.readString(),
+                        operation: r.readInt8(),
+                        permissionType: r.readInt8()
+                    };
+                })
+            };
+        })
+    };
+    if (response.errorCode) {
+        throw new ResponseError(apiKey, apiVersion, { '': response.errorCode }, response);
+    }
+    return response;
+}
+export const api = createAPI(29, 3, createRequest, parseResponse);

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

@@ -0,0 +1,30 @@
+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;
+}
+export type DescribeClientQuotasRequest = Parameters<typeof createRequest>;
+export interface DescribeClientQuotasResponseValue {
+    key: string;
+    value: number;
+}
+export interface DescribeClientQuotasResponseEntity {
+    entityType: string;
+    entityName: NullableString;
+}
+export interface DescribeClientQuotasResponseEntry {
+    entity: DescribeClientQuotasResponseEntity[];
+    values: DescribeClientQuotasResponseValue[];
+}
+export interface DescribeClientQuotasResponse {
+    throttleTimeMs: number;
+    errorCode: number;
+    errorMessage: NullableString;
+    entries: DescribeClientQuotasResponseEntry[];
+}
+export declare function createRequest(components: DescribeClientQuotasRequestComponent[], strict: boolean): Writer;
+export declare function parseResponse(_correlationId: number, apiKey: number, apiVersion: number, reader: Reader): DescribeClientQuotasResponse;
+export declare const api: import("../definitions.ts").API<[components: DescribeClientQuotasRequestComponent[], strict: boolean], DescribeClientQuotasResponse>;