@platformatic/kafka 2.10.0 → 2.12.0

package/dist/apis/security/sasl-handshake-v0.js

@@ -0,0 +1,28 @@
+import { ResponseError } from "../../errors.js";
+import { Writer } from "../../protocol/writer.js";
+import { createAPI } from "../definitions.js";
+/*
+  SaslHandshake Request (Version: 0) => mechanism
+    mechanism => STRING
+*/
+export function createRequest(mechanism) {
+    return Writer.create().appendString(mechanism, false);
+}
+/*
+  SaslHandshake Response (Version: 0) => error_code [mechanisms]
+    error_code => INT16
+    mechanisms => STRING
+*/
+export function parseResponse(_correlationId, apiKey, apiVersion, reader) {
+    const response = {
+        errorCode: reader.readInt16(),
+        mechanisms: reader.readArray(r => {
+            return r.readString(false);
+        }, false, false)
+    };
+    if (response.errorCode !== 0) {
+        throw new ResponseError(apiKey, apiVersion, { '/': [response.errorCode, null] }, response);
+    }
+    return response;
+}
+export const api = createAPI(17, 0, createRequest, parseResponse, false, false);

package/dist/apis/tagged-fields.d.ts

@@ -0,0 +1,7 @@
+import { Reader } from '../protocol/reader.ts';
+export type TaggedFieldHandler = (reader: Reader) => void;
+export type TaggedFieldHandlers = Readonly<Record<number, TaggedFieldHandler>>;
+/**
+ * Decodes known flexible-version tagged fields and skips fields the caller does not handle.
+ */
+export declare function readKnownTaggedFields(reader: Reader, handlers: TaggedFieldHandlers): void;

package/dist/apis/tagged-fields.js

@@ -0,0 +1,27 @@
+import { Reader } from "../protocol/reader.js";
+/**
+ * Decodes known flexible-version tagged fields and skips fields the caller does not handle.
+ */
+export function readKnownTaggedFields(reader, handlers) {
+    const count = reader.readUnsignedVarInt();
+    for (let index = 0; index < count; index++) {
+        const tag = reader.readUnsignedVarInt();
+        const size = reader.readUnsignedVarInt();
+        if (size > reader.remaining) {
+            throw new RangeError(`Tagged field ${tag} declares ${size} bytes but only ${reader.remaining} remain`);
+        }
+        const handler = handlers[tag];
+        if (handler) {
+            const payload = Reader.from(reader.buffer.slice(reader.position, reader.position + size));
+            try {
+                handler(payload);
+            }
+            finally {
+                reader.skip(size);
+            }
+        }
+        else {
+            reader.skip(size);
+        }
+    }
+}

package/dist/apis/telemetry/compression-types.d.ts

@@ -0,0 +1,8 @@
+export declare const TelemetryCompressionTypes: {
+    readonly NONE: 0;
+    readonly GZIP: 1;
+    readonly SNAPPY: 2;
+    readonly LZ4: 3;
+    readonly ZSTD: 4;
+};
+export type TelemetryCompressionType = (typeof TelemetryCompressionTypes)[keyof typeof TelemetryCompressionTypes];

package/dist/apis/telemetry/compression-types.js

@@ -0,0 +1,7 @@
+export const TelemetryCompressionTypes = {
+    NONE: 0,
+    GZIP: 1,
+    SNAPPY: 2,
+    LZ4: 3,
+    ZSTD: 4
+};

package/dist/apis/telemetry/get-telemetry-subscriptions-v0.d.ts

@@ -1,13 +1,14 @@
 import { type NullableString } from '../../protocol/definitions.ts';
 import { type Reader } from '../../protocol/reader.ts';
 import { Writer } from '../../protocol/writer.ts';
+import { type TelemetryCompressionType } from './compression-types.ts';
 export type GetTelemetrySubscriptionsRequest = Parameters<typeof createRequest>;
 export interface GetTelemetrySubscriptionsResponse {
     throttleTimeMs: number;
     errorCode: number;
     clientInstanceId: string;
     subscriptionId: number;
-    acceptedCompressionTypes: number[];
+    acceptedCompressionTypes: TelemetryCompressionType[];
     pushIntervalMs: number;
     telemetryMaxBytes: number;
     deltaTemporality: boolean;

package/dist/apis/telemetry/get-telemetry-subscriptions-v0.js

@@ -38,6 +38,7 @@ export function parseResponse(_correlationId, apiKey, apiVersion, reader) {
         deltaTemporality: reader.readBoolean(),
         requestedMetrics: reader.readArray(r => r.readString(), true, false)
     };
+    reader.readTaggedFields();
     if (errors.length) {
         throw new ResponseError(apiKey, apiVersion, Object.fromEntries(errors), response);
     }

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

@@ -1,3 +1,6 @@
+export { TelemetryCompressionTypes, type TelemetryCompressionType } from './compression-types.ts';
 export * as getTelemetrySubscriptionsV0 from './get-telemetry-subscriptions-v0.ts';
 export * as listClientMetricsResourcesV0 from './list-client-metrics-resources-v0.ts';
+export * as listConfigResourcesV1 from './list-config-resources-v1.ts';
+export * as listClientMetricsResourcesV1 from './list-config-resources-v1.ts';
 export * as pushTelemetryV0 from './push-telemetry-v0.ts';

package/dist/apis/telemetry/index.js

@@ -1,3 +1,6 @@
+export { TelemetryCompressionTypes } from "./compression-types.js";
 export * as getTelemetrySubscriptionsV0 from "./get-telemetry-subscriptions-v0.js";
 export * as listClientMetricsResourcesV0 from "./list-client-metrics-resources-v0.js";
+export * as listConfigResourcesV1 from "./list-config-resources-v1.js";
+export * as listClientMetricsResourcesV1 from "./list-config-resources-v1.js";
 export * as pushTelemetryV0 from "./push-telemetry-v0.js";

package/dist/apis/telemetry/list-client-metrics-resources-v0.d.ts

@@ -1,14 +1,16 @@
 import { type Reader } from '../../protocol/reader.ts';
 import { Writer } from '../../protocol/writer.ts';
+import { type ConfigResourceTypeValue } from '../enumerations.ts';
 export type ListClientMetricsResourcesRequest = Parameters<typeof createRequest>;
 export interface ListClientMetricsResourcesResource {
-    name: string;
+    resourceName: string;
+    resourceType: ConfigResourceTypeValue;
 }
 export interface ListClientMetricsResourcesResponse {
     throttleTimeMs: number;
     errorCode: number;
-    clientMetricsResources: ListClientMetricsResourcesResource[];
+    configResources: ListClientMetricsResourcesResource[];
 }
-export declare function createRequest(): Writer;
+export declare function createRequest(_resourceTypes?: ConfigResourceTypeValue[]): Writer;
 export declare function parseResponse(_correlationId: number, apiKey: number, apiVersion: number, reader: Reader): ListClientMetricsResourcesResponse;
-export declare const api: import("../definitions.ts").API<[], ListClientMetricsResourcesResponse>;
+export declare const api: import("../definitions.ts").API<[_resourceTypes?: ConfigResourceTypeValue[] | undefined], ListClientMetricsResourcesResponse>;

package/dist/apis/telemetry/list-client-metrics-resources-v0.js

@@ -1,29 +1,34 @@
 import { ResponseError } from "../../errors.js";
 import { Writer } from "../../protocol/writer.js";
 import { createAPI } from "../definitions.js";
+import { ConfigResourceTypes } from "../enumerations.js";
 /*
   ListClientMetricsResources Request (Version: 0) => TAG_BUFFER
 */
-export function createRequest() {
+export function createRequest(_resourceTypes) {
     return Writer.create().appendTaggedFields();
 }
 /*
-ListClientMetricsResources Response (Version: 0) => throttle_time_ms error_code [client_metrics_resources] TAG_BUFFER
+ ListClientMetricsResources Response (Version: 0) => throttle_time_ms error_code [config_resources] TAG_BUFFER
   throttle_time_ms => INT32
   error_code => INT16
-  client_metrics_resources => name TAG_BUFFER
-    name => COMPACT_STRING
+  config_resources => resource_name TAG_BUFFER
+    resource_name => COMPACT_STRING
 */
 export function parseResponse(_correlationId, apiKey, apiVersion, reader) {
     const response = {
         throttleTimeMs: reader.readInt32(),
         errorCode: reader.readInt16(),
-        clientMetricsResources: reader.readArray(r => {
-            return {
-                name: r.readString()
+        configResources: reader.readArray(r => {
+            const resource = {
+                resourceName: r.readString(),
+                resourceType: ConfigResourceTypes.CLIENT_METRICS
             };
-        })
+            r.readTaggedFields();
+            return resource;
+        }, true, false)
     };
+    reader.readTaggedFields();
     if (response.errorCode !== 0) {
         throw new ResponseError(apiKey, apiVersion, { '/': [response.errorCode, null] }, response);
     }

package/dist/apis/telemetry/list-config-resources-v1.d.ts

@@ -0,0 +1,16 @@
+import { type Reader } from '../../protocol/reader.ts';
+import { Writer } from '../../protocol/writer.ts';
+import { type ConfigResourceTypeValue } from '../enumerations.ts';
+export type ListConfigResourcesRequest = Parameters<typeof createRequest>;
+export interface ListConfigResourcesResource {
+    resourceName: string;
+    resourceType: ConfigResourceTypeValue;
+}
+export interface ListConfigResourcesResponse {
+    throttleTimeMs: number;
+    errorCode: number;
+    configResources: ListConfigResourcesResource[];
+}
+export declare function createRequest(resourceTypes?: ConfigResourceTypeValue[]): Writer;
+export declare function parseResponse(_correlationId: number, apiKey: number, apiVersion: number, reader: Reader): ListConfigResourcesResponse;
+export declare const api: import("../definitions.ts").API<[resourceTypes?: ConfigResourceTypeValue[] | undefined], ListConfigResourcesResponse>;

package/dist/apis/telemetry/list-config-resources-v1.js

@@ -0,0 +1,38 @@
+import { ResponseError } from "../../errors.js";
+import { Writer } from "../../protocol/writer.js";
+import { createAPI } from "../definitions.js";
+/*
+  ListConfigResources Request (Version: 1) => [resource_types] TAG_BUFFER
+    resource_types => INT8
+*/
+export function createRequest(resourceTypes = []) {
+    return Writer.create().appendArray(resourceTypes, (w, resourceType) => w.appendInt8(resourceType), true, false).appendTaggedFields();
+}
+/*
+ ListConfigResources Response (Version: 1) => throttle_time_ms error_code [config_resources] TAG_BUFFER
+   throttle_time_ms => INT32
+   error_code => INT16
+   config_resources => resource_name resource_type TAG_BUFFER
+     resource_name => COMPACT_STRING
+     resource_type => INT8
+*/
+export function parseResponse(_correlationId, apiKey, apiVersion, reader) {
+    const response = {
+        throttleTimeMs: reader.readInt32(),
+        errorCode: reader.readInt16(),
+        configResources: reader.readArray(r => {
+            const resource = {
+                resourceName: r.readString(),
+                resourceType: r.readInt8()
+            };
+            r.readTaggedFields();
+            return resource;
+        }, true, false)
+    };
+    reader.readTaggedFields();
+    if (response.errorCode !== 0) {
+        throw new ResponseError(apiKey, apiVersion, { '/': [response.errorCode, null] }, response);
+    }
+    return response;
+}
+export const api = createAPI(74, 1, createRequest, parseResponse);

package/dist/apis/telemetry/push-telemetry-v0.d.ts

@@ -1,10 +1,11 @@
 import { type Reader } from '../../protocol/reader.ts';
 import { Writer } from '../../protocol/writer.ts';
+import { type TelemetryCompressionType } from './compression-types.ts';
 export type PushTelemetryRequest = Parameters<typeof createRequest>;
 export interface PushTelemetryResponse {
     throttleTimeMs: number;
     errorCode: number;
 }
-export declare function createRequest(clientInstanceId: string, subscriptionId: number, terminating: boolean, compressionType: number, metrics: Buffer): Writer;
+export declare function createRequest(clientInstanceId: string, subscriptionId: number, terminating: boolean, compressionType: TelemetryCompressionType, metrics: Buffer): Writer;
 export declare function parseResponse(_correlationId: number, apiKey: number, apiVersion: number, reader: Reader): PushTelemetryResponse;
-export declare const api: import("../definitions.ts").API<[clientInstanceId: string, subscriptionId: number, terminating: boolean, compressionType: number, metrics: Buffer<ArrayBufferLike>], PushTelemetryResponse>;
+export declare const api: import("../definitions.ts").API<[clientInstanceId: string, subscriptionId: number, terminating: boolean, compressionType: TelemetryCompressionType, metrics: Buffer<ArrayBufferLike>], PushTelemetryResponse>;

package/dist/apis/telemetry/push-telemetry-v0.js

@@ -28,6 +28,7 @@ export function parseResponse(_correlationId, apiKey, apiVersion, reader) {
         throttleTimeMs: reader.readInt32(),
         errorCode: reader.readInt16()
     };
+    reader.readTaggedFields();
     if (response.errorCode !== 0) {
         throw new ResponseError(apiKey, apiVersion, { '/': [response.errorCode, null] }, response);
     }

package/dist/clients/admin/admin.js

@@ -1,9 +1,9 @@
 import { createPromisifiedCallback, kCallbackPromise, runConcurrentCallbacks } from "../../apis/callbacks.js";
-import { ConfigResourceTypes, FetchIsolationLevels, FindCoordinatorKeyTypes } from "../../apis/enumerations.js";
+import { ConfigResourceTypes, FetchIsolationLevels, FindCoordinatorKeyTypes, legacyConsumerGroupStates } from "../../apis/enumerations.js";
 import { adminAclsChannel, adminClientQuotasChannel, adminConfigsChannel, adminConsumerGroupOffsetsChannel, adminGroupsChannel, adminLogDirsChannel, adminOffsetsChannel, adminTopicsChannel, createDiagnosticContext } from "../../diagnostic.js";
 import { findErrorBy, MultipleErrors, NetworkError, UserError } from "../../errors.js";
-import { Reader } from "../../protocol/reader.js";
 import { Base, kAfterCreate, kCheckNotClosed, kConnections, kGetApi, kGetBootstrapConnection, kGetConnection, kMetadata, kOptions, kPerformDeduplicated, kPerformWithRetry, kValidateOptions } from "../base/base.js";
+import { decodeConsumerProtocolAssignment, decodeConsumerProtocolSubscription } from "../consumer/consumer-protocol.js";
 import { adminListOffsetsOptionsValidator, alterClientQuotasOptionsValidator, alterConfigsOptionsValidator, alterConsumerGroupOffsetsOptionsValidator, createAclsOptionsValidator, createPartitionsOptionsValidator, createTopicsOptionsValidator, deleteAclsOptionsValidator, deleteConsumerGroupOffsetsOptionsValidator, deleteGroupsOptionsValidator, deleteRecordsOptionsValidator, deleteTopicsOptionsValidator, describeAclsOptionsValidator, describeClientQuotasOptionsValidator, describeConfigsOptionsValidator, describeGroupsOptionsValidator, describeLogDirsOptionsValidator, findCoordinatorOptionsValidator, incrementalAlterConfigsOptionsValidator, listConsumerGroupOffsetsOptionsValidator, listGroupsOptionsValidator, listTopicsOptionsValidator, removeMembersFromConsumerGroupOptionsValidator } from "./options.js";
 export class Admin extends Base {
     #controller = null;
@@ -477,9 +477,10 @@ export class Admin extends Base {
                     return;
                 }
                 const created = [];
-                for (const { name, topicId: id, numPartitions: partitions, replicationFactor: replicas, configs } of response.topics) {
+                const topics = response.topics;
+                for (const { name, topicId: id = '', numPartitions: partitions = -1, replicationFactor: replicas = -1, configs: topicConfigs } of topics) {
                     const configuration = {};
-                    for (const { name, value } of configs) {
+                    for (const { name, value } of topicConfigs ?? []) {
                         configuration[name] = value;
                     }
                     created.push({ id, name, partitions, replicas, configuration });
@@ -567,8 +568,11 @@ export class Admin extends Base {
                                 retryCallback(error);
                                 return;
                             }
+                            // Brokers filter on the values they put on the wire, so the legacy Java enum
+                            // constant names have to be translated or they would silently match nothing.
+                            const states = (options.states ?? []).map(state => legacyConsumerGroupStates[state] ?? state);
                             /* c8 ignore next 5 */
-                            api(connection, options.states ?? [], options.types, retryCallback);
+                            api(connection, states, options.types, retryCallback);
                         });
                     }, concurrentCallback, 0);
                 });
@@ -582,8 +586,10 @@ export class Admin extends Base {
                     for (const raw of result.groups) {
                         groups.set(raw.groupId, {
                             id: raw.groupId,
-                            state: raw.groupState.toUpperCase(),
-                            groupType: raw.groupType,
+                            // ListGroups only carries group_state from v4, so below that the codec has nothing
+                            // to report. 'Unknown' is the value Kafka itself uses for exactly this case.
+                            state: (raw.groupState || 'Unknown'),
+                            groupType: raw.groupType || undefined,
                             protocolType: raw.protocolType
                         });
                     }
@@ -636,29 +642,26 @@ export class Admin extends Base {
                         for (const raw of result.groups) {
                             const group = {
                                 id: raw.groupId,
-                                state: raw.groupState.toUpperCase(),
+                                state: raw.groupState,
                                 protocolType: raw.protocolType,
                                 protocol: raw.protocolData,
                                 members: new Map(),
                                 authorizedOperations: raw.authorizedOperations
                             };
                             for (const member of raw.members) {
-                                const reader = Reader.from(member.memberMetadata);
                                 let memberMetadata;
                                 let memberAssignments;
-                                if (reader.remaining > 0) {
+                                if (member.memberMetadata.length > 0) {
+                                    const subscription = decodeConsumerProtocolSubscription(member.memberMetadata);
                                     memberMetadata = {
-                                        version: reader.readInt16(),
-                                        topics: reader.readArray(r => r.readString(false), false, false),
-                                        metadata: reader.readBytes(false)
+                                        version: subscription.version,
+                                        topics: subscription.topics,
+                                        metadata: subscription.userData,
+                                        ownedPartitions: subscription.ownedPartitions,
+                                        generationId: subscription.generationId,
+                                        rackId: subscription.rackId
                                     };
-                                    reader.reset(member.memberAssignment);
-                                    reader.skip(2); // Ignore Version information
-                                    memberAssignments = reader.readMap(r => {
-                                        const topic = r.readString(false);
-                                        return [topic, { topic, partitions: reader.readArray(r => r.readInt32(), false, false) }];
-                                    }, false, false);
-                                    // Ignore the user data
+                                    memberAssignments = new Map(decodeConsumerProtocolAssignment(member.memberAssignment).assignedPartitions.map(assignment => [assignment.topic, assignment]));
                                 }
                                 group.members.set(member.memberId, {
                                     id: member.memberId,
@@ -769,7 +772,13 @@ export class Admin extends Base {
                             groupInstanceId: null,
                             reason: typeof member === 'string' ? 'Not specified' : member.reason
                         }));
-                        api(connection, options.groupId, members, retryCallback);
+                        if (api.version >= 3) {
+                            api(connection, options.groupId, members, retryCallback);
+                            return;
+                        }
+                        runConcurrentCallbacks('Removing members from consumer group failed.', members, (member, concurrentCallback) => {
+                            api(connection, options.groupId, [member], concurrentCallback);
+                        }, error => retryCallback(error));
                     });
                 });
             });
@@ -793,7 +802,28 @@ export class Admin extends Base {
                         retryCallback(error);
                         return;
                     }
-                    api(connection, options.keyType, options.keys, retryCallback);
+                    if (api.version >= 4) {
+                        api(connection, options.keyType, options.keys, retryCallback);
+                        return;
+                    }
+                    runConcurrentCallbacks('Finding coordinator failed.', options.keys, (key, concurrentCallback) => {
+                        api(connection, options.keyType, [key], (error, response) => {
+                            if (response) {
+                                response.coordinators[0].key = key;
+                            }
+                            concurrentCallback(error, response);
+                        });
+                    }, (error, responses) => {
+                        if (error) {
+                            retryCallback(error);
+                            return;
+                        }
+                        retryCallback(null, {
+                            // The caller controls how many keys are looked up, so reduce rather than spread.
+                            throttleTimeMs: responses.reduce((max, response) => Math.max(max, response.throttleTimeMs), 0),
+                            coordinators: responses.flatMap(response => response.coordinators)
+                        });
+                    });
                 });
             });
         }, (error, response) => {
@@ -829,7 +859,7 @@ export class Admin extends Base {
                 callback(new MultipleErrors('Describing client quotas failed.', [error]));
                 return;
             }
-            callback(null, response.entries);
+            callback(null, response.entries ?? []);
         }, 0);
     }
     #alterClientQuotas(options, callback) {
@@ -943,8 +973,38 @@ export class Admin extends Base {
                                     retryCallback(error);
                                     return;
                                 }
-                                /* c8 ignore next - Hard to test */
-                                api(connection, groupRequests, options.requireStable ?? false, retryCallback);
+                                if (api.version >= 8) {
+                                    api(connection, groupRequests, options.requireStable ?? false, retryCallback);
+                                    return;
+                                }
+                                runConcurrentCallbacks('Listing consumer group offsets failed.', groupRequests, (groupRequest, groupCallback) => {
+                                    api(connection, [groupRequest], options.requireStable ?? false, (error, response) => {
+                                        if (error) {
+                                            groupCallback(error);
+                                            return;
+                                        }
+                                        const legacyResponse = response;
+                                        groupCallback(null, {
+                                            throttleTimeMs: legacyResponse.throttleTimeMs,
+                                            groups: [
+                                                {
+                                                    groupId: groupRequest.groupId,
+                                                    topics: legacyResponse.topics,
+                                                    errorCode: legacyResponse.errorCode
+                                                }
+                                            ]
+                                        });
+                                    });
+                                }, (error, responses) => {
+                                    if (error) {
+                                        retryCallback(error);
+                                        return;
+                                    }
+                                    retryCallback(null, {
+                                        throttleTimeMs: responses.reduce((max, response) => Math.max(max, response.throttleTimeMs), 0),
+                                        groups: responses.flatMap(response => response.groups)
+                                    });
+                                });
                             });
                         });
                     }, concurrentCallback, 0);

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

@@ -185,7 +185,7 @@ export declare const listGroupsOptionsSchema: {
             items: {
                 type: string;
                 enumeration: {
-                    allowed: readonly ["PREPARING_REBALANCE", "COMPLETING_REBALANCE", "STABLE", "DEAD", "EMPTY"];
+                    allowed: ("Unknown" | "PreparingRebalance" | "CompletingRebalance" | "Stable" | "Dead" | "Empty" | "Assigning" | "Reconciling" | "NotReady" | "PREPARING_REBALANCE" | "COMPLETING_REBALANCE" | "STABLE" | "DEAD" | "EMPTY")[];
                     errorMessage: string;
                 };
             };
@@ -764,7 +764,7 @@ export declare const createAclsOptionsSchema: {
                     };
                     operation: {
                         type: string;
-                        enum: (0 | 1 | 2 | 4 | 8 | 7 | 10 | 3 | 5 | 6 | 9 | 11 | 12 | 13 | 14 | 15)[];
+                        enum: (0 | 1 | 2 | 4 | 8 | 7 | 10 | 12 | 3 | 5 | 6 | 9 | 11 | 13 | 14 | 15)[];
                     };
                     permissionType: {
                         type: string;
@@ -823,7 +823,7 @@ export declare const describeAclsOptionsSchema: {
                 };
                 operation: {
                     type: string;
-                    enum: (0 | 1 | 2 | 4 | 8 | 7 | 10 | 3 | 5 | 6 | 9 | 11 | 12 | 13 | 14 | 15)[];
+                    enum: (0 | 1 | 2 | 4 | 8 | 7 | 10 | 12 | 3 | 5 | 6 | 9 | 11 | 13 | 14 | 15)[];
                 };
                 permissionType: {
                     type: string;
@@ -882,7 +882,7 @@ export declare const deleteAclsOptionsSchema: {
                     };
                     operation: {
                         type: string;
-                        enum: (0 | 1 | 2 | 4 | 8 | 7 | 10 | 3 | 5 | 6 | 9 | 11 | 12 | 13 | 14 | 15)[];
+                        enum: (0 | 1 | 2 | 4 | 8 | 7 | 10 | 12 | 3 | 5 | 6 | 9 | 11 | 13 | 14 | 15)[];
                     };
                     permissionType: {
                         type: string;

package/dist/clients/admin/options.js

@@ -1,4 +1,4 @@
-import { allowedAclOperations, allowedAclPermissionTypes, allowedClientQuotaMatchTypes, allowedFetchIsolationLevels, allowedFindCoordinatorKeyTypes, allowedIncrementalAlterConfigOperationTypes, allowedResourcePatternTypes, allowedResourceTypes, ConsumerGroupStates, IncrementalAlterConfigOperationTypes } from "../../apis/enumerations.js";
+import { allowedAclOperations, allowedAclPermissionTypes, allowedClientQuotaMatchTypes, allowedFetchIsolationLevels, allowedFindCoordinatorKeyTypes, allowedIncrementalAlterConfigOperationTypes, allowedResourcePatternTypes, allowedResourceTypes, ConsumerGroupStates, KafkaConsumerGroupStates, IncrementalAlterConfigOperationTypes } from "../../apis/enumerations.js";
 import { ajv, listErrorMessage } from "../../utils.js";
 import { idProperty } from "../base/options.js";
 export const groupsProperties = {
@@ -117,8 +117,8 @@ export const listGroupsOptionsSchema = {
             items: {
                 type: 'string',
                 enumeration: {
-                    allowed: ConsumerGroupStates,
-                    errorMessage: listErrorMessage(ConsumerGroupStates)
+                    allowed: [...ConsumerGroupStates, ...KafkaConsumerGroupStates],
+                    errorMessage: listErrorMessage([...ConsumerGroupStates, ...KafkaConsumerGroupStates])
                 }
             },
             minItems: 0

package/dist/clients/admin/types.d.ts

@@ -33,7 +33,7 @@ export interface GroupMember {
 export interface GroupBase {
     id: string;
     state: ConsumerGroupStateValue;
-    groupType: string;
+    groupType?: string;
     protocolType: string;
 }
 export interface Group extends Omit<GroupBase, 'groupType'> {

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

@@ -1,7 +1,7 @@
 import { type ValidateFunction } from 'ajv';
 import { type CallbackWithPromise } from '../../apis/callbacks.ts';
 import { type API, type Callback } from '../../apis/definitions.ts';
-import { type ApiVersionsResponseApi } from '../../apis/metadata/api-versions-v3.ts';
+import { type ApiVersionsResponseApi } from '../../apis/metadata/api-versions-v1.ts';
 import { type ClientType } from '../../diagnostic.ts';
 import { TypedEventEmitter, type TypedEvents } from '../../events.ts';
 import { ConnectionPool, type ConnectionPoolEventPayload } from '../../network/connection-pool.ts';
@@ -84,7 +84,7 @@ export declare class Base<OptionsType extends BaseOptions = BaseOptions, EventsT
     [kMetadata](options: MetadataOptions, callback: CallbackWithPromise<ClusterMetadata>): void;
     [kCheckNotClosed](callback: CallbackWithPromise<any>): boolean;
     clearMetadata(): void;
-    [kPerformWithRetry]<ReturnType>(operationId: string, operation: (callback: Callback<ReturnType>, attempt: number) => void, callback: CallbackWithPromise<ReturnType>, attempt?: number, errors?: Error[], shouldSkipRetry?: (e: Error) => boolean): void | Promise<ReturnType>;
+    [kPerformWithRetry]<ReturnType>(operationId: string, operation: (callback: Callback<ReturnType>, attempt: number) => void, callback: CallbackWithPromise<ReturnType>, attempt?: number, errors?: Error[], shouldSkipRetry?: (e: Error) => boolean, retryLimit?: number): 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;
     [kGetConnection](broker: Broker, callback: Callback<Connection>): void;