@platformatic/kafka 0.1.0

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

@@ -0,0 +1,50 @@
+import { type NullableString } from '../../protocol/definitions.ts';
+import { type Reader } from '../../protocol/reader.ts';
+import { Writer } from '../../protocol/writer.ts';
+export interface DescribeQuorumRequestPartition {
+    partitionIndex: number;
+}
+export interface DescribeQuorumRequestTopic {
+    topicName: string;
+    partitions: DescribeQuorumRequestPartition[];
+}
+export type DescribeQuorumRequest = Parameters<typeof createRequest>;
+export interface DescribeQuorumResponseVoter {
+    replicaId: number;
+    replicaDirectoryId: string;
+    logEndOffset: bigint;
+    lastFetchTimestamp: bigint;
+    lastCaughtUpTimestamp: bigint;
+}
+export interface DescribeQuorumResponsePartition {
+    partitionIndex: number;
+    errorCode: number;
+    errorMessage: NullableString;
+    leaderId: number;
+    leaderEpoch: number;
+    highWatermark: bigint;
+    currentVoters: DescribeQuorumResponseVoter[];
+    observers: DescribeQuorumResponseVoter[];
+}
+export interface DescribeQuorumResponseNodeListener {
+    name: string;
+    host: string;
+    port: number;
+}
+export interface DescribeQuorumResponseTopic {
+    topicName: string;
+    partitions: DescribeQuorumResponsePartition[];
+}
+export interface DescribeQuorumResponseNode {
+    nodeId: number;
+    listeners: DescribeQuorumResponseNodeListener[];
+}
+export interface DescribeQuorumResponse {
+    errorCode: number;
+    errorMessage: NullableString;
+    topics: DescribeQuorumResponseTopic[];
+    nodes: DescribeQuorumResponseNode[];
+}
+export declare function createRequest(topics: DescribeQuorumRequestTopic[]): Writer;
+export declare function parseResponse(_correlationId: number, apiKey: number, apiVersion: number, reader: Reader): DescribeQuorumResponse;
+export declare const api: import("../definitions.ts").API<[topics: DescribeQuorumRequestTopic[]], DescribeQuorumResponse>;

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

@@ -0,0 +1,116 @@
+import { ResponseError } from "../../errors.js";
+import { Writer } from "../../protocol/writer.js";
+import { createAPI } from "../definitions.js";
+/*
+  DescribeQuorum Request (Version: 2) => [topics] TAG_BUFFER
+    topics => topic_name [partitions] TAG_BUFFER
+      topic_name => COMPACT_STRING
+      partitions => partition_index TAG_BUFFER
+        partition_index => INT32
+*/
+export function createRequest(topics) {
+    return Writer.create()
+        .appendArray(topics, (w, t) => {
+        w.appendString(t.topicName).appendArray(t.partitions, (w, p) => {
+            w.appendInt32(p.partitionIndex);
+        });
+    })
+        .appendTaggedFields();
+}
+/*
+  DescribeQuorum Response (Version: 2) => error_code error_message [topics] [nodes] TAG_BUFFER
+    error_code => INT16
+    error_message => COMPACT_NULLABLE_STRING
+    topics => topic_name [partitions] TAG_BUFFER
+      topic_name => COMPACT_STRING
+      partitions => partition_index error_code error_message leader_id leader_epoch high_watermark [current_voters] [observers] TAG_BUFFER
+        partition_index => INT32
+        error_code => INT16
+        error_message => COMPACT_NULLABLE_STRING
+        leader_id => INT32
+        leader_epoch => INT32
+        high_watermark => INT64
+        current_voters => replica_id replica_directory_id log_end_offset last_fetch_timestamp last_caught_up_timestamp TAG_BUFFER
+          replica_id => INT32
+          replica_directory_id => UUID
+          log_end_offset => INT64
+          last_fetch_timestamp => INT64
+          last_caught_up_timestamp => INT64
+        observers => replica_id replica_directory_id log_end_offset last_fetch_timestamp last_caught_up_timestamp TAG_BUFFER
+          replica_id => INT32
+          replica_directory_id => UUID
+          log_end_offset => INT64
+          last_fetch_timestamp => INT64
+          last_caught_up_timestamp => INT64
+    nodes => node_id [listeners] TAG_BUFFER
+      node_id => INT32
+      listeners => name host port TAG_BUFFER
+        name => COMPACT_STRING
+        host => COMPACT_STRING
+        port => UINT16
+*/
+export function parseResponse(_correlationId, apiKey, apiVersion, reader) {
+    const errors = [];
+    const errorCode = reader.readInt16();
+    if (errorCode !== 0) {
+        errors.push(['', errorCode]);
+    }
+    const response = {
+        errorCode,
+        errorMessage: reader.readNullableString(),
+        topics: reader.readArray((r, i) => {
+            return {
+                topicName: r.readString(),
+                partitions: r.readArray((r, j) => {
+                    const partition = {
+                        partitionIndex: r.readInt32(),
+                        errorCode: r.readInt16(),
+                        errorMessage: r.readNullableString(),
+                        leaderId: r.readInt32(),
+                        leaderEpoch: r.readInt32(),
+                        highWatermark: r.readInt64(),
+                        currentVoters: r.readArray(r => {
+                            return {
+                                replicaId: r.readInt32(),
+                                replicaDirectoryId: r.readUUID(),
+                                logEndOffset: r.readInt64(),
+                                lastFetchTimestamp: r.readInt64(),
+                                lastCaughtUpTimestamp: r.readInt64()
+                            };
+                        }),
+                        observers: r.readArray(r => {
+                            return {
+                                replicaId: r.readInt32(),
+                                replicaDirectoryId: r.readUUID(),
+                                logEndOffset: r.readInt64(),
+                                lastFetchTimestamp: r.readInt64(),
+                                lastCaughtUpTimestamp: r.readInt64()
+                            };
+                        })
+                    };
+                    if (partition.errorCode !== 0) {
+                        errors.push([`/topics/${i}/partitions/${j}`, partition.errorCode]);
+                    }
+                    return partition;
+                })
+            };
+        }),
+        nodes: reader.readArray(r => {
+            return {
+                nodeId: r.readInt32(),
+                listeners: r.readArray(r => {
+                    return {
+                        name: r.readString(),
+                        host: r.readString(),
+                        port: r.readUnsignedInt16()
+                    };
+                })
+            };
+        })
+    };
+    if (errors.length) {
+        throw new ResponseError(apiKey, apiVersion, Object.fromEntries(errors), response);
+    }
+    return response;
+}
+export const api = createAPI(55, 2, createRequest, parseResponse);

package/dist/apis/admin/describe-topic-partitions.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 DescribeTopicPartitionsRequestTopic {
+    name: string;
+}
+export interface DescribeTopicPartitionsRequestCursor {
+    topicName: string;
+    partitionIndex: number;
+}
+export type DescribeTopicPartitionsRequest = Parameters<typeof createRequest>;
+export interface DescribeTopicPartitionsResponsePartition {
+    errorCode: number;
+    partitionIndex: number;
+    leaderId: number;
+    leaderEpoch: number;
+    replicaNodes: number[];
+    isrNodes: number[];
+    eligibleLeaderReplicas: number[];
+    lastKnownElr: number[];
+    offlineReplicas: number[];
+}
+export interface DescribeTopicPartitionsResponseTopic {
+    errorCode: number;
+    name: NullableString;
+    topicId: string;
+    isInternal: boolean;
+    partitions: DescribeTopicPartitionsResponsePartition[];
+    topicAuthorizedOperations: number;
+}
+export interface DescribeTopicPartitionsResponseCursor {
+    topicName: string;
+    partitionIndex: number;
+}
+export interface DescribeTopicPartitionsResponse {
+    throttleTimeMs: number;
+    topics: DescribeTopicPartitionsResponseTopic[];
+    nextCursor?: DescribeTopicPartitionsResponseCursor;
+}
+export declare function createRequest(topics: DescribeTopicPartitionsRequestTopic[], responsePartitionLimit: number, cursor?: DescribeTopicPartitionsRequestCursor): Writer;
+export declare function parseResponse(_correlationId: number, apiKey: number, apiVersion: number, reader: Reader): DescribeTopicPartitionsResponse;
+export declare const api: import("../definitions.ts").API<[topics: DescribeTopicPartitionsRequestTopic[], responsePartitionLimit: number, cursor?: DescribeTopicPartitionsRequestCursor | undefined], DescribeTopicPartitionsResponse>;

package/dist/apis/admin/describe-topic-partitions.js

@@ -0,0 +1,94 @@
+import { ResponseError } from "../../errors.js";
+import { Writer } from "../../protocol/writer.js";
+import { createAPI } from "../definitions.js";
+/*
+  DescribeTopicPartitions Request (Version: 0) => [topics] response_partition_limit cursor TAG_BUFFER
+    topics => name TAG_BUFFER
+      name => COMPACT_STRING
+    response_partition_limit => INT32
+    cursor => topic_name partition_index TAG_BUFFER
+      topic_name => COMPACT_STRING
+      partition_index => INT32
+*/
+export function createRequest(topics, responsePartitionLimit, cursor) {
+    const writer = Writer.create()
+        .appendArray(topics, (w, t) => w.appendString(t.name))
+        .appendInt32(responsePartitionLimit);
+    if (cursor) {
+        writer.appendInt8(1).appendString(cursor.topicName).appendInt32(cursor.partitionIndex).appendTaggedFields();
+    }
+    else {
+        writer.appendInt8(-1);
+    }
+    return writer.appendTaggedFields();
+}
+/*
+  DescribeTopicPartitions Response (Version: 0) => throttle_time_ms [topics] next_cursor TAG_BUFFER
+    throttle_time_ms => INT32
+    topics => error_code name topic_id is_internal [partitions] topic_authorized_operations TAG_BUFFER
+      error_code => INT16
+      name => COMPACT_NULLABLE_STRING
+      topic_id => UUID
+      is_internal => BOOLEAN
+      partitions => error_code partition_index leader_id leader_epoch [replica_nodes] [isr_nodes] [eligible_leader_replicas] [last_known_elr] [offline_replicas] TAG_BUFFER
+        error_code => INT16
+        partition_index => INT32
+        leader_id => INT32
+        leader_epoch => INT32
+        replica_nodes => INT32
+        isr_nodes => INT32
+        eligible_leader_replicas => INT32
+        last_known_elr => INT32
+        offline_replicas => INT32
+      topic_authorized_operations => INT32
+    next_cursor => topic_name partition_index TAG_BUFFER
+      topic_name => COMPACT_STRING
+      partition_index => INT32
+*/
+export function parseResponse(_correlationId, apiKey, apiVersion, reader) {
+    const errors = [];
+    const response = {
+        throttleTimeMs: reader.readInt32(),
+        topics: reader.readArray((r, i) => {
+            const errorCode = r.readInt16();
+            if (errorCode !== 0) {
+                errors.push([`/topics/${i}`, errorCode]);
+            }
+            return {
+                errorCode,
+                name: r.readNullableString(),
+                topicId: r.readUUID(),
+                isInternal: r.readBoolean(),
+                partitions: r.readArray((r, j) => {
+                    const errorCode = r.readInt16();
+                    if (errorCode !== 0) {
+                        errors.push([`/topics/${i}/partitions/${j}`, errorCode]);
+                    }
+                    return {
+                        errorCode,
+                        partitionIndex: r.readInt32(),
+                        leaderId: r.readInt32(),
+                        leaderEpoch: r.readInt32(),
+                        replicaNodes: r.readArray(r => r.readInt32(), true, false),
+                        isrNodes: r.readArray(r => r.readInt32(), true, false),
+                        eligibleLeaderReplicas: r.readArray(r => r.readInt32(), true, false),
+                        lastKnownElr: r.readArray(r => r.readInt32(), true, false),
+                        offlineReplicas: r.readArray(r => r.readInt32(), true, false)
+                    };
+                }),
+                topicAuthorizedOperations: r.readInt32()
+            };
+        })
+    };
+    if (reader.readInt8() === 1) {
+        response.nextCursor = {
+            topicName: reader.readString(),
+            partitionIndex: reader.readInt32()
+        };
+    }
+    if (errors.length) {
+        throw new ResponseError(apiKey, apiVersion, Object.fromEntries(errors), response);
+    }
+    return response;
+}
+export const api = createAPI(75, 0, createRequest, parseResponse);

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

@@ -0,0 +1,24 @@
+import { type Reader } from '../../protocol/reader.ts';
+import { Writer } from '../../protocol/writer.ts';
+export type DescribeTransactionsRequest = Parameters<typeof createRequest>;
+export interface DescribeTransactionsResponseTopic {
+    topic: string;
+    partitions: number[];
+}
+export interface DescribeTransactionsResponseTransactionState {
+    errorCode: number;
+    transactionalId: string;
+    transactionState: string;
+    transactionTimeoutMs: number;
+    transactionStartTimeMs: bigint;
+    producerId: bigint;
+    producerEpoch: number;
+    topics: DescribeTransactionsResponseTopic[];
+}
+export interface DescribeTransactionsResponse {
+    throttleTimeMs: number;
+    transactionStates: DescribeTransactionsResponseTransactionState[];
+}
+export declare function createRequest(transactionalIds: string[]): Writer;
+export declare function parseResponse(_correlationId: number, apiKey: number, apiVersion: number, reader: Reader): DescribeTransactionsResponse;
+export declare const api: import("../definitions.ts").API<[transactionalIds: string[]], DescribeTransactionsResponse>;

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

@@ -0,0 +1,59 @@
+import { ResponseError } from "../../errors.js";
+import { Writer } from "../../protocol/writer.js";
+import { createAPI } from "../definitions.js";
+/*
+DescribeTransactions Request (Version: 0) => [transactional_ids] TAG_BUFFER
+  transactional_ids => COMPACT_STRING
+*/
+export function createRequest(transactionalIds) {
+    return Writer.create()
+        .appendArray(transactionalIds, (w, t) => w.appendString(t), true, false)
+        .appendTaggedFields();
+}
+/*
+DescribeTransactions Response (Version: 0) => throttle_time_ms [transaction_states] TAG_BUFFER
+  throttle_time_ms => INT32
+  transaction_states => error_code transactional_id transaction_state transaction_timeout_ms transaction_start_time_ms producer_id producer_epoch [topics] TAG_BUFFER
+    error_code => INT16
+    transactional_id => COMPACT_STRING
+    transaction_state => COMPACT_STRING
+    transaction_timeout_ms => INT32
+    transaction_start_time_ms => INT64
+    producer_id => INT64
+    producer_epoch => INT16
+    topics => topic [partitions] TAG_BUFFER
+      topic => COMPACT_STRING
+      partitions => INT32
+*/
+export function parseResponse(_correlationId, apiKey, apiVersion, reader) {
+    const errors = [];
+    const response = {
+        throttleTimeMs: reader.readInt32(),
+        transactionStates: reader.readArray((r, i) => {
+            const state = {
+                errorCode: r.readInt16(),
+                transactionalId: r.readString(),
+                transactionState: r.readString(),
+                transactionTimeoutMs: r.readInt32(),
+                transactionStartTimeMs: r.readInt64(),
+                producerId: r.readInt64(),
+                producerEpoch: r.readInt16(),
+                topics: r.readArray(r => {
+                    return {
+                        topic: r.readString(),
+                        partitions: r.readArray(r => r.readInt32(), true, false)
+                    };
+                })
+            };
+            if (state.errorCode !== 0) {
+                errors.push([`/transaction_states/${i}`, state.errorCode]);
+            }
+            return state;
+        })
+    };
+    if (errors.length) {
+        throw new ResponseError(apiKey, apiVersion, Object.fromEntries(errors), response);
+    }
+    return response;
+}
+export const api = createAPI(65, 0, createRequest, parseResponse);

package/dist/apis/admin/describe-user-scram-credentials.d.ts

@@ -0,0 +1,26 @@
+import { type NullableString } from '../../protocol/definitions.ts';
+import { type Reader } from '../../protocol/reader.ts';
+import { Writer } from '../../protocol/writer.ts';
+export interface DescribeUserScramCredentialsRequestUser {
+    name: string;
+}
+export type DescribeUserScramCredentialsRequest = Parameters<typeof createRequest>;
+export interface DescribeUserScramCredentialsResponseResultCredentialInfo {
+    mechanism: number;
+    iterations: number;
+}
+export interface DescribeUserScramCredentialsResponseResult {
+    user: string;
+    errorCode: number;
+    errorMessage: NullableString;
+    credentialInfos: DescribeUserScramCredentialsResponseResultCredentialInfo[];
+}
+export interface DescribeUserScramCredentialsResponse {
+    throttleTimeMs: number;
+    errorCode: number;
+    errorMessage: NullableString;
+    results: DescribeUserScramCredentialsResponseResult[];
+}
+export declare function createRequest(users: DescribeUserScramCredentialsRequestUser[]): Writer;
+export declare function parseResponse(_correlationId: number, apiKey: number, apiVersion: number, reader: Reader): DescribeUserScramCredentialsResponse;
+export declare const api: import("../definitions.ts").API<[users: DescribeUserScramCredentialsRequestUser[]], DescribeUserScramCredentialsResponse>;

package/dist/apis/admin/describe-user-scram-credentials.js

@@ -0,0 +1,62 @@
+import { ResponseError } from "../../errors.js";
+import { Writer } from "../../protocol/writer.js";
+import { createAPI } from "../definitions.js";
+/*
+  DescribeUserScramCredentials Request (Version: 0) => [users] TAG_BUFFER
+    users => name TAG_BUFFER
+      name => COMPACT_STRING
+*/
+export function createRequest(users) {
+    return Writer.create()
+        .appendArray(users, (w, u) => w.appendString(u.name))
+        .appendTaggedFields();
+}
+/*
+  DescribeUserScramCredentials Response (Version: 0) => throttle_time_ms error_code error_message [results] TAG_BUFFER
+    throttle_time_ms => INT32
+    error_code => INT16
+    error_message => COMPACT_NULLABLE_STRING
+    results => user error_code error_message [credential_infos] TAG_BUFFER
+      user => COMPACT_STRING
+      error_code => INT16
+      error_message => COMPACT_NULLABLE_STRING
+      credential_infos => mechanism iterations TAG_BUFFER
+        mechanism => INT8
+        iterations => INT32
+*/
+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 user = r.readString();
+            const errorCode = r.readInt16();
+            if (errorCode !== 0) {
+                errors.push([`/results/${i}`, errorCode]);
+            }
+            return {
+                user,
+                errorCode,
+                errorMessage: r.readNullableString(),
+                credentialInfos: r.readArray(r => {
+                    return {
+                        mechanism: r.readInt8(),
+                        iterations: r.readInt32()
+                    };
+                })
+            };
+        })
+    };
+    if (errors.length) {
+        throw new ResponseError(apiKey, apiVersion, Object.fromEntries(errors), response);
+    }
+    return response;
+}
+export const api = createAPI(50, 0, createRequest, parseResponse);

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

@@ -0,0 +1,10 @@
+import { type Reader } from '../../protocol/reader.ts';
+import { Writer } from '../../protocol/writer.ts';
+export type EnvelopeRequest = Parameters<typeof createRequest>;
+export interface EnvelopeResponse {
+    responseData: Buffer | null;
+    errorCode: number;
+}
+export declare function createRequest(requestData: Buffer, requestPrincipal: Buffer | undefined | null, clientHostAddress: Buffer): Writer;
+export declare function parseResponse(_correlationId: number, apiKey: number, apiVersion: number, reader: Reader): EnvelopeResponse;
+export declare const api: import("../definitions.ts").API<[requestData: Buffer<ArrayBufferLike>, requestPrincipal: Buffer<ArrayBufferLike> | null | undefined, clientHostAddress: Buffer<ArrayBufferLike>], EnvelopeResponse>;

package/dist/apis/admin/envelope.js

@@ -0,0 +1,32 @@
+import { ResponseError } from "../../errors.js";
+import { Writer } from "../../protocol/writer.js";
+import { createAPI } from "../definitions.js";
+/*
+Envelope Request (Version: 0) => request_data request_principal client_host_address TAG_BUFFER
+  request_data => COMPACT_BYTES
+  request_principal => COMPACT_NULLABLE_BYTES
+  client_host_address => COMPACT_BYTES
+*/
+export function createRequest(requestData, requestPrincipal, clientHostAddress) {
+    return Writer.create()
+        .appendBytes(requestData)
+        .appendBytes(requestPrincipal)
+        .appendBytes(clientHostAddress)
+        .appendTaggedFields();
+}
+/*
+Envelope Response (Version: 0) => response_data error_code TAG_BUFFER
+  response_data => COMPACT_NULLABLE_BYTES
+  error_code => INT16
+*/
+export function parseResponse(_correlationId, apiKey, apiVersion, reader) {
+    const response = {
+        responseData: reader.readNullableBytes(),
+        errorCode: reader.readInt16()
+    };
+    if (response.errorCode) {
+        throw new ResponseError(apiKey, apiVersion, { '': response.errorCode }, response);
+    }
+    return response;
+}
+export const api = createAPI(58, 0, createRequest, parseResponse);

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

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

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

@@ -0,0 +1,29 @@
+import { ResponseError } from "../../errors.js";
+import { Writer } from "../../protocol/writer.js";
+import { createAPI } from "../definitions.js";
+/*
+  ExpireDelegationToken Request (Version: 2) => hmac expiry_time_period_ms TAG_BUFFER
+    hmac => COMPACT_BYTES
+    expiry_time_period_ms => INT64
+*/
+export function createRequest(hmac, expiryTimePeriodMs) {
+    return Writer.create().appendBytes(hmac).appendInt64(expiryTimePeriodMs).appendTaggedFields();
+}
+/*
+  ExpireDelegationToken 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(40, 2, createRequest, parseResponse);

package/dist/apis/admin/incremental-alter-configs.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 IncrementalAlterConfigsRequestConfig {
+    name: string;
+    configOperation: number;
+    value?: NullableString;
+}
+export interface IncrementalAlterConfigsRequestResource {
+    resourceType: number;
+    resourceName: string;
+    configs: IncrementalAlterConfigsRequestConfig[];
+}
+export type IncrementalAlterConfigsRequest = Parameters<typeof createRequest>;
+export interface IncrementalAlterConfigsResponseResult {
+    errorCode: number;
+    errorMessage: NullableString;
+    resourceType: number;
+    resourceName: string;
+}
+export interface IncrementalAlterConfigsResponse {
+    throttleTimeMs: number;
+    responses: IncrementalAlterConfigsResponseResult[];
+}
+export declare function createRequest(resources: IncrementalAlterConfigsRequestResource[], validateOnly: boolean): Writer;
+export declare function parseResponse(_correlationId: number, apiKey: number, apiVersion: number, reader: Reader): IncrementalAlterConfigsResponse;
+export declare const api: import("../definitions.ts").API<[resources: IncrementalAlterConfigsRequestResource[], validateOnly: boolean], IncrementalAlterConfigsResponse>;

package/dist/apis/admin/incremental-alter-configs.js

@@ -0,0 +1,58 @@
+import { ResponseError } from "../../errors.js";
+import { Writer } from "../../protocol/writer.js";
+import { createAPI } from "../definitions.js";
+/*
+  IncrementalAlterConfigs Request (Version: 1) => [resources] validate_only TAG_BUFFER
+    resources => resource_type resource_name [configs] TAG_BUFFER
+      resource_type => INT8
+      resource_name => COMPACT_STRING
+      configs => name config_operation value TAG_BUFFER
+        name => COMPACT_STRING
+        config_operation => INT8
+        value => COMPACT_NULLABLE_STRING
+    validate_only => BOOLEAN
+*/
+export function createRequest(resources, validateOnly) {
+    return Writer.create()
+        .appendArray(resources, (w, r) => {
+        w.appendInt8(r.resourceType)
+            .appendString(r.resourceName)
+            .appendArray(r.configs, (w, r) => {
+            w.appendString(r.name).appendInt8(r.configOperation).appendString(r.value);
+        });
+    })
+        .appendBoolean(validateOnly)
+        .appendTaggedFields();
+}
+/*
+  IncrementalAlterConfigs Response (Version: 1) => throttle_time_ms [responses] TAG_BUFFER
+    throttle_time_ms => INT32
+    responses => error_code error_message resource_type resource_name TAG_BUFFER
+      error_code => INT16
+      error_message => COMPACT_NULLABLE_STRING
+      resource_type => INT8
+      resource_name => COMPACT_STRING
+*/
+export function parseResponse(_correlationId, apiKey, apiVersion, reader) {
+    const errors = [];
+    const response = {
+        throttleTimeMs: reader.readInt32(),
+        responses: reader.readArray((r, i) => {
+            const errorCode = r.readInt16();
+            if (errorCode !== 0) {
+                errors.push([`/responses/${i}`, errorCode]);
+            }
+            return {
+                errorCode,
+                errorMessage: r.readNullableString(),
+                resourceType: r.readInt8(),
+                resourceName: r.readString()
+            };
+        })
+    };
+    if (errors.length) {
+        throw new ResponseError(apiKey, apiVersion, Object.fromEntries(errors), response);
+    }
+    return response;
+}
+export const api = createAPI(44, 1, createRequest, parseResponse);