@platformatic/kafka 0.1.0

package/dist/apis/admin/index.d.ts

@@ -0,0 +1,37 @@
+export * as alterClientQuotasV1 from './alter-client-quotas.ts';
+export * as alterConfigsV2 from './alter-configs.ts';
+export * as alterPartitionReassignmentsV0 from './alter-partition-reassignments.ts';
+export * as alterPartitionV3 from './alter-partition.ts';
+export * as alterReplicaLogDirsV2 from './alter-replica-log-dirs.ts';
+export * as alterUserScramCredentialsV0 from './alter-user-scram-credentials.ts';
+export * as consumerGroupDescribeV0 from './consumer-group-describe.ts';
+export * as createAclsV3 from './create-acls.ts';
+export * as createDelegationTokenV3 from './create-delegation-token.ts';
+export * as createPartitionsV3 from './create-partitions.ts';
+export * as createTopicsV7 from './create-topics.ts';
+export * as deleteAclsV3 from './delete-acls.ts';
+export * as deleteGroupsV2 from './delete-groups.ts';
+export * as deleteRecordsV2 from './delete-records.ts';
+export * as deleteTopicsV6 from './delete-topics.ts';
+export * as describeAclsV3 from './describe-acls.ts';
+export * as describeClientQuotasV0 from './describe-client-quotas.ts';
+export * as describeClusterV1 from './describe-cluster.ts';
+export * as describeConfigsV4 from './describe-configs.ts';
+export * as describeDelegationTokenV3 from './describe-delegation-token.ts';
+export * as describeGroupsV5 from './describe-groups.ts';
+export * as describeLogDirsV4 from './describe-log-dirs.ts';
+export * as describeProducersV0 from './describe-producers.ts';
+export * as describeQuorumV2 from './describe-quorum.ts';
+export * as describeTopicPartitionsV0 from './describe-topic-partitions.ts';
+export * as describeTransactionsV0 from './describe-transactions.ts';
+export * as describeUserScramCredentialsV0 from './describe-user-scram-credentials.ts';
+export * as envelopeV0 from './envelope.ts';
+export * as expireDelegationTokenV2 from './expire-delegation-token.ts';
+export * as incrementalAlterConfigsV1 from './incremental-alter-configs.ts';
+export * as listGroupsV5 from './list-groups.ts';
+export * as listPartitionReassignmentsV0 from './list-partition-reassignments.ts';
+export * as listTransactionsV1 from './list-transactions.ts';
+export * as offsetDeleteV0 from './offset-delete.ts';
+export * as renewDelegationTokenV2 from './renew-delegation-token.ts';
+export * as unregisterBrokerV0 from './unregister-broker.ts';
+export * as updateFeaturesV1 from './update-features.ts';

package/dist/apis/admin/index.js

@@ -0,0 +1,37 @@
+export * as alterClientQuotasV1 from "./alter-client-quotas.js";
+export * as alterConfigsV2 from "./alter-configs.js";
+export * as alterPartitionReassignmentsV0 from "./alter-partition-reassignments.js";
+export * as alterPartitionV3 from "./alter-partition.js";
+export * as alterReplicaLogDirsV2 from "./alter-replica-log-dirs.js";
+export * as alterUserScramCredentialsV0 from "./alter-user-scram-credentials.js";
+export * as consumerGroupDescribeV0 from "./consumer-group-describe.js";
+export * as createAclsV3 from "./create-acls.js";
+export * as createDelegationTokenV3 from "./create-delegation-token.js";
+export * as createPartitionsV3 from "./create-partitions.js";
+export * as createTopicsV7 from "./create-topics.js";
+export * as deleteAclsV3 from "./delete-acls.js";
+export * as deleteGroupsV2 from "./delete-groups.js";
+export * as deleteRecordsV2 from "./delete-records.js";
+export * as deleteTopicsV6 from "./delete-topics.js";
+export * as describeAclsV3 from "./describe-acls.js";
+export * as describeClientQuotasV0 from "./describe-client-quotas.js";
+export * as describeClusterV1 from "./describe-cluster.js";
+export * as describeConfigsV4 from "./describe-configs.js";
+export * as describeDelegationTokenV3 from "./describe-delegation-token.js";
+export * as describeGroupsV5 from "./describe-groups.js";
+export * as describeLogDirsV4 from "./describe-log-dirs.js";
+export * as describeProducersV0 from "./describe-producers.js";
+export * as describeQuorumV2 from "./describe-quorum.js";
+export * as describeTopicPartitionsV0 from "./describe-topic-partitions.js";
+export * as describeTransactionsV0 from "./describe-transactions.js";
+export * as describeUserScramCredentialsV0 from "./describe-user-scram-credentials.js";
+export * as envelopeV0 from "./envelope.js";
+export * as expireDelegationTokenV2 from "./expire-delegation-token.js";
+export * as incrementalAlterConfigsV1 from "./incremental-alter-configs.js";
+export * as listGroupsV5 from "./list-groups.js";
+export * as listPartitionReassignmentsV0 from "./list-partition-reassignments.js";
+export * as listTransactionsV1 from "./list-transactions.js";
+export * as offsetDeleteV0 from "./offset-delete.js";
+export * as renewDelegationTokenV2 from "./renew-delegation-token.js";
+export * as unregisterBrokerV0 from "./unregister-broker.js";
+export * as updateFeaturesV1 from "./update-features.js";

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

@@ -0,0 +1,18 @@
+import { type Reader } from '../../protocol/reader.ts';
+import { Writer } from '../../protocol/writer.ts';
+import { type ConsumerGroupState } from '../enumerations.ts';
+export type ListGroupsRequest = Parameters<typeof createRequest>;
+export interface ListGroupsResponseGroup {
+    groupId: string;
+    protocolType: string;
+    groupState: string;
+    groupType: string;
+}
+export interface ListGroupsResponse {
+    throttleTimeMs: number;
+    errorCode: number;
+    groups: ListGroupsResponseGroup[];
+}
+export declare function createRequest(statesFilter: ConsumerGroupState[], typesFilter: string[]): Writer;
+export declare function parseResponse(_correlationId: number, apiKey: number, apiVersion: number, reader: Reader): ListGroupsResponse;
+export declare const api: import("../definitions.ts").API<[statesFilter: ("PREPARING_REBALANCE" | "COMPLETING_REBALANCE" | "STABLE" | "DEAD" | "EMPTY")[], typesFilter: string[]], ListGroupsResponse>;

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

@@ -0,0 +1,43 @@
+import { ResponseError } from "../../errors.js";
+import { Writer } from "../../protocol/writer.js";
+import { createAPI } from "../definitions.js";
+/*
+  ListGroups Request (Version: 5) => [states_filter] [types_filter] TAG_BUFFER
+    states_filter => COMPACT_STRING
+    types_filter => COMPACT_STRING
+*/
+export function createRequest(statesFilter, typesFilter) {
+    return Writer.create()
+        .appendArray(statesFilter, (w, s) => w.appendString(s), true, false)
+        .appendArray(typesFilter, (w, t) => w.appendString(t), true, false)
+        .appendTaggedFields();
+}
+/*
+  ListGroups Response (Version: 5) => throttle_time_ms error_code [groups] TAG_BUFFER
+    throttle_time_ms => INT32
+    error_code => INT16
+    groups => group_id protocol_type group_state group_type TAG_BUFFER
+      group_id => COMPACT_STRING
+      protocol_type => COMPACT_STRING
+      group_state => COMPACT_STRING
+      group_type => COMPACT_STRING
+*/
+export function parseResponse(_correlationId, apiKey, apiVersion, reader) {
+    const response = {
+        throttleTimeMs: reader.readInt32(),
+        errorCode: reader.readInt16(),
+        groups: reader.readArray(r => {
+            return {
+                groupId: r.readNullableString(),
+                protocolType: r.readString(),
+                groupState: r.readString(),
+                groupType: r.readString()
+            };
+        })
+    };
+    if (response.errorCode !== 0) {
+        throw new ResponseError(apiKey, apiVersion, { '': response.errorCode }, response);
+    }
+    return response;
+}
+export const api = createAPI(16, 5, createRequest, parseResponse);

package/dist/apis/admin/list-partition-reassignments.d.ts

@@ -0,0 +1,27 @@
+import { type NullableString } from '../../protocol/definitions.ts';
+import { type Reader } from '../../protocol/reader.ts';
+import { Writer } from '../../protocol/writer.ts';
+export interface ListPartitionReassignmentsRequestTopic {
+    name: string;
+    partitionIndexes: number[];
+}
+export type ListPartitionReassignmentsRequest = Parameters<typeof createRequest>;
+export interface ListPartitionReassignmentsResponsePartition {
+    partitionIndex: number;
+    replicas: number[];
+    addingReplicas: number[];
+    removingReplicas: number[];
+}
+export interface ListPartitionReassignmentsResponseTopic {
+    name: string;
+    partitions: ListPartitionReassignmentsResponsePartition[];
+}
+export interface ListPartitionReassignmentsResponse {
+    throttleTimeMs: number;
+    errorCode: number;
+    errorMessage: NullableString;
+    topics: ListPartitionReassignmentsResponseTopic[];
+}
+export declare function createRequest(timeoutMs: number, topics: ListPartitionReassignmentsRequestTopic[]): Writer;
+export declare function parseResponse(_correlationId: number, apiKey: number, apiVersion: number, reader: Reader): ListPartitionReassignmentsResponse;
+export declare const api: import("../definitions.ts").API<[timeoutMs: number, topics: ListPartitionReassignmentsRequestTopic[]], ListPartitionReassignmentsResponse>;

package/dist/apis/admin/list-partition-reassignments.js

@@ -0,0 +1,56 @@
+import { ResponseError } from "../../errors.js";
+import { Writer } from "../../protocol/writer.js";
+import { createAPI } from "../definitions.js";
+/*
+  ListPartitionReassignments Request (Version: 0) => timeout_ms [topics] TAG_BUFFER
+    timeout_ms => INT32
+    topics => name [partition_indexes] TAG_BUFFER
+      name => COMPACT_STRING
+      partition_indexes => INT32
+*/
+export function createRequest(timeoutMs, topics) {
+    return Writer.create()
+        .appendInt32(timeoutMs)
+        .appendArray(topics, (w, t) => {
+        w.appendString(t.name).appendArray(t.partitionIndexes, (w, p) => w.appendInt32(p), true, false);
+    })
+        .appendTaggedFields();
+}
+/*
+  ListPartitionReassignments Response (Version: 0) => throttle_time_ms error_code error_message [topics] TAG_BUFFER
+    throttle_time_ms => INT32
+    error_code => INT16
+    error_message => COMPACT_NULLABLE_STRING
+    topics => name [partitions] TAG_BUFFER
+      name => COMPACT_STRING
+      partitions => partition_index [replicas] [adding_replicas] [removing_replicas] TAG_BUFFER
+        partition_index => INT32
+        replicas => INT32
+        adding_replicas => INT32
+        removing_replicas => INT32
+*/
+export function parseResponse(_correlationId, apiKey, apiVersion, reader) {
+    const response = {
+        throttleTimeMs: reader.readInt32(),
+        errorCode: reader.readInt16(),
+        errorMessage: reader.readNullableString(),
+        topics: reader.readArray(r => {
+            return {
+                name: r.readString(),
+                partitions: r.readArray(r => {
+                    return {
+                        partitionIndex: r.readInt32(),
+                        replicas: r.readArray(r => r.readInt32(), true, false),
+                        addingReplicas: r.readArray(r => r.readInt32(), true, false),
+                        removingReplicas: r.readArray(r => r.readInt32(), true, false)
+                    };
+                })
+            };
+        })
+    };
+    if (response.errorCode !== 0) {
+        throw new ResponseError(apiKey, apiVersion, { '': response.errorCode }, response);
+    }
+    return response;
+}
+export const api = createAPI(46, 0, createRequest, parseResponse);

package/dist/apis/admin/list-transactions.d.ts

@@ -0,0 +1,18 @@
+import { type Reader } from '../../protocol/reader.ts';
+import { Writer } from '../../protocol/writer.ts';
+import { type TransactionState } from '../enumerations.ts';
+export type ListTransactionsRequest = Parameters<typeof createRequest>;
+export interface ListTransactionsResponseTransactionState {
+    transactionalId: string;
+    producerId: bigint;
+    transactionState: string;
+}
+export interface ListTransactionsResponse {
+    throttleTimeMs: number;
+    errorCode: number;
+    unknownStateFilters: string[];
+    transactionStates: ListTransactionsResponseTransactionState[];
+}
+export declare function createRequest(stateFilters: TransactionState[], producerIdFilters: bigint[], durationFilter: bigint): Writer;
+export declare function parseResponse(_correlationId: number, apiKey: number, apiVersion: number, reader: Reader): ListTransactionsResponse;
+export declare const api: import("../definitions.ts").API<[stateFilters: ("EMPTY" | "ONGOING" | "PREPARE_ABORT" | "COMMITTING" | "ABORTING" | "COMPLETE_COMMIT" | "COMPLETE_ABORT")[], producerIdFilters: bigint[], durationFilter: bigint], ListTransactionsResponse>;

package/dist/apis/admin/list-transactions.js

@@ -0,0 +1,45 @@
+import { ResponseError } from "../../errors.js";
+import { Writer } from "../../protocol/writer.js";
+import { createAPI } from "../definitions.js";
+/*
+  ListTransactions Request (Version: 1) => [state_filters] [producer_id_filters] duration_filter TAG_BUFFER
+    state_filters => COMPACT_STRING
+    producer_id_filters => INT64
+    duration_filter => INT64
+*/
+export function createRequest(stateFilters, producerIdFilters, durationFilter) {
+    return Writer.create()
+        .appendArray(stateFilters, (w, t) => w.appendString(t), true, false)
+        .appendArray(producerIdFilters, (w, p) => w.appendInt64(p), true, false)
+        .appendInt64(durationFilter)
+        .appendTaggedFields();
+}
+/*
+  ListTransactions Response (Version: 1) => throttle_time_ms error_code [unknown_state_filters] [transaction_states] TAG_BUFFER
+    throttle_time_ms => INT32
+    error_code => INT16
+    unknown_state_filters => COMPACT_STRING
+    transaction_states => transactional_id producer_id transaction_state TAG_BUFFER
+      transactional_id => COMPACT_STRING
+      producer_id => INT64
+      transaction_state => COMPACT_STRING
+*/
+export function parseResponse(_correlationId, apiKey, apiVersion, reader) {
+    const response = {
+        throttleTimeMs: reader.readInt32(),
+        errorCode: reader.readInt16(),
+        unknownStateFilters: reader.readArray(r => r.readString(), true, false),
+        transactionStates: reader.readArray(r => {
+            return {
+                transactionalId: r.readString(),
+                producerId: r.readInt64(),
+                transactionState: r.readString()
+            };
+        })
+    };
+    if (response.errorCode !== 0) {
+        throw new ResponseError(apiKey, apiVersion, { '': response.errorCode }, response);
+    }
+    return response;
+}
+export const api = createAPI(66, 1, createRequest, parseResponse);

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

@@ -0,0 +1,26 @@
+import { type Reader } from '../../protocol/reader.ts';
+import { Writer } from '../../protocol/writer.ts';
+export interface OffsetDeleteRequestPartition {
+    partitionIndex: number;
+}
+export interface OffsetDeleteRequestTopic {
+    name: string;
+    partitions: OffsetDeleteRequestPartition[];
+}
+export type OffsetDeleteRequest = Parameters<typeof createRequest>;
+export interface OffsetDeleteResponsePartition {
+    partitionIndex: number;
+    errorCode: number;
+}
+export interface OffsetDeleteResponseTopic {
+    name: string;
+    partitions: OffsetDeleteResponsePartition[];
+}
+export interface OffsetDeleteResponse {
+    errorCode: number;
+    throttleTimeMs: number;
+    topics: OffsetDeleteResponseTopic[];
+}
+export declare function createRequest(groupId: string, topics: OffsetDeleteRequestTopic[]): Writer;
+export declare function parseResponse(_correlationId: number, apiKey: number, apiVersion: number, reader: Reader): OffsetDeleteResponse;
+export declare const api: import("../definitions.ts").API<[groupId: string, topics: OffsetDeleteRequestTopic[]], OffsetDeleteResponse>;

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

@@ -0,0 +1,59 @@
+import { ResponseError } from "../../errors.js";
+import { Writer } from "../../protocol/writer.js";
+import { createAPI } from "../definitions.js";
+/*
+  OffsetDelete Request (Version: 0) => group_id [topics]
+    group_id => STRING
+    topics => name [partitions]
+      name => STRING
+      partitions => partition_index
+        partition_index => INT32
+*/
+export function createRequest(groupId, topics) {
+    return Writer.create()
+        .appendString(groupId, false)
+        .appendArray(topics, (w, t) => {
+        w.appendString(t.name, false).appendArray(t.partitions, (w, p) => w.appendInt32(p.partitionIndex), false, false);
+    }, false, false);
+}
+/*
+  OffsetDelete Response (Version: 0) => error_code throttle_time_ms [topics]
+    error_code => INT16
+    throttle_time_ms => INT32
+    topics => name [partitions]
+      name => STRING
+      partitions => partition_index error_code
+        partition_index => INT32
+        error_code => INT16
+*/
+export function parseResponse(_correlationId, apiKey, apiVersion, reader) {
+    const errors = [];
+    const errorCode = reader.readInt16();
+    if (errorCode !== 0) {
+        errors.push(['', errorCode]);
+    }
+    const response = {
+        errorCode,
+        throttleTimeMs: reader.readInt32(),
+        topics: reader.readArray((r, i) => {
+            return {
+                name: r.readString(),
+                partitions: r.readArray((r, j) => {
+                    const partition = {
+                        partitionIndex: r.readInt32(),
+                        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(47, 0, createRequest, parseResponse, false, false);

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

@@ -0,0 +1,11 @@
+import { type Reader } from '../../protocol/reader.ts';
+import { Writer } from '../../protocol/writer.ts';
+export type RenewDelegationTokenRequest = Parameters<typeof createRequest>;
+export interface RenewDelegationTokenResponse {
+    errorCode: number;
+    expiryTimestampMs: bigint;
+    throttleTimeMs: number;
+}
+export declare function createRequest(hmac: Buffer, renewPeriodMs: bigint): Writer;
+export declare function parseResponse(_correlationId: number, apiKey: number, apiVersion: number, reader: Reader): RenewDelegationTokenResponse;
+export declare const api: import("../definitions.ts").API<[hmac: Buffer<ArrayBufferLike>, renewPeriodMs: bigint], RenewDelegationTokenResponse>;

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

@@ -0,0 +1,29 @@
+import { ResponseError } from "../../errors.js";
+import { Writer } from "../../protocol/writer.js";
+import { createAPI } from "../definitions.js";
+/*
+  RenewDelegationToken Request (Version: 2) => hmac renew_period_ms TAG_BUFFER
+    hmac => COMPACT_BYTES
+    renew_period_ms => INT64
+*/
+export function createRequest(hmac, renewPeriodMs) {
+    return Writer.create().appendBytes(hmac).appendInt64(renewPeriodMs).appendTaggedFields();
+}
+/*
+  RenewDelegationToken Response (Version: 2) => error_code expiry_timestamp_ms throttle_time_ms TAG_BUFFER
+    error_code => INT16
+    expiry_timestamp_ms => INT64
+    throttle_time_ms => INT32
+*/
+export function parseResponse(_correlationId, apiKey, apiVersion, reader) {
+    const response = {
+        errorCode: reader.readInt16(),
+        expiryTimestampMs: reader.readInt64(),
+        throttleTimeMs: reader.readInt32()
+    };
+    if (response.errorCode !== 0) {
+        throw new ResponseError(apiKey, apiVersion, { '': response.errorCode }, response);
+    }
+    return response;
+}
+export const api = createAPI(39, 2, createRequest, parseResponse);

package/dist/apis/admin/unregister-broker.d.ts

@@ -0,0 +1,12 @@
+import { type NullableString } from '../../protocol/definitions.ts';
+import { type Reader } from '../../protocol/reader.ts';
+import { Writer } from '../../protocol/writer.ts';
+export type UnregisterBrokerRequest = Parameters<typeof createRequest>;
+export interface UnregisterBrokerResponse {
+    throttleTimeMs: number;
+    errorCode: number;
+    errorMessage: NullableString;
+}
+export declare function createRequest(brokerId: number): Writer;
+export declare function parseResponse(_correlationId: number, apiKey: number, apiVersion: number, reader: Reader): UnregisterBrokerResponse;
+export declare const api: import("../definitions.ts").API<[brokerId: number], UnregisterBrokerResponse>;

package/dist/apis/admin/unregister-broker.js

@@ -0,0 +1,28 @@
+import { ResponseError } from "../../errors.js";
+import { Writer } from "../../protocol/writer.js";
+import { createAPI } from "../definitions.js";
+/*
+UnregisterBroker Request (Version: 0) => broker_id TAG_BUFFER
+  broker_id => INT32
+*/
+export function createRequest(brokerId) {
+    return Writer.create().appendInt32(brokerId).appendTaggedFields();
+}
+/*
+  UnregisterBroker Response (Version: 0) => throttle_time_ms error_code error_message TAG_BUFFER
+    throttle_time_ms => INT32
+    error_code => INT16
+    error_message => COMPACT_NULLABLE_STRING
+*/
+export function parseResponse(_correlationId, apiKey, apiVersion, reader) {
+    const response = {
+        throttleTimeMs: reader.readInt32(),
+        errorCode: reader.readInt16(),
+        errorMessage: reader.readNullableString()
+    };
+    if (response.errorCode !== 0) {
+        throw new ResponseError(apiKey, apiVersion, { '': response.errorCode }, response);
+    }
+    return response;
+}
+export const api = createAPI(64, 0, createRequest, parseResponse);

package/dist/apis/admin/update-features.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 interface UpdateFeaturesRequestFeature {
+    feature: string;
+    maxVersionLevel: number;
+    upgradeType: number;
+}
+export type UpdateFeaturesRequest = Parameters<typeof createRequest>;
+export interface UpdateFeaturesResponseResult {
+    feature: string;
+    errorCode: number;
+    errorMessage: NullableString;
+}
+export interface UpdateFeaturesResponse {
+    throttleTimeMs: number;
+    errorCode: number;
+    errorMessage: NullableString;
+    results: UpdateFeaturesResponseResult[];
+}
+export declare function createRequest(timeoutMs: number, featureUpdates: UpdateFeaturesRequestFeature[], validateOnly: boolean): Writer;
+export declare function parseResponse(_correlationId: number, apiKey: number, apiVersion: number, reader: Reader): UpdateFeaturesResponse;
+export declare const api: import("../definitions.ts").API<[timeoutMs: number, featureUpdates: UpdateFeaturesRequestFeature[], validateOnly: boolean], UpdateFeaturesResponse>;

package/dist/apis/admin/update-features.js

@@ -0,0 +1,60 @@
+import { ResponseError } from "../../errors.js";
+import { Writer } from "../../protocol/writer.js";
+import { createAPI } from "../definitions.js";
+/*
+  UpdateFeatures Request (Version: 1) => timeout_ms [feature_updates] validate_only TAG_BUFFER
+    timeout_ms => INT32
+    feature_updates => feature max_version_level upgrade_type TAG_BUFFER
+      feature => COMPACT_STRING
+      max_version_level => INT16
+      upgrade_type => INT8
+    validate_only => BOOLEAN
+*/
+export function createRequest(timeoutMs, featureUpdates, validateOnly) {
+    return Writer.create()
+        .appendInt32(timeoutMs)
+        .appendArray(featureUpdates, (w, f) => {
+        w.appendString(f.feature).appendInt16(f.maxVersionLevel).appendInt8(f.upgradeType);
+    })
+        .appendBoolean(validateOnly)
+        .appendTaggedFields();
+}
+/*
+  UpdateFeatures Response (Version: 1) => throttle_time_ms error_code error_message [results] TAG_BUFFER
+    throttle_time_ms => INT32
+    error_code => INT16
+    error_message => COMPACT_NULLABLE_STRING
+    results => feature error_code error_message TAG_BUFFER
+      feature => COMPACT_STRING
+      error_code => INT16
+      error_message => COMPACT_NULLABLE_STRING
+*/
+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,
+        errorMessage: reader.readNullableString(),
+        results: reader.readArray((r, i) => {
+            const result = {
+                feature: 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(57, 1, createRequest, parseResponse);

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

@@ -0,0 +1,27 @@
+import { type NullableString } from '../../protocol/definitions.ts';
+import { type Reader } from '../../protocol/reader.ts';
+import { Writer } from '../../protocol/writer.ts';
+export interface ConsumerGroupHeartbeatRequestTopicPartition {
+    topicId: string;
+    partitions: number[];
+}
+export type ConsumerGroupHeartbeatRequest = Parameters<typeof createRequest>;
+export interface ConsumerGroupHeartbeatResponseAssignmentTopicPartition {
+    topicId: string;
+    partitions: number[];
+}
+export interface ConsumerGroupHeartbeatResponseAssignment {
+    topicPartitions: ConsumerGroupHeartbeatResponseAssignmentTopicPartition[];
+}
+export interface ConsumerGroupHeartbeatResponse {
+    throttleTimeMs: number;
+    errorCode: number;
+    errorMessage: NullableString;
+    memberId: NullableString;
+    memberEpoch: number;
+    heartbeatIntervalMs: number;
+    assignment: ConsumerGroupHeartbeatResponseAssignment[];
+}
+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;
+export declare const api: import("../definitions.ts").API<[groupId: string, memberId: string, memberEpoch: number, instanceId: NullableString, rackId: NullableString, rebalanceTimeoutMs: number, subscribedTopicNames: string[] | null, serverAssignor: NullableString, topicPartitions: ConsumerGroupHeartbeatRequestTopicPartition[]], ConsumerGroupHeartbeatResponse>;

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

@@ -0,0 +1,70 @@
+import { ResponseError } from "../../errors.js";
+import { Writer } from "../../protocol/writer.js";
+import { createAPI } from "../definitions.js";
+/*
+  ConsumerGroupHeartbeat Request (Version: 0) => group_id member_id member_epoch instance_id rack_id rebalance_timeout_ms [subscribed_topic_names] server_assignor [topic_partitions] TAG_BUFFER
+    group_id => COMPACT_STRING
+    member_id => COMPACT_STRING
+    member_epoch => INT32
+    instance_id => COMPACT_NULLABLE_STRING
+    rack_id => COMPACT_NULLABLE_STRING
+    rebalance_timeout_ms => INT32
+    subscribed_topic_names => COMPACT_STRING
+    server_assignor => COMPACT_NULLABLE_STRING
+    topic_partitions => topic_id [partitions] TAG_BUFFER
+      topic_id => UUID
+      partitions => INT32
+*/
+export function createRequest(groupId, memberId, memberEpoch, instanceId, rackId, rebalanceTimeoutMs, subscribedTopicNames, serverAssignor, topicPartitions) {
+    return Writer.create()
+        .appendString(groupId)
+        .appendString(memberId)
+        .appendInt32(memberEpoch)
+        .appendString(instanceId)
+        .appendString(rackId)
+        .appendInt32(rebalanceTimeoutMs)
+        .appendArray(subscribedTopicNames, (w, t) => w.appendString(t), true, false)
+        .appendString(serverAssignor)
+        .appendArray(topicPartitions, (w, t) => {
+        return w.appendUUID(t.topicId).appendArray(t.partitions, (w, p) => w.appendInt32(p), true, false);
+    })
+        .appendTaggedFields();
+}
+/*
+  ConsumerGroupHeartbeat Response (Version: 0) => throttle_time_ms error_code error_message member_id member_epoch heartbeat_interval_ms assignment TAG_BUFFER
+    throttle_time_ms => INT32
+    error_code => INT16
+    error_message => COMPACT_NULLABLE_STRING
+    member_id => COMPACT_NULLABLE_STRING
+    member_epoch => INT32
+    heartbeat_interval_ms => INT32
+    assignment => [topic_partitions] TAG_BUFFER
+      topic_partitions => topic_id [partitions] TAG_BUFFER
+        topic_id => UUID
+        partitions => INT32
+*/
+export function parseResponse(_correlationId, apiKey, apiVersion, reader) {
+    const response = {
+        throttleTimeMs: reader.readInt32(),
+        errorCode: reader.readInt16(),
+        errorMessage: reader.readNullableString(),
+        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)
+                    };
+                })
+            };
+        })
+    };
+    if (response.errorCode !== 0) {
+        throw new ResponseError(apiKey, apiVersion, { '': response.errorCode }, response);
+    }
+    return response;
+}
+export const api = createAPI(68, 0, createRequest, parseResponse);