@platformatic/kafka 0.1.0

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

@@ -0,0 +1,57 @@
+import { ResponseError } from "../../errors.js";
+import { Writer } from "../../protocol/writer.js";
+import { createAPI } from "../definitions.js";
+/*
+  DescribeClientQuotas Request (Version: 1) => [components] strict TAG_BUFFER
+    components => entity_type match_type match TAG_BUFFER
+      entity_type => COMPACT_STRING
+      match_type => INT8
+      match => COMPACT_NULLABLE_STRING
+    strict => BOOLEAN
+*/
+export function createRequest(components, strict) {
+    return Writer.create()
+        .appendArray(components, (w, c) => {
+        w.appendString(c.entityType).appendInt8(c.matchType).appendString(c.match);
+    })
+        .appendBoolean(strict)
+        .appendTaggedFields();
+}
+/*
+  DescribeClientQuotas Response (Version: 1) => throttle_time_ms error_code error_message [entries] TAG_BUFFER
+    throttle_time_ms => INT32
+    error_code => INT16
+    error_message => COMPACT_NULLABLE_STRING
+    entries => [entity] [values] TAG_BUFFER
+      entity => entity_type entity_name TAG_BUFFER
+        entity_type => COMPACT_STRING
+        entity_name => COMPACT_NULLABLE_STRING
+      values => key value TAG_BUFFER
+        key => COMPACT_STRING
+        value => FLOAT64
+*/
+export function parseResponse(_correlationId, apiKey, apiVersion, reader) {
+    const response = {
+        throttleTimeMs: reader.readInt32(),
+        errorCode: reader.readInt16(),
+        errorMessage: reader.readNullableString(),
+        entries: reader.readArray(r => {
+            return {
+                entity: r.readArray(r => {
+                    return { entityType: r.readString(), entityName: r.readNullableString() };
+                }),
+                values: r.readArray(r => {
+                    return {
+                        key: r.readString(),
+                        value: r.readFloat64()
+                    };
+                })
+            };
+        })
+    };
+    if (response.errorCode !== 0) {
+        throw new ResponseError(apiKey, apiVersion, { '': response.errorCode }, response);
+    }
+    return response;
+}
+export const api = createAPI(48, 1, createRequest, parseResponse);

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

@@ -0,0 +1,23 @@
+import { type NullableString } from '../../protocol/definitions.ts';
+import { type Reader } from '../../protocol/reader.ts';
+import { Writer } from '../../protocol/writer.ts';
+export type DescribeClusterRequest = Parameters<typeof createRequest>;
+export interface DescribeClusterResponseBroker {
+    brokerId: number;
+    host: string;
+    port: number;
+    rack: NullableString;
+}
+export interface DescribeClusterResponse {
+    throttleTimeMs: number;
+    errorCode: number;
+    errorMessage: NullableString;
+    endpointType: number;
+    clusterId: string;
+    controllerId: number;
+    brokers: DescribeClusterResponseBroker[];
+    clusterAuthorizedOperations: number;
+}
+export declare function createRequest(includeClusterAuthorizedOperations: boolean, endpointType: number): Writer;
+export declare function parseResponse(_correlationId: number, apiKey: number, apiVersion: number, reader: Reader): DescribeClusterResponse;
+export declare const api: import("../definitions.ts").API<[includeClusterAuthorizedOperations: boolean, endpointType: number], DescribeClusterResponse>;

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

@@ -0,0 +1,50 @@
+import { ResponseError } from "../../errors.js";
+import { Writer } from "../../protocol/writer.js";
+import { createAPI } from "../definitions.js";
+/*
+  DescribeCluster Request (Version: 1) => include_cluster_authorized_operations endpoint_type TAG_BUFFER
+    include_cluster_authorized_operations => BOOLEAN
+    endpoint_type => INT8
+*/
+export function createRequest(includeClusterAuthorizedOperations, endpointType) {
+    return Writer.create().appendBoolean(includeClusterAuthorizedOperations).appendInt8(endpointType).appendTaggedFields();
+}
+/*
+  DescribeCluster Response (Version: 1) => throttle_time_ms error_code error_message endpoint_type cluster_id controller_id [brokers] cluster_authorized_operations TAG_BUFFER
+    throttle_time_ms => INT32
+    error_code => INT16
+    error_message => COMPACT_NULLABLE_STRING
+    endpoint_type => INT8
+    cluster_id => COMPACT_STRING
+    controller_id => INT32
+    brokers => broker_id host port rack TAG_BUFFER
+      broker_id => INT32
+      host => COMPACT_STRING
+      port => INT32
+      rack => COMPACT_NULLABLE_STRING
+    cluster_authorized_operations => INT32
+*/
+export function parseResponse(_correlationId, apiKey, apiVersion, reader) {
+    const response = {
+        throttleTimeMs: reader.readInt32(),
+        errorCode: reader.readInt16(),
+        errorMessage: reader.readNullableString(),
+        endpointType: reader.readInt8(),
+        clusterId: reader.readString(),
+        controllerId: reader.readInt32(),
+        brokers: reader.readArray(r => {
+            return {
+                brokerId: r.readInt32(),
+                host: r.readString(),
+                port: r.readInt32(),
+                rack: r.readNullableString()
+            };
+        }),
+        clusterAuthorizedOperations: reader.readInt32()
+    };
+    if (response.errorCode !== 0) {
+        throw new ResponseError(apiKey, apiVersion, { '': response.errorCode }, response);
+    }
+    return response;
+}
+export const api = createAPI(60, 1, createRequest, parseResponse);

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

@@ -0,0 +1,38 @@
+import { type NullableString } from '../../protocol/definitions.ts';
+import { type Reader } from '../../protocol/reader.ts';
+import { Writer } from '../../protocol/writer.ts';
+export interface DescribeConfigsRequestResource {
+    resourceType: number;
+    resourceName: string;
+    configurationKeys: string[];
+}
+export type DescribeConfigsRequest = Parameters<typeof createRequest>;
+export interface DescribeConfigsResponseSynonym {
+    name: string;
+    value: NullableString;
+    source: number;
+}
+export interface DescribeConfigsResponseConfig {
+    name: string;
+    value: NullableString;
+    readOnly: boolean;
+    configSource: number;
+    isSensitive: boolean;
+    synonyms: DescribeConfigsResponseSynonym[];
+    configType: number;
+    documentation: NullableString;
+}
+export interface DescribeConfigsResponseResult {
+    errorCode: number;
+    errorMessage: NullableString;
+    resourceType: number;
+    resourceName: string;
+    configs: DescribeConfigsResponseConfig[];
+}
+export interface DescribeConfigsResponse {
+    throttleTimeMs: number;
+    results: DescribeConfigsResponseResult[];
+}
+export declare function createRequest(resources: DescribeConfigsRequestResource[], includeSynonyms: boolean, includeDocumentation: boolean): Writer;
+export declare function parseResponse(_correlationId: number, apiKey: number, apiVersion: number, reader: Reader): DescribeConfigsResponse;
+export declare const api: import("../definitions.ts").API<[resources: DescribeConfigsRequestResource[], includeSynonyms: boolean, includeDocumentation: boolean], DescribeConfigsResponse>;

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

@@ -0,0 +1,85 @@
+import { ResponseError } from "../../errors.js";
+import { Writer } from "../../protocol/writer.js";
+import { createAPI } from "../definitions.js";
+/*
+  DescribeConfigs Request (Version: 4) => [resources] include_synonyms include_documentation TAG_BUFFER
+    resources => resource_type resource_name [configuration_keys] TAG_BUFFER
+      resource_type => INT8
+      resource_name => COMPACT_STRING
+      configuration_keys => COMPACT_STRING
+    include_synonyms => BOOLEAN
+    include_documentation => BOOLEAN
+*/
+export function createRequest(resources, includeSynonyms, includeDocumentation) {
+    return Writer.create()
+        .appendArray(resources, (w, r) => {
+        w.appendInt8(r.resourceType)
+            .appendString(r.resourceName)
+            .appendArray(r.configurationKeys, (w, c) => w.appendString(c), true, false);
+    })
+        .appendBoolean(includeSynonyms)
+        .appendBoolean(includeDocumentation)
+        .appendTaggedFields();
+}
+/*
+  DescribeConfigs Response (Version: 4) => throttle_time_ms [results] TAG_BUFFER
+    throttle_time_ms => INT32
+    results => error_code error_message resource_type resource_name [configs] TAG_BUFFER
+      error_code => INT16
+      error_message => COMPACT_NULLABLE_STRING
+      resource_type => INT8
+      resource_name => COMPACT_STRING
+      configs => name value read_only config_source is_sensitive [synonyms] config_type documentation TAG_BUFFER
+        name => COMPACT_STRING
+        value => COMPACT_NULLABLE_STRING
+        read_only => BOOLEAN
+        config_source => INT8
+        is_sensitive => BOOLEAN
+        synonyms => name value source TAG_BUFFER
+          name => COMPACT_STRING
+          value => COMPACT_NULLABLE_STRING
+          source => INT8
+        config_type => INT8
+        documentation => COMPACT_NULLABLE_STRING
+*/
+export function parseResponse(_correlationId, apiKey, apiVersion, reader) {
+    const errors = [];
+    const response = {
+        throttleTimeMs: reader.readInt32(),
+        results: reader.readArray((r, i) => {
+            const errorCode = r.readInt16();
+            if (errorCode !== 0) {
+                errors.push([`/results/${i}`, errorCode]);
+            }
+            return {
+                errorCode,
+                errorMessage: r.readNullableString(),
+                resourceType: r.readInt8(),
+                resourceName: r.readString(),
+                configs: r.readArray(r => {
+                    return {
+                        name: r.readString(),
+                        value: r.readNullableString(),
+                        readOnly: r.readBoolean(),
+                        configSource: r.readInt8(),
+                        isSensitive: r.readBoolean(),
+                        synonyms: r.readArray(r => {
+                            return {
+                                name: r.readString(),
+                                value: r.readNullableString(),
+                                source: r.readInt8()
+                            };
+                        }, true, false),
+                        configType: r.readInt8(),
+                        documentation: r.readNullableString()
+                    };
+                })
+            };
+        })
+    };
+    if (errors.length) {
+        throw new ResponseError(apiKey, apiVersion, Object.fromEntries(errors), response);
+    }
+    return response;
+}
+export const api = createAPI(32, 4, createRequest, parseResponse);

package/dist/apis/admin/describe-delegation-token.d.ts

@@ -0,0 +1,31 @@
+import { type Reader } from '../../protocol/reader.ts';
+import { Writer } from '../../protocol/writer.ts';
+export interface DescribeDelegationTokenRequestOwner {
+    principalType: string;
+    principalName: string;
+}
+export type DescribeDelegationTokenRequest = Parameters<typeof createRequest>;
+export interface DescribeDelegationTokenResponseRenewer {
+    principalType: string;
+    principalName: string;
+}
+export interface DescribeDelegationTokenResponseToken {
+    principalType: string;
+    principalName: string;
+    tokenRequesterPrincipalType: string;
+    tokenRequesterPrincipalName: string;
+    issueTimestamp: bigint;
+    expiryTimestamp: bigint;
+    maxTimestamp: bigint;
+    tokenId: string;
+    hmac: Buffer;
+    renewers: DescribeDelegationTokenResponseRenewer[];
+}
+export interface DescribeDelegationTokenResponse {
+    errorCode: number;
+    tokens: DescribeDelegationTokenResponseToken[];
+    throttleTimeMs: number;
+}
+export declare function createRequest(owners: DescribeDelegationTokenRequestOwner[]): Writer;
+export declare function parseResponse(_correlationId: number, apiKey: number, apiVersion: number, reader: Reader): DescribeDelegationTokenResponse;
+export declare const api: import("../definitions.ts").API<[owners: DescribeDelegationTokenRequestOwner[]], DescribeDelegationTokenResponse>;

package/dist/apis/admin/describe-delegation-token.js

@@ -0,0 +1,62 @@
+import { ResponseError } from "../../errors.js";
+import { Writer } from "../../protocol/writer.js";
+import { createAPI } from "../definitions.js";
+/*
+  DescribeDelegationToken Request (Version: 3) => [owners] TAG_BUFFER
+    owners => principal_type principal_name TAG_BUFFER
+      principal_type => COMPACT_STRING
+      principal_name => COMPACT_STRING
+*/
+export function createRequest(owners) {
+    return Writer.create()
+        .appendArray(owners, (w, r) => w.appendString(r.principalType).appendString(r.principalName))
+        .appendTaggedFields();
+}
+/*
+DescribeDelegationToken Response (Version: 3) => error_code [tokens] throttle_time_ms TAG_BUFFER
+  error_code => INT16
+  tokens => principal_type principal_name token_requester_principal_type token_requester_principal_name issue_timestamp expiry_timestamp max_timestamp token_id hmac [renewers] TAG_BUFFER
+    principal_type => COMPACT_STRING
+    principal_name => COMPACT_STRING
+    token_requester_principal_type => COMPACT_STRING
+    token_requester_principal_name => COMPACT_STRING
+    issue_timestamp => INT64
+    expiry_timestamp => INT64
+    max_timestamp => INT64
+    token_id => COMPACT_STRING
+    hmac => COMPACT_BYTES
+    renewers => principal_type principal_name TAG_BUFFER
+      principal_type => COMPACT_STRING
+      principal_name => COMPACT_STRING
+  throttle_time_ms => INT32
+*/
+export function parseResponse(_correlationId, apiKey, apiVersion, reader) {
+    const response = {
+        errorCode: reader.readInt16(),
+        tokens: reader.readArray(r => {
+            return {
+                principalType: r.readString(),
+                principalName: r.readString(),
+                tokenRequesterPrincipalType: r.readString(),
+                tokenRequesterPrincipalName: r.readString(),
+                issueTimestamp: r.readInt64(),
+                expiryTimestamp: r.readInt64(),
+                maxTimestamp: r.readInt64(),
+                tokenId: r.readString(),
+                hmac: r.readBytes(),
+                renewers: r.readArray(r => {
+                    return {
+                        principalType: r.readString(),
+                        principalName: r.readString()
+                    };
+                })
+            };
+        }),
+        throttleTimeMs: reader.readInt32()
+    };
+    if (response.errorCode !== 0) {
+        throw new ResponseError(apiKey, apiVersion, { '': response.errorCode }, response);
+    }
+    return response;
+}
+export const api = createAPI(41, 3, createRequest, parseResponse);

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

@@ -0,0 +1,28 @@
+import { type NullableString } from '../../protocol/definitions.ts';
+import { type Reader } from '../../protocol/reader.ts';
+import { Writer } from '../../protocol/writer.ts';
+export type DescribeGroupsRequest = Parameters<typeof createRequest>;
+export interface DescribeGroupsResponseMember {
+    memberId: string;
+    groupInstanceId: NullableString;
+    clientId: string;
+    clientHost: string;
+    memberMetadata: Buffer;
+    memberAssignment: Buffer;
+}
+export interface DescribeGroupsResponseGroup {
+    errorCode: number;
+    groupId: string;
+    groupState: string;
+    protocolType: string;
+    protocolData: string;
+    members: DescribeGroupsResponseMember[];
+    authorizedOperations: number;
+}
+export interface DescribeGroupsResponse {
+    throttleTimeMs: number;
+    groups: DescribeGroupsResponseGroup[];
+}
+export declare function createRequest(groups: string[], includeAuthorizedOperations: boolean): Writer;
+export declare function parseResponse(_correlationId: number, apiKey: number, apiVersion: number, reader: Reader): DescribeGroupsResponse;
+export declare const api: import("../definitions.ts").API<[groups: string[], includeAuthorizedOperations: boolean], DescribeGroupsResponse>;

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

@@ -0,0 +1,67 @@
+import { ResponseError } from "../../errors.js";
+import { Writer } from "../../protocol/writer.js";
+import { createAPI } from "../definitions.js";
+/*
+  DescribeGroups Request (Version: 5) => [groups] include_authorized_operations TAG_BUFFER
+    groups => COMPACT_STRING
+    include_authorized_operations => BOOLEAN
+*/
+export function createRequest(groups, includeAuthorizedOperations) {
+    return Writer.create()
+        .appendArray(groups, (w, g) => w.appendString(g), true, false)
+        .appendBoolean(includeAuthorizedOperations)
+        .appendTaggedFields();
+}
+/*
+DescribeGroups Response (Version: 5) => throttle_time_ms [groups] TAG_BUFFER
+  throttle_time_ms => INT32
+  groups => error_code group_id group_state protocol_type protocol_data [members] authorized_operations TAG_BUFFER
+    error_code => INT16
+    group_id => COMPACT_STRING
+    group_state => COMPACT_STRING
+    protocol_type => COMPACT_STRING
+    protocol_data => COMPACT_STRING
+    members => member_id group_instance_id client_id client_host member_metadata member_assignment TAG_BUFFER
+      member_id => COMPACT_STRING
+      group_instance_id => COMPACT_NULLABLE_STRING
+      client_id => COMPACT_STRING
+      client_host => COMPACT_STRING
+      member_metadata => COMPACT_BYTES
+      member_assignment => COMPACT_BYTES
+    authorized_operations => INT32
+*/
+export function parseResponse(_correlationId, apiKey, apiVersion, reader) {
+    const errors = [];
+    const response = {
+        throttleTimeMs: reader.readInt32(),
+        groups: reader.readArray((r, i) => {
+            const group = {
+                errorCode: r.readInt16(),
+                groupId: r.readString(),
+                groupState: r.readString(),
+                protocolType: r.readString(),
+                protocolData: r.readString(),
+                members: r.readArray(r => {
+                    return {
+                        memberId: r.readString(),
+                        groupInstanceId: r.readNullableString(),
+                        clientId: r.readString(),
+                        clientHost: r.readString(),
+                        memberMetadata: r.readBytes(),
+                        memberAssignment: r.readBytes()
+                    };
+                }),
+                authorizedOperations: r.readInt32()
+            };
+            if (group.errorCode !== 0) {
+                errors.push([`/groups/${i}`, group.errorCode]);
+            }
+            return group;
+        })
+    };
+    if (errors.length) {
+        throw new ResponseError(apiKey, apiVersion, Object.fromEntries(errors), response);
+    }
+    return response;
+}
+export const api = createAPI(15, 5, createRequest, parseResponse);

package/dist/apis/admin/describe-log-dirs.d.ts

@@ -0,0 +1,32 @@
+import { type Reader } from '../../protocol/reader.ts';
+import { Writer } from '../../protocol/writer.ts';
+export interface DescribeLogDirsRequestTopic {
+    name: string;
+    partitions: number[];
+}
+export type DescribeLogDirsRequest = Parameters<typeof createRequest>;
+export interface DescribeLogDirsResponsePartition {
+    partitionIndex: number;
+    partitionSize: bigint;
+    offsetLag: bigint;
+    isFutureKey: boolean;
+}
+export interface DescribeLogDirsResponseTopic {
+    name: string;
+    partitions: DescribeLogDirsResponsePartition[];
+}
+export interface DescribeLogDirsResponseResult {
+    errorCode: number;
+    logDir: string;
+    topics: DescribeLogDirsResponseTopic[];
+    totalBytes: bigint;
+    usableBytes: bigint;
+}
+export interface DescribeLogDirsResponse {
+    throttleTimeMs: number;
+    errorCode: number;
+    results: DescribeLogDirsResponseResult[];
+}
+export declare function createRequest(topics: DescribeLogDirsRequestTopic[]): Writer;
+export declare function parseResponse(_correlationId: number, apiKey: number, apiVersion: number, reader: Reader): DescribeLogDirsResponse;
+export declare const api: import("../definitions.ts").API<[topics: DescribeLogDirsRequestTopic[]], DescribeLogDirsResponse>;

package/dist/apis/admin/describe-log-dirs.js

@@ -0,0 +1,75 @@
+import { ResponseError } from "../../errors.js";
+import { Writer } from "../../protocol/writer.js";
+import { createAPI } from "../definitions.js";
+/*
+  DescribeLogDirs Request (Version: 4) => [topics] TAG_BUFFER
+    topics => topic [partitions] TAG_BUFFER
+      topic => COMPACT_STRING
+      partitions => INT32
+*/
+export function createRequest(topics) {
+    return Writer.create()
+        .appendArray(topics, (w, t) => {
+        w.appendString(t.name).appendArray(t.partitions, (w, p) => w.appendInt32(p), true, false);
+    })
+        .appendTaggedFields();
+}
+/*
+  DescribeLogDirs Response (Version: 4) => throttle_time_ms error_code [results] TAG_BUFFER
+    throttle_time_ms => INT32
+    error_code => INT16
+    results => error_code log_dir [topics] total_bytes usable_bytes TAG_BUFFER
+      error_code => INT16
+      log_dir => COMPACT_STRING
+      topics => name [partitions] TAG_BUFFER
+        name => COMPACT_STRING
+        partitions => partition_index partition_size offset_lag is_future_key TAG_BUFFER
+          partition_index => INT32
+          partition_size => INT64
+          offset_lag => INT64
+          is_future_key => BOOLEAN
+      total_bytes => INT64
+      usable_bytes => INT64
+*/
+export function parseResponse(_correlationId, apiKey, apiVersion, reader) {
+    const errors = [];
+    const throttleTimeMs = reader.readInt32();
+    const errorCode = reader.readInt16();
+    if (errorCode !== 0) {
+        errors.push(['', errorCode]);
+    }
+    const response = {
+        throttleTimeMs,
+        errorCode,
+        results: reader.readArray((r, i) => {
+            const errorCode = r.readInt16();
+            if (errorCode !== 0) {
+                errors.push([`/results/${i}`, errorCode]);
+            }
+            return {
+                errorCode,
+                logDir: r.readString(),
+                topics: r.readArray(reader => {
+                    return {
+                        name: reader.readString(),
+                        partitions: reader.readArray(reader => {
+                            return {
+                                partitionIndex: reader.readInt32(),
+                                partitionSize: reader.readInt64(),
+                                offsetLag: reader.readInt64(),
+                                isFutureKey: reader.readBoolean()
+                            };
+                        })
+                    };
+                }),
+                totalBytes: r.readInt64(),
+                usableBytes: r.readInt64()
+            };
+        })
+    };
+    if (errors.length) {
+        throw new ResponseError(apiKey, apiVersion, Object.fromEntries(errors), response);
+    }
+    return response;
+}
+export const api = createAPI(35, 4, createRequest, parseResponse);

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

@@ -0,0 +1,33 @@
+import { type NullableString } from '../../protocol/definitions.ts';
+import { type Reader } from '../../protocol/reader.ts';
+import { Writer } from '../../protocol/writer.ts';
+export interface DescribeProducersRequestTopic {
+    name: string;
+    partitionIndexes: number[];
+}
+export type DescribeProducersRequest = Parameters<typeof createRequest>;
+export interface DescribeProducersResponsePartitionProducer {
+    producerId: bigint;
+    producerEpoch: number;
+    lastSequence: number;
+    lastTimestamp: bigint;
+    coordinatorEpoch: number;
+    currentTxnStartOffset: bigint;
+}
+export interface DescribeProducersResponsePartition {
+    partitionIndex: number;
+    errorCode: number;
+    errorMessage: NullableString;
+    activeProducers: DescribeProducersResponsePartitionProducer[];
+}
+export interface DescribeProducersResponseTopic {
+    name: string;
+    partitions: DescribeProducersResponsePartition[];
+}
+export interface DescribeProducersResponse {
+    throttleTimeMs: number;
+    topics: DescribeProducersResponseTopic[];
+}
+export declare function createRequest(topics: DescribeProducersRequestTopic[]): Writer;
+export declare function parseResponse(_correlationId: number, apiKey: number, apiVersion: number, reader: Reader): DescribeProducersResponse;
+export declare const api: import("../definitions.ts").API<[topics: DescribeProducersRequestTopic[]], DescribeProducersResponse>;

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

@@ -0,0 +1,70 @@
+import { ResponseError } from "../../errors.js";
+import { Writer } from "../../protocol/writer.js";
+import { createAPI } from "../definitions.js";
+/*
+  DescribeProducers Request (Version: 0) => [topics] TAG_BUFFER
+    topics => name [partition_indexes] TAG_BUFFER
+      name => COMPACT_STRING
+      partition_indexes => INT32
+*/
+export function createRequest(topics) {
+    return Writer.create()
+        .appendArray(topics, (w, t) => {
+        w.appendString(t.name).appendArray(t.partitionIndexes, (w, p) => w.appendInt32(p), true, false);
+    })
+        .appendTaggedFields();
+}
+/*
+  DescribeProducers Response (Version: 0) => throttle_time_ms [topics] TAG_BUFFER
+    throttle_time_ms => INT32
+    topics => name [partitions] TAG_BUFFER
+      name => COMPACT_STRING
+      partitions => partition_index error_code error_message [active_producers] TAG_BUFFER
+        partition_index => INT32
+        error_code => INT16
+        error_message => COMPACT_NULLABLE_STRING
+        active_producers => producer_id producer_epoch last_sequence last_timestamp coordinator_epoch current_txn_start_offset TAG_BUFFER
+          producer_id => INT64
+          producer_epoch => INT32
+          last_sequence => INT32
+          last_timestamp => INT64
+          coordinator_epoch => INT32
+          current_txn_start_offset => INT64
+*/
+export function parseResponse(_correlationId, apiKey, apiVersion, reader) {
+    const errors = [];
+    const response = {
+        throttleTimeMs: reader.readInt32(),
+        topics: reader.readArray(r => {
+            return {
+                name: r.readString(),
+                partitions: reader.readArray((r, i) => {
+                    const partition = {
+                        partitionIndex: r.readInt32(),
+                        errorCode: r.readInt16(),
+                        errorMessage: r.readNullableString(),
+                        activeProducers: r.readArray(r => {
+                            return {
+                                producerId: r.readInt64(),
+                                producerEpoch: r.readInt32(),
+                                lastSequence: r.readInt32(),
+                                lastTimestamp: r.readInt64(),
+                                coordinatorEpoch: r.readInt32(),
+                                currentTxnStartOffset: r.readInt64()
+                            };
+                        })
+                    };
+                    if (partition.errorCode !== 0) {
+                        errors.push([`/partitions/${i}`, partition.errorCode]);
+                    }
+                    return partition;
+                })
+            };
+        })
+    };
+    if (errors.length) {
+        throw new ResponseError(apiKey, apiVersion, Object.fromEntries(errors), response);
+    }
+    return response;
+}
+export const api = createAPI(61, 0, createRequest, parseResponse);