@platformatic/kafka 1.22.0-alpha.2 → 1.23.0-alpha.1

package/dist/apis/callbacks.js

@@ -1,5 +1,5 @@
 import { MultipleErrors, TimeoutError } from "../errors.js";
-import { PromiseWithResolvers } from "../utils.js";
+import { promiseWithResolvers } from "../utils.js";
 export const kCallbackPromise = Symbol('plt.kafka.callbackPromise');
 // This is only meaningful for testing
 export const kNoopCallbackReturnValue = Symbol('plt.kafka.noopCallbackReturnValue');
@@ -7,7 +7,7 @@ export const noopCallback = () => {
     return Promise.resolve(kNoopCallbackReturnValue);
 };
 export function createPromisifiedCallback() {
-    const { promise, resolve, reject } = PromiseWithResolvers();
+    const { promise, resolve, reject } = promiseWithResolvers();
     function callback(error, payload) {
         if (error) {
             reject(error);

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

@@ -121,6 +121,21 @@ export declare const baseOptionsSchema: {
                         type?: undefined;
                     })[];
                 };
+                oauthBearerExtensions: {
+                    oneOf: ({
+                        type: string;
+                        patternProperties: {
+                            '.+': {
+                                type: string;
+                            };
+                        };
+                        function?: undefined;
+                    } | {
+                        function: boolean;
+                        type?: undefined;
+                        patternProperties?: undefined;
+                    })[];
+                };
                 authBytesValidator: {
                     function: boolean;
                 };

package/dist/clients/base/options.js

@@ -41,6 +41,9 @@ export const baseOptionsSchema = {
                 username: { oneOf: [{ type: 'string' }, { function: true }] },
                 password: { oneOf: [{ type: 'string' }, { function: true }] },
                 token: { oneOf: [{ type: 'string' }, { function: true }] },
+                oauthBearerExtensions: {
+                    oneOf: [{ type: 'object', patternProperties: { '.+': { type: 'string' } } }, { function: true }]
+                },
                 authBytesValidator: { function: true },
                 authenticate: { function: true }
             },

package/dist/network/connection.d.ts

@@ -6,7 +6,7 @@ import { type Callback, type ResponseParser } from '../apis/definitions.ts';
 import { type SASLMechanismValue } from '../apis/enumerations.ts';
 import { type SaslAuthenticateResponse, type SASLAuthenticationAPI } from '../apis/security/sasl-authenticate-v2.ts';
 import { Writer } from '../protocol/writer.ts';
-export type SASLCredentialProvider = () => string | Promise<string>;
+export type SASLCredentialProvider<T = string> = () => T | Promise<T>;
 export interface Broker {
     host: string;
     port: number;
@@ -17,8 +17,9 @@ export interface SASLOptions {
     username?: string | SASLCredentialProvider;
     password?: string | SASLCredentialProvider;
     token?: string | SASLCredentialProvider;
-    authBytesValidator?: (authBytes: Buffer, callback: CallbackWithPromise<Buffer>) => void;
+    oauthBearerExtensions?: Record<string, string> | SASLCredentialProvider<Record<string, string>>;
     authenticate?: SASLCustomAuthenticator;
+    authBytesValidator?: (authBytes: Buffer, callback: CallbackWithPromise<Buffer>) => void;
 }
 export interface ConnectionOptions {
     connectTimeout?: number;

package/dist/network/connection.js

@@ -68,9 +68,11 @@ export class Connection extends EventEmitter {
         this.#socketMustBeDrained = false;
         notifyCreation('connection', this);
     }
+    /* c8 ignore next 3 - Simple getter */
     get host() {
         return this.#status === ConnectionStatuses.CONNECTING || ConnectionStatuses.CONNECTED ? this.#host : undefined;
     }
+    /* c8 ignore next 3 - Simple getter */
     get port() {
         return this.#status === ConnectionStatuses.CONNECTING || ConnectionStatuses.CONNECTED ? this.#port : undefined;
     }
@@ -257,7 +259,7 @@ export class Connection extends EventEmitter {
         if (this.#status === ConnectionStatuses.CONNECTING) {
             this.#status = ConnectionStatuses.AUTHENTICATING;
         }
-        const { mechanism, username, password, token, authenticate } = this.#options.sasl;
+        const { mechanism, username, password, token, oauthBearerExtensions, authenticate } = this.#options.sasl;
         if (!allowedSASLMechanisms.includes(mechanism)) {
             this.#onConnectionError(host, port, diagnosticContext, new UserError(`SASL mechanism ${mechanism} not supported.`));
             return;
@@ -276,7 +278,7 @@ export class Connection extends EventEmitter {
                 saslPlain.authenticate(saslAuthenticateV2.api, this, username, password, callback);
             }
             else if (mechanism === SASLMechanisms.OAUTHBEARER) {
-                saslOAuthBearer.authenticate(saslAuthenticateV2.api, this, token, callback);
+                saslOAuthBearer.authenticate(saslAuthenticateV2.api, this, token, oauthBearerExtensions, callback);
             }
             else if (mechanism === SASLMechanisms.GSSAPI) {
                 callback(new UserError('No custom SASL/GSSAPI authenticator provided.'), undefined);

package/dist/protocol/sasl/oauth-bearer.d.ts

@@ -2,5 +2,5 @@ import { type CallbackWithPromise } from '../../apis/callbacks.ts';
 import { type SASLAuthenticationAPI, type SaslAuthenticateResponse } from '../../apis/security/sasl-authenticate-v2.ts';
 import { type Connection, type SASLCredentialProvider } from '../../network/connection.ts';
 export declare function jwtValidateAuthenticationBytes(authBytes: Buffer, callback: CallbackWithPromise<Buffer>): void;
-export declare function authenticate(authenticateAPI: SASLAuthenticationAPI, connection: Connection, tokenOrProvider: string | SASLCredentialProvider, callback: CallbackWithPromise<SaslAuthenticateResponse>): void;
-export declare function authenticate(authenticateAPI: SASLAuthenticationAPI, connection: Connection, tokenOrProvider: string | SASLCredentialProvider): Promise<SaslAuthenticateResponse>;
+export declare function authenticate(authenticateAPI: SASLAuthenticationAPI, connection: Connection, tokenOrProvider: string | SASLCredentialProvider, extensions: Record<string, string> | SASLCredentialProvider<Record<string, string>>, callback: CallbackWithPromise<SaslAuthenticateResponse>): void;
+export declare function authenticate(authenticateAPI: SASLAuthenticationAPI, connection: Connection, tokenOrProvider: string | SASLCredentialProvider, extensions: Record<string, string> | SASLCredentialProvider<Record<string, string>>): Promise<SaslAuthenticateResponse>;

package/dist/protocol/sasl/oauth-bearer.js

@@ -18,7 +18,7 @@ export function jwtValidateAuthenticationBytes(authBytes, callback) {
     }
     callback(null, authBytes);
 }
-export function authenticate(authenticateAPI, connection, tokenOrProvider, callback) {
+export function authenticate(authenticateAPI, connection, tokenOrProvider, extensionsOrProvider, callback) {
     if (!callback) {
         callback = createPromisifiedCallback();
     }
@@ -27,7 +27,18 @@ export function authenticate(authenticateAPI, connection, tokenOrProvider, callb
             callback(error, undefined);
             return;
         }
-        authenticateAPI(connection, Buffer.from(`n,,\x01auth=Bearer ${token}\x01\x01`), callback);
+        getCredential('SASL/OAUTHBEARER extensions', extensionsOrProvider ?? {}, (error, extensionsMap) => {
+            if (error) {
+                return callback(error, undefined);
+            }
+            let extensions = '';
+            if (extensionsMap) {
+                for (const [key, value] of Object.entries(extensionsMap)) {
+                    extensions += `\x01${key}=${value}`;
+                }
+            }
+            authenticateAPI(connection, Buffer.from(`n,,\x01auth=Bearer ${token}${extensions}\x01\x01`), callback);
+        });
     });
     return callback[kCallbackPromise];
 }

package/dist/protocol/sasl/utils.d.ts

@@ -1,4 +1,4 @@
 import { type CallbackWithPromise } from '../../apis/index.ts';
 import { type SASLCredentialProvider } from '../../network/connection.ts';
-export declare function getCredential(label: string, credentialOrProvider: string | SASLCredentialProvider, callback: CallbackWithPromise<string>): void;
-export declare function getCredential(label: string, credentialOrProvider: string | SASLCredentialProvider): Promise<string>;
+export declare function getCredential<T>(label: string, credentialOrProvider: T | SASLCredentialProvider<T>, callback: CallbackWithPromise<T>): void;
+export declare function getCredential<T>(label: string, credentialOrProvider: T | SASLCredentialProvider<T>): Promise<T>;

package/dist/protocol/sasl/utils.js

@@ -4,33 +4,34 @@ export function getCredential(label, credentialOrProvider, callback) {
     if (!callback) {
         callback = createPromisifiedCallback();
     }
-    if (typeof credentialOrProvider === 'string') {
-        callback(null, credentialOrProvider);
+    if (typeof credentialOrProvider === 'undefined') {
+        callback(new AuthenticationError(`The ${label} should be a value or a function.`), undefined);
         return callback[kCallbackPromise];
     }
     else if (typeof credentialOrProvider !== 'function') {
-        callback(new AuthenticationError(`The ${label} should be a string or a function.`), undefined);
+        callback(null, credentialOrProvider);
         return callback[kCallbackPromise];
     }
     try {
         const credential = credentialOrProvider();
-        if (typeof credential === 'string') {
-            callback(null, credential);
+        if (credential == null) {
+            callback(new AuthenticationError(`The ${label} provider should return a string or a promise that resolves to a value.`), undefined);
             return callback[kCallbackPromise];
         }
         else if (typeof credential?.then !== 'function') {
-            callback(new AuthenticationError(`The ${label} provider should return a string or a promise that resolves to a string.`), undefined);
+            callback(null, credential);
             return callback[kCallbackPromise];
         }
+        ;
         credential
-            .then(token => {
-            if (typeof token !== 'string') {
-                process.nextTick(callback, new AuthenticationError(`The ${label} provider should resolve to a string.`), undefined);
-                return callback[kCallbackPromise];
+            .then((result) => {
+            if (result == null) {
+                process.nextTick(callback, new AuthenticationError(`The ${label} provider should resolve to a value.`), undefined);
+                return;
             }
-            process.nextTick(callback, null, token);
+            process.nextTick(callback, null, result);
         })
-            .catch(error => {
+            .catch((error) => {
             process.nextTick(callback, new AuthenticationError(`The ${label} provider threw an error.`, { cause: error }));
         });
     }

package/dist/typescript-4/dist/apis/admin/alter-client-quotas-v1.d.ts

@@ -0,0 +1,39 @@
+import { type NullableString } from "../../protocol/definitions";
+import { type Reader } from "../../protocol/reader";
+import { Writer } from "../../protocol/writer";
+import { type ClientQuotaEntityType, type ClientQuotaKey } from "../enumerations";
+export interface AlterClientQuotasRequestEntity {
+  entityType: ClientQuotaEntityType;
+  entityName?: NullableString;
+}
+export interface AlterClientQuotaRequestOpAddition {
+  key: ClientQuotaKey;
+  value: number;
+  remove: false;
+}
+export interface AlterClientQuotaRequestOpRemoval {
+  key: ClientQuotaKey;
+  remove: true;
+}
+export type AlterClientQuotasRequestOp = AlterClientQuotaRequestOpAddition | AlterClientQuotaRequestOpRemoval;
+export interface AlterClientQuotasRequestEntry {
+  entities: AlterClientQuotasRequestEntity[];
+  ops: AlterClientQuotasRequestOp[];
+}
+export type AlterClientQuotasRequest = Parameters<typeof createRequest>;
+export interface AlterClientQuotasResponseEntity {
+  entityType: string;
+  entityName: NullableString;
+}
+export interface AlterClientQuotasResponseEntries {
+  errorCode: number;
+  errorMessage: NullableString;
+  entity: AlterClientQuotasResponseEntity[];
+}
+export interface AlterClientQuotasResponse {
+  throttleTimeMs: number;
+  entries: AlterClientQuotasResponseEntries[];
+}
+export declare function createRequest(entries: AlterClientQuotasRequestEntry[], validateOnly: boolean): Writer;
+export declare function parseResponse(_correlationId: number, apiKey: number, apiVersion: number, reader: Reader): AlterClientQuotasResponse;
+export declare const api: import("../definitions").API<[entries: AlterClientQuotasRequestEntry[], validateOnly: boolean], AlterClientQuotasResponse>;

package/dist/typescript-4/dist/apis/admin/alter-configs-v2.d.ts

@@ -0,0 +1,26 @@
+import { type NullableString } from "../../protocol/definitions";
+import { type Reader } from "../../protocol/reader";
+import { Writer } from "../../protocol/writer";
+export interface AlterConfigsRequestConfig {
+  name: string;
+  value?: NullableString;
+}
+export interface AlterConfigsRequestResource {
+  resourceType: number;
+  resourceName: string;
+  configs: AlterConfigsRequestConfig[];
+}
+export type AlterConfigsRequest = Parameters<typeof createRequest>;
+export interface AlterConfigsResponseResult {
+  errorCode: number;
+  errorMessage: NullableString;
+  resourceType: number;
+  resourceName: string;
+}
+export interface AlterConfigsResponse {
+  throttleTimeMs: number;
+  responses: AlterConfigsResponseResult[];
+}
+export declare function createRequest(resources: AlterConfigsRequestResource[], validateOnly: boolean): Writer;
+export declare function parseResponse(_correlationId: number, apiKey: number, apiVersion: number, reader: Reader): AlterConfigsResponse;
+export declare const api: import("../definitions").API<[resources: AlterConfigsRequestResource[], validateOnly: boolean], AlterConfigsResponse>;

package/dist/typescript-4/dist/apis/admin/alter-partition-reassignments-v0.d.ts

@@ -0,0 +1,30 @@
+import { type NullableString } from "../../protocol/definitions";
+import { type Reader } from "../../protocol/reader";
+import { Writer } from "../../protocol/writer";
+export interface AlterPartitionReassignmentsRequestPartition {
+  partitionIndex: number;
+  replicas: number[];
+}
+export interface AlterPartitionReassignmentsRequestTopic {
+  name: string;
+  partitions: AlterPartitionReassignmentsRequestPartition[];
+}
+export type AlterPartitionReassignmentsRequest = Parameters<typeof createRequest>;
+export interface AlterPartitionReassignmentsResponsePartition {
+  partitionIndex: number;
+  errorCode: number;
+  errorMessage: NullableString;
+}
+export interface AlterPartitionReassignmentsResponseResponse {
+  name: string;
+  partitions: AlterPartitionReassignmentsResponsePartition[];
+}
+export interface AlterPartitionReassignmentsResponse {
+  throttleTimeMs: number;
+  errorCode: number;
+  errorMessage: NullableString;
+  responses: AlterPartitionReassignmentsResponseResponse[];
+}
+export declare function createRequest(timeoutMs: number, topics: AlterPartitionReassignmentsRequestTopic[]): Writer;
+export declare function parseResponse(_correlationId: number, apiKey: number, apiVersion: number, reader: Reader): AlterPartitionReassignmentsResponse;
+export declare const api: import("../definitions").API<[timeoutMs: number, topics: AlterPartitionReassignmentsRequestTopic[]], AlterPartitionReassignmentsResponse>;

package/dist/typescript-4/dist/apis/admin/alter-partition-v3.d.ts

@@ -0,0 +1,39 @@
+import { type Reader } from "../../protocol/reader";
+import { Writer } from "../../protocol/writer";
+export interface AlterPartitionRequestISR {
+  brokerId: number;
+  brokerEpoch: bigint;
+}
+export interface AlterPartitionRequestPartition {
+  partitionIndex: number;
+  leaderEpoch: number;
+  newIsrWithEpochs: AlterPartitionRequestISR[];
+  leaderRecoveryState: number;
+  partitionEpoch: number;
+}
+export interface AlterPartitionRequestTopic {
+  topicId: string;
+  partitions: AlterPartitionRequestPartition[];
+}
+export type AlterPartitionRequest = Parameters<typeof createRequest>;
+export interface AlterPartitionResponsePartition {
+  partitionIndex: number;
+  errorCode: number;
+  leaderId: number;
+  leaderEpoch: number;
+  isr: number;
+  leaderRecoveryState: number;
+  partitionEpoch: number;
+}
+export interface AlterPartitionResponseTopic {
+  topicId: string;
+  partitions: AlterPartitionResponsePartition[];
+}
+export interface AlterPartitionResponse {
+  throttleTimeMs: number;
+  errorCode: number;
+  topics: AlterPartitionResponseTopic[];
+}
+export declare function createRequest(brokerId: number, brokerEpoch: bigint, topic: AlterPartitionRequestTopic[]): Writer;
+export declare function parseResponse(_correlationId: number, apiKey: number, apiVersion: number, reader: Reader): AlterPartitionResponse;
+export declare const api: import("../definitions").API<[brokerId: number, brokerEpoch: bigint, topic: AlterPartitionRequestTopic[]], AlterPartitionResponse>;

package/dist/typescript-4/dist/apis/admin/alter-replica-log-dirs-v2.d.ts

@@ -0,0 +1,26 @@
+import { type Reader } from "../../protocol/reader";
+import { Writer } from "../../protocol/writer";
+export interface AlterReplicaLogDirsRequestTopic {
+  name: string;
+  partitions: number[];
+}
+export interface AlterReplicaLogDirsRequestDir {
+  path: string;
+  topics: AlterReplicaLogDirsRequestTopic[];
+}
+export type AlterReplicaLogDirsRequest = Parameters<typeof createRequest>;
+export interface AlterReplicaLogDirsResponsePartition {
+  partitionIndex: number;
+  errorCode: number;
+}
+export interface AlterReplicaLogDirsResponseResult {
+  topicName: string;
+  partitions: AlterReplicaLogDirsResponsePartition[];
+}
+export interface AlterReplicaLogDirsResponse {
+  throttleTimeMs?: number;
+  results: AlterReplicaLogDirsResponseResult[];
+}
+export declare function createRequest(dirs: AlterReplicaLogDirsRequestDir[]): Writer;
+export declare function parseResponse(_correlationId: number, apiKey: number, apiVersion: number, reader: Reader): AlterReplicaLogDirsResponse;
+export declare const api: import("../definitions").API<[dirs: AlterReplicaLogDirsRequestDir[]], AlterReplicaLogDirsResponse>;

package/dist/typescript-4/dist/apis/admin/alter-user-scram-credentials-v0.d.ts

@@ -0,0 +1,27 @@
+import { type NullableString } from "../../protocol/definitions";
+import { type Reader } from "../../protocol/reader";
+import { Writer } from "../../protocol/writer";
+export interface AlterUserScramCredentialsRequestDeletions {
+  name: string;
+  mechanism: number;
+}
+export interface AlterUserScramCredentialsRequestUpsertions {
+  name: string;
+  mechanism: number;
+  iterations: number;
+  salt: Buffer;
+  saltedPassword: Buffer;
+}
+export type AlterUserScramCredentialsRequest = Parameters<typeof createRequest>;
+export interface AlterUserScramCredentialsResponseResult {
+  user: string;
+  errorCode: number;
+  errorMessage: NullableString;
+}
+export interface AlterUserScramCredentialsResponse {
+  throttleTimeMs: number;
+  results: AlterUserScramCredentialsResponseResult[];
+}
+export declare function createRequest(deletions: AlterUserScramCredentialsRequestDeletions[], upsertions: AlterUserScramCredentialsRequestUpsertions[]): Writer;
+export declare function parseResponse(_correlationId: number, apiKey: number, apiVersion: number, reader: Reader): AlterUserScramCredentialsResponse;
+export declare const api: import("../definitions").API<[deletions: AlterUserScramCredentialsRequestDeletions[], upsertions: AlterUserScramCredentialsRequestUpsertions[]], AlterUserScramCredentialsResponse>;

package/dist/typescript-4/dist/apis/admin/consumer-group-describe-v0.d.ts

@@ -0,0 +1,41 @@
+import { type NullableString } from "../../protocol/definitions";
+import { type Reader } from "../../protocol/reader";
+import { Writer } from "../../protocol/writer";
+export type ConsumerGroupDescribeRequest = Parameters<typeof createRequest>;
+export interface ConsumerGroupDescribeResponseMemberTopic {
+  topicId: string;
+  topicName: string;
+  partitions: number[];
+}
+export interface ConsumerGroupDescribeResponseMemberAssignment {
+  topicPartitions: ConsumerGroupDescribeResponseMemberTopic[];
+}
+export interface ConsumerGroupDescribeResponseMember {
+  memberId: string;
+  instanceId: NullableString;
+  rackId: NullableString;
+  memberEpoch: number;
+  clientId: string;
+  clientHost: string;
+  subscribedTopicNames: string;
+  subscribedTopicRegex: NullableString;
+  assignment: ConsumerGroupDescribeResponseMemberAssignment;
+  targetAssignment: ConsumerGroupDescribeResponseMemberAssignment;
+}
+export interface ConsumerGroupDescribeResponseGroup {
+  errorCode: number;
+  errorMessage: NullableString;
+  groupId: string;
+  groupState: string;
+  groupEpoch: number;
+  assignmentEpoch: number;
+  assignorName: string;
+  members: ConsumerGroupDescribeResponseMember[];
+}
+export interface ConsumerGroupDescribeResponse {
+  throttleTimeMs: number;
+  groups: ConsumerGroupDescribeResponseGroup[];
+}
+export declare function createRequest(groupIds: string[], includeAuthorizedOperations: boolean): Writer;
+export declare function parseResponse(_correlationId: number, apiKey: number, apiVersion: number, reader: Reader): ConsumerGroupDescribeResponse;
+export declare const api: import("../definitions").API<[groupIds: string[], includeAuthorizedOperations: boolean], ConsumerGroupDescribeResponse>;

package/dist/typescript-4/dist/apis/admin/create-acls-v3.d.ts

@@ -0,0 +1,24 @@
+import { type NullableString } from "../../protocol/definitions";
+import { type Reader } from "../../protocol/reader";
+import { Writer } from "../../protocol/writer";
+export interface CreateAclsRequestCreation {
+  resourceType: number;
+  resourceName: string;
+  resourcePatternType: number;
+  principal: string;
+  host: string;
+  operation: number;
+  permissionType: number;
+}
+export type CreateAclsRequest = Parameters<typeof createRequest>;
+export interface CreateAclsResponseResult {
+  errorCode: number;
+  errorMessage: NullableString;
+}
+export interface CreateAclsResponse {
+  throttleTimeMs: number;
+  results: CreateAclsResponseResult[];
+}
+export declare function createRequest(creations: CreateAclsRequestCreation[]): Writer;
+export declare function parseResponse(_correlationId: number, apiKey: number, apiVersion: number, reader: Reader): CreateAclsResponse;
+export declare const api: import("../definitions").API<[creations: CreateAclsRequestCreation[]], CreateAclsResponse>;

package/dist/typescript-4/dist/apis/admin/create-delegation-token-v3.d.ts

@@ -0,0 +1,24 @@
+import { type NullableString } from "../../protocol/definitions";
+import { type Reader } from "../../protocol/reader";
+import { Writer } from "../../protocol/writer";
+export interface CreateDelegationTokenRequestRenewer {
+  principalType: string;
+  principalName: string;
+}
+export type CreateDelegationTokenRequest = Parameters<typeof createRequest>;
+export interface CreateDelegationTokenResponse {
+  errorCode: number;
+  principalType: string;
+  principalName: string;
+  tokenRequesterPrincipalType: string;
+  tokenRequesterPrincipalName: string;
+  issueTimestampMs: bigint;
+  expiryTimestampMs: bigint;
+  maxTimestampMs: bigint;
+  tokenId: string;
+  hmac: Buffer;
+  throttleTimeMs: number;
+}
+export declare function createRequest(ownerPrincipalType: NullableString, ownerPrincipalName: NullableString, renewers: CreateDelegationTokenRequestRenewer[], maxLifetimeMs: bigint): Writer;
+export declare function parseResponse(_correlationId: number, apiKey: number, apiVersion: number, reader: Reader): CreateDelegationTokenResponse;
+export declare const api: import("../definitions").API<[ownerPrincipalType: NullableString, ownerPrincipalName: NullableString, renewers: CreateDelegationTokenRequestRenewer[], maxLifetimeMs: bigint], CreateDelegationTokenResponse>;

package/dist/typescript-4/dist/apis/admin/create-partitions-v1.d.ts

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

package/dist/typescript-4/dist/apis/admin/create-partitions-v2.d.ts

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

package/dist/typescript-4/dist/apis/admin/create-partitions-v3.d.ts

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

package/dist/typescript-4/dist/apis/admin/create-topics-v7.d.ts

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

package/dist/typescript-4/dist/apis/admin/delete-acls-v3.d.ts

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