@platformatic/kafka 1.1.0 → 1.2.0

package/dist/apis/metadata/find-coordinator-v5.d.ts

@@ -0,0 +1,19 @@
+import { type NullableString } from '../../protocol/definitions.ts';
+import { type Reader } from '../../protocol/reader.ts';
+import { Writer } from '../../protocol/writer.ts';
+export type FindCoordinatorRequest = Parameters<typeof createRequest>;
+export interface FindCoordinatorResponseCoordinator {
+    key: string;
+    nodeId: number;
+    host: string;
+    port: number;
+    errorCode: number;
+    errorMessage: NullableString;
+}
+export interface FindCoordinatorResponse {
+    throttleTimeMs: number;
+    coordinators: FindCoordinatorResponseCoordinator[];
+}
+export declare function createRequest(keyType: number, coordinatorKeys: string[]): Writer;
+export declare function parseResponse(_correlationId: number, apiKey: number, apiVersion: number, reader: Reader): FindCoordinatorResponse;
+export declare const api: import("../definitions.ts").API<[keyType: number, coordinatorKeys: string[]], FindCoordinatorResponse>;

package/dist/apis/metadata/find-coordinator-v5.js

@@ -0,0 +1,50 @@
+import { ResponseError } from "../../errors.js";
+import { Writer } from "../../protocol/writer.js";
+import { createAPI } from "../definitions.js";
+/*
+  FindCoordinator Request (Version: 5) => key_type [coordinator_keys] TAG_BUFFER
+    key_type => INT8
+    coordinator_keys => COMPACT_STRING
+*/
+export function createRequest(keyType, coordinatorKeys) {
+    return Writer.create()
+        .appendInt8(keyType)
+        .appendArray(coordinatorKeys, (w, k) => w.appendString(k), true, false)
+        .appendTaggedFields();
+}
+/*
+  FindCoordinator Response (Version: 5) => throttle_time_ms [coordinators] TAG_BUFFER
+    throttle_time_ms => INT32
+    coordinators => key node_id host port error_code error_message TAG_BUFFER
+      key => COMPACT_STRING
+      node_id => INT32
+      host => COMPACT_STRING
+      port => INT32
+      error_code => INT16
+      error_message => COMPACT_NULLABLE_STRING
+*/
+export function parseResponse(_correlationId, apiKey, apiVersion, reader) {
+    const errors = [];
+    const response = {
+        throttleTimeMs: reader.readInt32(),
+        coordinators: reader.readArray((r, i) => {
+            const coordinator = {
+                key: r.readString(),
+                nodeId: r.readInt32(),
+                host: r.readString(),
+                port: r.readInt32(),
+                errorCode: r.readInt16(),
+                errorMessage: r.readNullableString()
+            };
+            if (coordinator.errorCode !== 0) {
+                errors.push([`/coordinators/${i}`, coordinator.errorCode]);
+            }
+            return coordinator;
+        })
+    };
+    if (errors.length) {
+        throw new ResponseError(apiKey, apiVersion, Object.fromEntries(errors), response);
+    }
+    return response;
+}
+export const api = createAPI(10, 5, createRequest, parseResponse);

package/dist/apis/metadata/find-coordinator-v6.d.ts

@@ -0,0 +1,19 @@
+import { type NullableString } from '../../protocol/definitions.ts';
+import { type Reader } from '../../protocol/reader.ts';
+import { Writer } from '../../protocol/writer.ts';
+export type FindCoordinatorRequest = Parameters<typeof createRequest>;
+export interface FindCoordinatorResponseCoordinator {
+    key: string;
+    nodeId: number;
+    host: string;
+    port: number;
+    errorCode: number;
+    errorMessage: NullableString;
+}
+export interface FindCoordinatorResponse {
+    throttleTimeMs: number;
+    coordinators: FindCoordinatorResponseCoordinator[];
+}
+export declare function createRequest(keyType: number, coordinatorKeys: string[]): Writer;
+export declare function parseResponse(_correlationId: number, apiKey: number, apiVersion: number, reader: Reader): FindCoordinatorResponse;
+export declare const api: import("../definitions.ts").API<[keyType: number, coordinatorKeys: string[]], FindCoordinatorResponse>;

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

@@ -1,3 +1,6 @@
-export * as apiVersionsV4 from './api-versions.ts';
-export * as findCoordinatorV6 from './find-coordinator.ts';
-export * as metadataV12 from './metadata.ts';
+export * as apiVersionsV3 from './api-versions-v3.ts';
+export * as apiVersionsV4 from './api-versions-v4.ts';
+export * as findCoordinatorV4 from './find-coordinator-v4.ts';
+export * as findCoordinatorV5 from './find-coordinator-v5.ts';
+export * as findCoordinatorV6 from './find-coordinator-v6.ts';
+export * as metadataV12 from './metadata-v12.ts';

package/dist/apis/metadata/index.js

@@ -1,3 +1,6 @@
-export * as apiVersionsV4 from "./api-versions.js";
-export * as findCoordinatorV6 from "./find-coordinator.js";
-export * as metadataV12 from "./metadata.js";
+export * as apiVersionsV3 from "./api-versions-v3.js";
+export * as apiVersionsV4 from "./api-versions-v4.js";
+export * as findCoordinatorV4 from "./find-coordinator-v4.js";
+export * as findCoordinatorV5 from "./find-coordinator-v5.js";
+export * as findCoordinatorV6 from "./find-coordinator-v6.js";
+export * as metadataV12 from "./metadata-v12.js";

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

@@ -1,6 +1,8 @@
-export * as addOffsetsToTxnV4 from './add-offsets-to-txn.ts';
-export * as addPartitionsToTxnV5 from './add-partitions-to-txn.ts';
-export * as endTxnV4 from './end-txn.ts';
-export * as initProducerIdV5 from './init-producer-id.ts';
-export * as produceV11 from './produce.ts';
-export * as txnOffsetCommitV4 from './txn-offset-commit.ts';
+export * as addOffsetsToTxnV4 from './add-offsets-to-txn-v4.ts';
+export * as addPartitionsToTxnV5 from './add-partitions-to-txn-v5.ts';
+export * as endTxnV4 from './end-txn-v4.ts';
+export * as initProducerIdV4 from './init-producer-id-v4.ts';
+export * as initProducerIdV5 from './init-producer-id-v5.ts';
+export * as produceV10 from './produce-v10.ts';
+export * as produceV11 from './produce-v11.ts';
+export * as txnOffsetCommitV4 from './txn-offset-commit-v4.ts';

package/dist/apis/producer/index.js

@@ -1,6 +1,8 @@
-export * as addOffsetsToTxnV4 from "./add-offsets-to-txn.js";
-export * as addPartitionsToTxnV5 from "./add-partitions-to-txn.js";
-export * as endTxnV4 from "./end-txn.js";
-export * as initProducerIdV5 from "./init-producer-id.js";
-export * as produceV11 from "./produce.js";
-export * as txnOffsetCommitV4 from "./txn-offset-commit.js";
+export * as addOffsetsToTxnV4 from "./add-offsets-to-txn-v4.js";
+export * as addPartitionsToTxnV5 from "./add-partitions-to-txn-v5.js";
+export * as endTxnV4 from "./end-txn-v4.js";
+export * as initProducerIdV4 from "./init-producer-id-v4.js";
+export * as initProducerIdV5 from "./init-producer-id-v5.js";
+export * as produceV10 from "./produce-v10.js";
+export * as produceV11 from "./produce-v11.js";
+export * as txnOffsetCommitV4 from "./txn-offset-commit-v4.js";

package/dist/apis/producer/init-producer-id-v4.js

@@ -0,0 +1,38 @@
+import { ResponseError } from "../../errors.js";
+import { Writer } from "../../protocol/writer.js";
+import { createAPI } from "../definitions.js";
+/*
+  InitProducerId Request (Version: 4) => transactional_id transaction_timeout_ms producer_id producer_epoch TAG_BUFFER
+    transactional_id => COMPACT_NULLABLE_STRING
+    transaction_timeout_ms => INT32
+    producer_id => INT64
+    producer_epoch => INT16
+*/
+export function createRequest(transactionalId, transactionTimeoutMs, producerId, producerEpoch) {
+    return Writer.create()
+        .appendString(transactionalId, true)
+        .appendInt32(transactionTimeoutMs)
+        .appendInt64(producerId)
+        .appendInt16(producerEpoch)
+        .appendTaggedFields();
+}
+/*
+  InitProducerId Response (Version: 4) => throttle_time_ms error_code producer_id producer_epoch TAG_BUFFER
+    throttle_time_ms => INT32
+    error_code => INT16
+    producer_id => INT64
+    producer_epoch => INT16
+*/
+export function parseResponse(_correlationId, apiKey, apiVersion, reader) {
+    const response = {
+        throttleTimeMs: reader.readInt32(),
+        errorCode: reader.readInt16(),
+        producerId: reader.readInt64(),
+        producerEpoch: reader.readInt16()
+    };
+    if (response.errorCode !== 0) {
+        throw new ResponseError(apiKey, apiVersion, { '': response.errorCode }, response);
+    }
+    return response;
+}
+export const api = createAPI(22, 4, createRequest, parseResponse);

package/dist/apis/producer/init-producer-id-v5.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 type InitProducerIdRequest = Parameters<typeof createRequest>;
+export interface InitProducerIdResponseCoordinator {
+    key: string;
+    nodeId: number;
+    host: string;
+    port: number;
+    errorCode: number;
+    errorMessage: NullableString;
+}
+export interface InitProducerIdResponse {
+    throttleTimeMs: number;
+    errorCode: number;
+    producerId: bigint;
+    producerEpoch: number;
+}
+export declare function createRequest(transactionalId: NullableString, transactionTimeoutMs: number, producerId: bigint, producerEpoch: number): Writer;
+export declare function parseResponse(_correlationId: number, apiKey: number, apiVersion: number, reader: Reader): InitProducerIdResponse;
+export declare const api: import("../definitions.ts").API<[transactionalId: NullableString, transactionTimeoutMs: number, producerId: bigint, producerEpoch: number], InitProducerIdResponse>;

package/dist/apis/producer/produce-v10.js

@@ -0,0 +1,104 @@
+import { ResponseError } from "../../errors.js";
+import { createRecordsBatch } from "../../protocol/records.js";
+import { Writer } from "../../protocol/writer.js";
+import { groupByProperty } from "../../utils.js";
+import { createAPI } from "../definitions.js";
+import { ProduceAcks } from "../enumerations.js";
+/*
+  Produce Request (Version: 10) => transactional_id acks timeout_ms [topic_data] TAG_BUFFER
+    transactional_id => COMPACT_NULLABLE_STRING
+    acks => INT16
+    timeout_ms => INT32
+    topic_data => name [partition_data] TAG_BUFFER
+      name => COMPACT_STRING
+      partition_data => index records TAG_BUFFER
+        index => INT32
+        records => COMPACT_RECORDS
+*/
+export function createRequest(acks = 1, timeout = 0, topicData, options = {}) {
+    // Normalize the messages
+    const now = BigInt(Date.now());
+    for (const message of topicData) {
+        if (typeof message.partition === 'undefined') {
+            message.partition = 0;
+        }
+        if (typeof message.timestamp === 'undefined') {
+            message.timestamp = now;
+        }
+    }
+    const writer = Writer.create()
+        .appendString(options.transactionalId)
+        .appendInt16(acks)
+        .appendInt32(timeout)
+        .appendArray(groupByProperty(topicData, 'topic'), (w, [topic, messages]) => {
+        w.appendString(topic).appendArray(groupByProperty(messages, 'partition'), (w, [partition, messages]) => {
+            const records = createRecordsBatch(messages, options);
+            w.appendInt32(partition)
+                .appendUnsignedVarInt(records.length + 1)
+                .appendFrom(records);
+        });
+    })
+        .appendTaggedFields();
+    if (acks === ProduceAcks.NO_RESPONSE) {
+        writer.context.noResponse = true;
+    }
+    return writer;
+}
+/*
+  Produce Response (Version: 10) => [responses] throttle_time_ms TAG_BUFFER
+    responses => name [partition_responses] TAG_BUFFER
+      name => COMPACT_STRING
+      partition_responses => index error_code base_offset log_append_time_ms log_start_offset [record_errors] error_message TAG_BUFFER
+        index => INT32
+        error_code => INT16
+        base_offset => INT64
+        log_append_time_ms => INT64
+        log_start_offset => INT64
+        record_errors => batch_index batch_index_error_message TAG_BUFFER
+          batch_index => INT32
+          batch_index_error_message => COMPACT_NULLABLE_STRING
+        error_message => COMPACT_NULLABLE_STRING
+    throttle_time_ms => INT32
+*/
+export function parseResponse(_correlationId, apiKey, apiVersion, reader) {
+    const errors = [];
+    const response = {
+        responses: reader.readArray((r, i) => {
+            const topicResponse = {
+                name: r.readString(),
+                partitionResponses: r.readArray((r, j) => {
+                    const index = r.readInt32();
+                    const errorCode = r.readInt16();
+                    if (errorCode !== 0) {
+                        errors.push([`/responses/${i}/partition_responses/${j}`, errorCode]);
+                    }
+                    return {
+                        index,
+                        errorCode,
+                        baseOffset: r.readInt64(),
+                        logAppendTimeMs: r.readInt64(),
+                        logStartOffset: r.readInt64(),
+                        recordErrors: r.readArray((r, k) => {
+                            const recordError = {
+                                batchIndex: r.readInt32(),
+                                batchIndexErrorMessage: r.readNullableString()
+                            };
+                            if (recordError.batchIndexErrorMessage) {
+                                errors.push([`/responses/${i}/partition_responses/${j}/record_errors/${k}`, -1]);
+                            }
+                            return recordError;
+                        }),
+                        errorMessage: r.readNullableString()
+                    };
+                })
+            };
+            return topicResponse;
+        }),
+        throttleTimeMs: reader.readInt32()
+    };
+    if (errors.length) {
+        throw new ResponseError(apiKey, apiVersion, Object.fromEntries(errors), response);
+    }
+    return response;
+}
+export const api = createAPI(0, 10, createRequest, parseResponse);

package/dist/apis/producer/produce-v11.d.ts

@@ -0,0 +1,29 @@
+import { type NullableString } from '../../protocol/definitions.ts';
+import { type Reader } from '../../protocol/reader.ts';
+import { type CreateRecordsBatchOptions, type MessageRecord } from '../../protocol/records.ts';
+import { Writer } from '../../protocol/writer.ts';
+export type ProduceRequest = Parameters<typeof createRequest>;
+export interface ProduceResponsePartitionRecordError {
+    batchIndex: number;
+    batchIndexErrorMessage: NullableString;
+}
+export interface ProduceResponsePartition {
+    index: number;
+    errorCode: number;
+    baseOffset: bigint;
+    logAppendTimeMs: bigint;
+    logStartOffset: bigint;
+    recordErrors: ProduceResponsePartitionRecordError[];
+    errorMessage: NullableString;
+}
+export interface ProduceResponseTopic {
+    name: string;
+    partitionResponses: ProduceResponsePartition[];
+}
+export interface ProduceResponse {
+    responses: ProduceResponseTopic[];
+    throttleTimeMs: number;
+}
+export declare function createRequest(acks: number | undefined, timeout: number | undefined, topicData: MessageRecord[], options?: Partial<CreateRecordsBatchOptions>): Writer;
+export declare function parseResponse(_correlationId: number, apiKey: number, apiVersion: number, reader: Reader): ProduceResponse;
+export declare const api: import("../definitions.ts").API<[acks: number | undefined, timeout: number | undefined, topicData: MessageRecord[], options?: Partial<CreateRecordsBatchOptions> | undefined], boolean | ProduceResponse>;

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

@@ -1,2 +1,2 @@
-export * as saslAuthenticateV2 from './sasl-authenticate.ts';
-export * as saslHandshakeV1 from './sasl-handshake.ts';
+export * as saslAuthenticateV2 from './sasl-authenticate-v2.ts';
+export * as saslHandshakeV1 from './sasl-handshake-v1.ts';

package/dist/apis/security/index.js

@@ -1,2 +1,2 @@
-export * as saslAuthenticateV2 from "./sasl-authenticate.js";
-export * as saslHandshakeV1 from "./sasl-handshake.js";
+export * as saslAuthenticateV2 from "./sasl-authenticate-v2.js";
+export * as saslHandshakeV1 from "./sasl-handshake-v1.js";

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

@@ -1,3 +1,3 @@
-export * as getTelemetrySubscriptionsV0 from './get-telemetry-subscriptions.ts';
-export * as listClientMetricsResourcesV0 from './list-client-metrics-resources.ts';
-export * as pushTelemetryV0 from './push-telemetry.ts';
+export * as getTelemetrySubscriptionsV0 from './get-telemetry-subscriptions-v0.ts';
+export * as listClientMetricsResourcesV0 from './list-client-metrics-resources-v0.ts';
+export * as pushTelemetryV0 from './push-telemetry-v0.ts';

package/dist/apis/telemetry/index.js

@@ -1,3 +1,3 @@
-export * as getTelemetrySubscriptionsV0 from "./get-telemetry-subscriptions.js";
-export * as listClientMetricsResourcesV0 from "./list-client-metrics-resources.js";
-export * as pushTelemetryV0 from "./push-telemetry.js";
+export * as getTelemetrySubscriptionsV0 from "./get-telemetry-subscriptions-v0.js";
+export * as listClientMetricsResourcesV0 from "./list-client-metrics-resources-v0.js";
+export * as pushTelemetryV0 from "./push-telemetry-v0.js";

package/dist/clients/admin/admin.js

@@ -1,13 +1,7 @@
-import { api as createTopicsV7 } from "../../apis/admin/create-topics.js";
-import { api as deleteGroupsV2 } from "../../apis/admin/delete-groups.js";
-import { api as deleteTopicsV6 } from "../../apis/admin/delete-topics.js";
-import { api as describeGroupsV5 } from "../../apis/admin/describe-groups.js";
-import { api as listGroupsV5 } from "../../apis/admin/list-groups.js";
 import { FindCoordinatorKeyTypes } from "../../apis/enumerations.js";
-import { api as findCoordinatorV6 } from "../../apis/metadata/find-coordinator.js";
 import { adminGroupsChannel, adminTopicsChannel, createDiagnosticContext } from "../../diagnostic.js";
 import { Reader } from "../../protocol/reader.js";
-import { Base, kAfterCreate, kBootstrapBrokers, kCheckNotClosed, kConnections, kMetadata, kOptions, kPerformDeduplicated, kPerformWithRetry, kValidateOptions } from "../base/base.js";
+import { Base, kAfterCreate, kBootstrapBrokers, kCheckNotClosed, kConnections, kGetApi, kMetadata, kOptions, kPerformDeduplicated, kPerformWithRetry, kValidateOptions } from "../base/base.js";
 import { createPromisifiedCallback, kCallbackPromise, runConcurrentCallbacks } from "../callbacks.js";
 import { createTopicsOptionsValidator, deleteGroupsOptionsValidator, deleteTopicsOptionsValidator, describeGroupsOptionsValidator, listGroupsOptionsValidator } from "./options.js";
 export class Admin extends Base {
@@ -118,7 +112,13 @@ export class Admin extends Base {
                         retryCallback(error, undefined);
                         return;
                     }
-                    createTopicsV7(connection, requests, this[kOptions].timeout, false, retryCallback);
+                    this[kGetApi]('CreateTopics', (error, api) => {
+                        if (error) {
+                            retryCallback(error, undefined);
+                            return;
+                        }
+                        api(connection, requests, this[kOptions].timeout, false, retryCallback);
+                    });
                 });
             }, (error, response) => {
                 if (error) {
@@ -149,7 +149,13 @@ export class Admin extends Base {
                     for (const topic of options.topics) {
                         requests.push({ name: topic });
                     }
-                    deleteTopicsV6(connection, requests, this[kOptions].timeout, retryCallback);
+                    this[kGetApi]('DeleteTopics', (error, api) => {
+                        if (error) {
+                            retryCallback(error, undefined);
+                            return;
+                        }
+                        api(connection, requests, this[kOptions].timeout, retryCallback);
+                    });
                 });
             }, deduplicateCallback, 0);
         }, error => callback(error));
@@ -168,7 +174,19 @@ export class Admin extends Base {
                         return;
                     }
                     this[kPerformWithRetry]('listGroups', retryCallback => {
-                        listGroupsV5(connection, options.states ?? [], options.types, retryCallback);
+                        this[kGetApi]('ListGroups', (error, api) => {
+                            if (error) {
+                                retryCallback(error, undefined);
+                                return;
+                            }
+                            /* c8 ignore next 5 */
+                            if (api.version === 4) {
+                                api(connection, options.states ?? [], retryCallback);
+                            }
+                            else {
+                                api(connection, options.states ?? [], options.types, retryCallback);
+                            }
+                        });
                     }, concurrentCallback, 0);
                 });
             }, (error, results) => {
@@ -219,7 +237,13 @@ export class Admin extends Base {
                             return;
                         }
                         this[kPerformWithRetry]('describeGroups', retryCallback => {
-                            describeGroupsV5(connection, groups, options.includeAuthorizedOperations ?? false, retryCallback);
+                            this[kGetApi]('DescribeGroups', (error, api) => {
+                                if (error) {
+                                    retryCallback(error, undefined);
+                                    return;
+                                }
+                                api(connection, groups, options.includeAuthorizedOperations ?? false, retryCallback);
+                            });
                         }, concurrentCallback, 0);
                     });
                 }, (error, results) => {
@@ -295,7 +319,13 @@ export class Admin extends Base {
                             return;
                         }
                         this[kPerformWithRetry]('deleteGroups', retryCallback => {
-                            deleteGroupsV2(connection, groups, retryCallback);
+                            this[kGetApi]('DeleteGroups', (error, api) => {
+                                if (error) {
+                                    retryCallback(error, undefined);
+                                    return;
+                                }
+                                api(connection, groups, retryCallback);
+                            });
                         }, concurrentCallback, 0);
                     });
                 }, error => callback(error));
@@ -309,7 +339,13 @@ export class Admin extends Base {
                     retryCallback(error, undefined);
                     return;
                 }
-                findCoordinatorV6(connection, FindCoordinatorKeyTypes.GROUP, groups, retryCallback);
+                this[kGetApi]('FindCoordinator', (error, api) => {
+                    if (error) {
+                        retryCallback(error, undefined);
+                        return;
+                    }
+                    api(connection, FindCoordinatorKeyTypes.GROUP, groups, retryCallback);
+                });
             });
         }, (error, response) => {
             if (error) {

package/dist/clients/base/base.d.ts

@@ -1,6 +1,7 @@
 import { type ValidateFunction } from 'ajv';
 import { EventEmitter } from 'node:events';
-import { type Callback } from '../../apis/definitions.ts';
+import { type API, type Callback } from '../../apis/definitions.ts';
+import { type ApiVersionsResponseApi } from '../../apis/metadata/api-versions-v3.ts';
 import { type ClientType } from '../../diagnostic.ts';
 import { ConnectionPool } from '../../network/connection-pool.ts';
 import { type Broker } from '../../network/connection.ts';
@@ -10,11 +11,14 @@ import { type Metrics } from '../metrics.ts';
 import { type BaseOptions, type ClusterMetadata, type MetadataOptions } from './types.ts';
 export declare const kClientId: unique symbol;
 export declare const kBootstrapBrokers: unique symbol;
+export declare const kApis: unique symbol;
+export declare const kGetApi: unique symbol;
 export declare const kOptions: unique symbol;
 export declare const kConnections: unique symbol;
 export declare const kFetchConnections: unique symbol;
 export declare const kCreateConnectionPool: unique symbol;
 export declare const kClosed: unique symbol;
+export declare const kListApis: unique symbol;
 export declare const kMetadata: unique symbol;
 export declare const kCheckNotClosed: unique symbol;
 export declare const kClearMetadata: unique symbol;
@@ -33,6 +37,7 @@ export declare class Base<OptionsType extends BaseOptions = BaseOptions> extends
     [kClientId]: string;
     [kClientType]: ClientType;
     [kBootstrapBrokers]: Broker[];
+    [kApis]: ApiVersionsResponseApi[];
     [kOptions]: OptionsType;
     [kConnections]: ConnectionPool;
     [kClosed]: boolean;
@@ -45,15 +50,19 @@ export declare class Base<OptionsType extends BaseOptions = BaseOptions> extends
     emitWithDebug(section: string | null, name: string, ...args: any[]): boolean;
     close(callback: CallbackWithPromise<void>): void;
     close(): Promise<void>;
+    listApis(callback: CallbackWithPromise<ApiVersionsResponseApi[]>): void;
+    listApis(): Promise<ApiVersionsResponseApi[]>;
     metadata(options: MetadataOptions, callback: CallbackWithPromise<ClusterMetadata>): void;
     metadata(options: MetadataOptions): Promise<ClusterMetadata>;
     [kCreateConnectionPool](): ConnectionPool;
+    [kListApis](callback: CallbackWithPromise<ApiVersionsResponseApi[]>): void;
     [kMetadata](options: MetadataOptions, callback: CallbackWithPromise<ClusterMetadata>): void;
     [kCheckNotClosed](callback: CallbackWithPromise<any>): boolean;
     [kClearMetadata](): void;
     [kParseBroker](broker: Broker | string): Broker;
     [kPerformWithRetry]<ReturnType>(operationId: string, operation: (callback: Callback<ReturnType>) => void, callback: CallbackWithPromise<ReturnType>, attempt?: number, errors?: Error[], shouldSkipRetry?: (e: Error) => boolean): void | Promise<ReturnType>;
     [kPerformDeduplicated]<ReturnType>(operationId: string, operation: (callback: CallbackWithPromise<ReturnType>) => void, callback: CallbackWithPromise<ReturnType>): void | Promise<ReturnType>;
+    [kGetApi]<RequestArguments extends Array<unknown>, ResponseType>(name: string, callback: Callback<API<RequestArguments, ResponseType>>): void;
     [kValidateOptions](target: unknown, validator: ValidateFunction<unknown>, targetName: string, throwOnErrors?: boolean): Error | null;
     [kInspect](...args: unknown[]): void;
     [kFormatValidationErrors](validator: ValidateFunction<unknown>, targetName: string): string;