@platformatic/kafka 1.24.0 → 1.25.0

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

@@ -5,7 +5,7 @@ import { type CallbackWithPromise } from '../../apis/callbacks.ts';
 import { type Callback } from '../../apis/definitions.ts';
 import { type Acl } from '../../apis/types.ts';
 import { Base } from '../base/base.ts';
-import { type AdminOptions, type AlterClientQuotasOptions, type AlterConfigsOptions, type AlterConsumerGroupOffsetsOptions, type BrokerLogDirDescription, type ConfigDescription, type CreateAclsOptions, type CreatedTopic, type CreatePartitionsOptions, type CreateTopicsOptions, type DeleteAclsOptions, type DeleteConsumerGroupOffsetsOptions, type DeleteGroupsOptions, type DeleteTopicsOptions, type DescribeAclsOptions, type DescribeClientQuotasOptions, type DescribeConfigsOptions, type DescribeGroupsOptions, type DescribeLogDirsOptions, type Group, type GroupBase, type IncrementalAlterConfigsOptions, type ListConsumerGroupOffsetsGroup, type ListConsumerGroupOffsetsOptions, type ListedOffsetsTopic, type ListGroupsOptions, type ListOffsetsOptions, type ListTopicsOptions, type RemoveMembersFromConsumerGroupOptions } from './types.ts';
+import { type AdminListOffsetsOptions, type AdminOptions, type AlterClientQuotasOptions, type AlterConfigsOptions, type AlterConsumerGroupOffsetsOptions, type BrokerLogDirDescription, type ConfigDescription, type CreateAclsOptions, type CreatedTopic, type CreatePartitionsOptions, type CreateTopicsOptions, type DeleteAclsOptions, type DeleteConsumerGroupOffsetsOptions, type DeleteGroupsOptions, type DeleteTopicsOptions, type DescribeAclsOptions, type DescribeClientQuotasOptions, type DescribeConfigsOptions, type DescribeGroupsOptions, type DescribeLogDirsOptions, type Group, type GroupBase, type IncrementalAlterConfigsOptions, type ListConsumerGroupOffsetsGroup, type ListConsumerGroupOffsetsOptions, type ListedOffsetsTopic, type ListGroupsOptions, type ListTopicsOptions, type RemoveMembersFromConsumerGroupOptions } from './types.ts';
 export declare class Admin extends Base<AdminOptions> {
     #private;
     constructor(options: AdminOptions);
@@ -55,6 +55,6 @@ export declare class Admin extends Base<AdminOptions> {
     describeAcls(options: DescribeAclsOptions): Promise<DescribeAclsResponseResource[]>;
     deleteAcls(options: DeleteAclsOptions, callback: CallbackWithPromise<Acl[]>): void;
     deleteAcls(options: DeleteAclsOptions): Promise<Acl[]>;
-    listOffsets(options: ListOffsetsOptions, callback: CallbackWithPromise<ListedOffsetsTopic[]>): void;
-    listOffsets(options: ListOffsetsOptions): Promise<ListedOffsetsTopic[]>;
+    listOffsets(options: AdminListOffsetsOptions, callback: CallbackWithPromise<ListedOffsetsTopic[]>): void;
+    listOffsets(options: AdminListOffsetsOptions): Promise<ListedOffsetsTopic[]>;
 }

package/dist/clients/admin/admin.js

@@ -4,7 +4,7 @@ import { adminAclsChannel, adminClientQuotasChannel, adminConfigsChannel, adminC
 import { MultipleErrors } 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 { alterClientQuotasOptionsValidator, alterConfigsOptionsValidator, alterConsumerGroupOffsetsOptionsValidator, createAclsOptionsValidator, createPartitionsOptionsValidator, createTopicsOptionsValidator, deleteAclsOptionsValidator, deleteConsumerGroupOffsetsOptionsValidator, deleteGroupsOptionsValidator, deleteTopicsOptionsValidator, describeAclsOptionsValidator, describeClientQuotasOptionsValidator, describeConfigsOptionsValidator, describeGroupsOptionsValidator, describeLogDirsOptionsValidator, incrementalAlterConfigsOptionsValidator, listConsumerGroupOffsetsOptionsValidator, listGroupsOptionsValidator, listOffsetsOptionsValidator, listTopicsOptionsValidator, removeMembersFromConsumerGroupOptionsValidator } from "./options.js";
+import { adminListOffsetsOptionsValidator, alterClientQuotasOptionsValidator, alterConfigsOptionsValidator, alterConsumerGroupOffsetsOptionsValidator, createAclsOptionsValidator, createPartitionsOptionsValidator, createTopicsOptionsValidator, deleteAclsOptionsValidator, deleteConsumerGroupOffsetsOptionsValidator, deleteGroupsOptionsValidator, deleteTopicsOptionsValidator, describeAclsOptionsValidator, describeClientQuotasOptionsValidator, describeConfigsOptionsValidator, describeGroupsOptionsValidator, describeLogDirsOptionsValidator, incrementalAlterConfigsOptionsValidator, listConsumerGroupOffsetsOptionsValidator, listGroupsOptionsValidator, listTopicsOptionsValidator, removeMembersFromConsumerGroupOptionsValidator } from "./options.js";
 export class Admin extends Base {
     #controller = null;
     constructor(options) {
@@ -326,7 +326,7 @@ export class Admin extends Base {
         if (this[kCheckNotClosed](callback)) {
             return callback[kCallbackPromise];
         }
-        const validationError = this[kValidateOptions](options, listOffsetsOptionsValidator, '/options', false);
+        const validationError = this[kValidateOptions](options, adminListOffsetsOptionsValidator, '/options', false);
         if (validationError) {
             callback(validationError);
             return callback[kCallbackPromise];

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

@@ -802,7 +802,7 @@ export declare const deleteAclsOptionsSchema: {
     required: string[];
     additionalProperties: boolean;
 };
-export declare const listOffsetsOptionsSchema: {
+export declare const adminListOffsetsOptionsSchema: {
     type: string;
     properties: {
         topics: {
@@ -902,6 +902,6 @@ export declare const describeAclsOptionsValidator: import("ajv").ValidateFunctio
 export declare const deleteAclsOptionsValidator: import("ajv").ValidateFunction<{
     [x: string]: {};
 }>;
-export declare const listOffsetsOptionsValidator: import("ajv").ValidateFunction<{
+export declare const adminListOffsetsOptionsValidator: import("ajv").ValidateFunction<{
     [x: string]: {};
 }>;

package/dist/clients/admin/options.js

@@ -1,4 +1,4 @@
-import { allowedIncrementalAlterConfigOperationTypes, allowedResourceTypes, ConsumerGroupStates, IncrementalAlterConfigOperationTypes, allowedAclOperations, allowedAclPermissionTypes, allowedResourcePatternTypes, allowedFetchIsolationLevels, allowedClientQuotaMatchTypes } from "../../apis/enumerations.js";
+import { allowedAclOperations, allowedAclPermissionTypes, allowedClientQuotaMatchTypes, allowedFetchIsolationLevels, allowedIncrementalAlterConfigOperationTypes, allowedResourcePatternTypes, allowedResourceTypes, ConsumerGroupStates, IncrementalAlterConfigOperationTypes } from "../../apis/enumerations.js";
 import { ajv, listErrorMessage } from "../../utils.js";
 import { idProperty } from "../base/options.js";
 export const groupsProperties = {
@@ -522,7 +522,7 @@ export const deleteAclsOptionsSchema = {
     required: ['filters'],
     additionalProperties: false
 };
-export const listOffsetsOptionsSchema = {
+export const adminListOffsetsOptionsSchema = {
     type: 'object',
     properties: {
         topics: {
@@ -575,4 +575,4 @@ export const incrementalAlterConfigsOptionsValidator = ajv.compile(incrementalAl
 export const createAclsOptionsValidator = ajv.compile(createAclsOptionsSchema);
 export const describeAclsOptionsValidator = ajv.compile(describeAclsOptionsSchema);
 export const deleteAclsOptionsValidator = ajv.compile(deleteAclsOptionsSchema);
-export const listOffsetsOptionsValidator = ajv.compile(listOffsetsOptionsSchema);
+export const adminListOffsetsOptionsValidator = ajv.compile(adminListOffsetsOptionsSchema);

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

@@ -1,16 +1,16 @@
 import { type AlterClientQuotasRequestEntry } from '../../apis/admin/alter-client-quotas-v1.ts';
+import { type AlterConfigsRequestResource } from '../../apis/admin/alter-configs-v2.ts';
 import { type CreatePartitionsRequestTopic } from '../../apis/admin/create-partitions-v3.ts';
 import { type CreateTopicsRequestTopicConfig } from '../../apis/admin/create-topics-v7.ts';
-import { type AlterConfigsRequestResource } from '../../apis/admin/alter-configs-v2.ts';
-import { type DescribeConfigsRequestResource, type DescribeConfigsResponseConfig } from '../../apis/admin/describe-configs-v4.ts';
 import { type DescribeClientQuotasRequestComponent } from '../../apis/admin/describe-client-quotas-v0.ts';
+import { type DescribeConfigsRequestResource, type DescribeConfigsResponseConfig } from '../../apis/admin/describe-configs-v4.ts';
 import { type DescribeLogDirsRequestTopic, type DescribeLogDirsResponse, type DescribeLogDirsResponseResult } from '../../apis/admin/describe-log-dirs-v4.ts';
 import { type IncrementalAlterConfigsRequestResource } from '../../apis/admin/incremental-alter-configs-v1.ts';
-import { type FetchIsolationLevelValue, type ConfigResourceTypeValue, type ConsumerGroupStateValue } from '../../apis/enumerations.ts';
+import { type ConfigResourceTypeValue, type ConsumerGroupStateValue, type FetchIsolationLevelValue } from '../../apis/enumerations.ts';
+import { type Acl, type AclFilter } from '../../apis/types.ts';
 import { type Nullable, type NullableString } from '../../protocol/definitions.ts';
 import { type BaseOptions } from '../base/types.ts';
 import { type ExtendedGroupProtocolSubscription, type GroupAssignment } from '../consumer/types.ts';
-import { type Acl, type AclFilter } from '../../apis/types.ts';
 export interface BrokerAssignment {
     partition: number;
     brokers: number[];
@@ -174,7 +174,7 @@ export interface TopicOffsetRequest {
     name: string;
     partitions: PartitionTimestamp[];
 }
-export interface ListOffsetsOptions {
+export interface AdminListOffsetsOptions {
     topics: TopicOffsetRequest[];
     isolationLevel?: Nullable<FetchIsolationLevelValue>;
 }

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

@@ -1,10 +1,10 @@
 import { type ValidateFunction } from 'ajv';
-import { EventEmitter } from 'node:events';
 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 ClientType } from '../../diagnostic.ts';
-import { ConnectionPool } from '../../network/connection-pool.ts';
+import { TypedEventEmitter, type TypedEvents } from '../../events.ts';
+import { ConnectionPool, type ConnectionPoolEventPayload } from '../../network/connection-pool.ts';
 import { type Broker, type Connection } from '../../network/connection.ts';
 import { kInstance } from '../../symbols.ts';
 import { type Metrics } from '../metrics.ts';
@@ -31,7 +31,24 @@ export declare const kFormatValidationErrors: unique symbol;
 export declare const kPrometheus: unique symbol;
 export declare const kClientType: unique symbol;
 export declare const kAfterCreate: unique symbol;
-export declare class Base<OptionsType extends BaseOptions = BaseOptions> extends EventEmitter {
+export interface BaseEvents extends TypedEvents {
+    'client:broker:connect': (payload: ConnectionPoolEventPayload) => void;
+    'client:broker:disconnect': (payload: ConnectionPoolEventPayload) => void;
+    'client:broker:failed': (payload: ConnectionPoolEventPayload) => void;
+    'client:broker:drain': (payload: ConnectionPoolEventPayload) => void;
+    'client:broker:sasl:handshake': (payload: ConnectionPoolEventPayload & {
+        mechanisms: string[];
+    }) => void;
+    'client:broker:sasl:authentication': (payload: ConnectionPoolEventPayload & {
+        authentication: Buffer;
+    }) => void;
+    'client:broker:sasl:authentication:extended': (payload: ConnectionPoolEventPayload & {
+        authentication: Buffer;
+    }) => void;
+    'client:metadata': (metadata: ClusterMetadata) => void;
+    'client:close': () => void;
+}
+export declare class Base<OptionsType extends BaseOptions = BaseOptions, EventsType extends BaseEvents = BaseEvents> extends TypedEventEmitter<EventsType> {
     #private;
     [kInstance]: number;
     [kClientId]: string;

package/dist/clients/base/base.js

@@ -1,9 +1,9 @@
-import { EventEmitter } from 'node:events';
 import { createPromisifiedCallback, kCallbackPromise, runConcurrentCallbacks } from "../../apis/callbacks.js";
 import * as apis from "../../apis/index.js";
 import { api as apiVersionsV3 } from "../../apis/metadata/api-versions-v3.js";
 import { baseApisChannel, baseMetadataChannel, createDiagnosticContext, notifyCreation } from "../../diagnostic.js";
 import { MultipleErrors, NetworkError, UnsupportedApiError, UserError } from "../../errors.js";
+import { TypedEventEmitter } from "../../events.js";
 import { ConnectionPool } from "../../network/connection-pool.js";
 import { parseBroker } from "../../network/utils.js";
 import { kInstance } from "../../symbols.js";
@@ -32,7 +32,7 @@ export const kPrometheus = Symbol('plt.kafka.base.prometheus');
 export const kClientType = Symbol('plt.kafka.base.clientType');
 export const kAfterCreate = Symbol('plt.kafka.base.afterCreate');
 let currentInstance = 0;
-export class Base extends EventEmitter {
+export class Base extends TypedEventEmitter {
     // This is declared using a symbol (a.k.a protected/friend) to make it available in ConnectionPool and MessagesStream
     [kInstance];
     // General status - Use symbols rather than JS private property to make them "protected" as in C++

package/dist/clients/consumer/consumer.d.ts

@@ -1,11 +1,23 @@
 import { type CallbackWithPromise } from '../../apis/callbacks.ts';
 import { type FetchResponse } from '../../apis/consumer/fetch-v17.ts';
 import { type ConnectionPool } from '../../network/connection-pool.ts';
-import { Base, kFetchConnections } from '../base/base.ts';
+import { Base, type BaseEvents, kFetchConnections } from '../base/base.ts';
 import { MessagesStream } from './messages-stream.ts';
 import { TopicsMap } from './topics-map.ts';
 import { type CommitOptions, type ConsumeOptions, type ConsumerGroupJoinPayload, type ConsumerGroupLeavePayload, type ConsumerGroupRebalancePayload, type ConsumerHeartbeatErrorPayload, type ConsumerHeartbeatPayload, type ConsumerOptions, type FetchOptions, type GetLagOptions, type GroupAssignment, type GroupOptions, type ListCommitsOptions, type ListOffsetsOptions, type Offsets, type OffsetsWithTimestamps } from './types.ts';
-export declare class Consumer<Key = Buffer, Value = Buffer, HeaderKey = Buffer, HeaderValue = Buffer> extends Base<ConsumerOptions<Key, Value, HeaderKey, HeaderValue>> {
+export interface ConsumerEvents extends BaseEvents {
+    'consumer:group:join': (payload: ConsumerGroupJoinPayload) => void;
+    'consumer:group:leave': (payload: ConsumerGroupLeavePayload) => void;
+    'consumer:group:rejoin': () => void;
+    'consumer:group:rebalance': (payload: ConsumerGroupRebalancePayload) => void;
+    'consumer:heartbeat:start': (payload?: ConsumerHeartbeatPayload) => void;
+    'consumer:heartbeat:cancel': (payload: ConsumerHeartbeatPayload) => void;
+    'consumer:heartbeat:end': (payload?: ConsumerHeartbeatPayload) => void;
+    'consumer:heartbeat:error': (payload: ConsumerHeartbeatErrorPayload) => void;
+    'consumer:lag': (lag: Offsets) => void;
+    'consumer:lag:error': (error: Error) => void;
+}
+export declare class Consumer<Key = Buffer, Value = Buffer, HeaderKey = Buffer, HeaderValue = Buffer> extends Base<ConsumerOptions<Key, Value, HeaderKey, HeaderValue>, ConsumerEvents> {
     #private;
     groupId: string;
     generationId: number;
@@ -17,61 +29,6 @@ export declare class Consumer<Key = Buffer, Value = Buffer, HeaderKey = Buffer,
     get streamsCount(): number;
     get lastHeartbeat(): Date | null;
     get coordinatorId(): number | null;
-    addListener(event: 'consumer:group:join', listener: (payload: ConsumerGroupJoinPayload) => void): this;
-    addListener(event: 'consumer:group:leave', listener: (payload: ConsumerGroupLeavePayload) => void): this;
-    addListener(event: 'consumer:group:rejoin', listener: () => void): this;
-    addListener(event: 'consumer:group:rebalance', listener: (payload: ConsumerGroupRebalancePayload) => void): this;
-    addListener(event: 'consumer:heartbeat:start', listener: (payload?: ConsumerHeartbeatPayload) => void): this;
-    addListener(event: 'consumer:heartbeat:cancel', listener: (payload: ConsumerHeartbeatPayload) => void): this;
-    addListener(event: 'consumer:heartbeat:end', listener: (payload?: ConsumerHeartbeatPayload) => void): this;
-    addListener(event: 'consumer:heartbeat:error', listener: (payload: ConsumerHeartbeatErrorPayload) => void): this;
-    addListener(event: 'consumer:lag', listener: (lag: Offsets) => void): this;
-    addListener(event: 'consumer:lag:error', listener: (error: Error) => void): this;
-    addListener(event: 'error', listener: (error: Error) => void): this;
-    on(event: 'consumer:group:join', listener: (payload: ConsumerGroupJoinPayload) => void): this;
-    on(event: 'consumer:group:leave', listener: (payload: ConsumerGroupLeavePayload) => void): this;
-    on(event: 'consumer:group:rejoin', listener: () => void): this;
-    on(event: 'consumer:group:rebalance', listener: (payload: ConsumerGroupRebalancePayload) => void): this;
-    on(event: 'consumer:heartbeat:start', listener: (payload?: ConsumerHeartbeatPayload) => void): this;
-    on(event: 'consumer:heartbeat:cancel', listener: (payload: ConsumerHeartbeatPayload) => void): this;
-    on(event: 'consumer:heartbeat:end', listener: (payload?: ConsumerHeartbeatPayload) => void): this;
-    on(event: 'consumer:heartbeat:error', listener: (payload: ConsumerHeartbeatErrorPayload) => void): this;
-    on(event: 'consumer:lag', listener: (lag: Offsets) => void): this;
-    on(event: 'consumer:lag:error', listener: (error: Error) => void): this;
-    on(event: 'error', listener: (error: Error) => void): this;
-    once(event: 'consumer:group:join', listener: (payload: ConsumerGroupJoinPayload) => void): this;
-    once(event: 'consumer:group:leave', listener: (payload: ConsumerGroupLeavePayload) => void): this;
-    once(event: 'consumer:group:rejoin', listener: () => void): this;
-    once(event: 'consumer:group:rebalance', listener: (payload: ConsumerGroupRebalancePayload) => void): this;
-    once(event: 'consumer:heartbeat:start', listener: (payload?: ConsumerHeartbeatPayload) => void): this;
-    once(event: 'consumer:heartbeat:cancel', listener: (payload: ConsumerHeartbeatPayload) => void): this;
-    once(event: 'consumer:heartbeat:end', listener: (payload?: ConsumerHeartbeatPayload) => void): this;
-    once(event: 'consumer:heartbeat:error', listener: (payload: ConsumerHeartbeatErrorPayload) => void): this;
-    once(event: 'consumer:lag', listener: (lag: Offsets) => void): this;
-    once(event: 'consumer:lag:error', listener: (error: Error) => void): this;
-    once(event: 'error', listener: (error: Error) => void): this;
-    prependListener(event: 'consumer:group:join', listener: (payload: ConsumerGroupJoinPayload) => void): this;
-    prependListener(event: 'consumer:group:leave', listener: (payload: ConsumerGroupLeavePayload) => void): this;
-    prependListener(event: 'consumer:group:rejoin', listener: () => void): this;
-    prependListener(event: 'consumer:group:rebalance', listener: (payload: ConsumerGroupRebalancePayload) => void): this;
-    prependListener(event: 'consumer:heartbeat:start', listener: (payload?: ConsumerHeartbeatPayload) => void): this;
-    prependListener(event: 'consumer:heartbeat:cancel', listener: (payload: ConsumerHeartbeatPayload) => void): this;
-    prependListener(event: 'consumer:heartbeat:end', listener: (payload?: ConsumerHeartbeatPayload) => void): this;
-    prependListener(event: 'consumer:heartbeat:error', listener: (payload: ConsumerHeartbeatErrorPayload) => void): this;
-    prependListener(event: 'consumer:lag', listener: (lag: Offsets) => void): this;
-    prependListener(event: 'consumer:lag:error', listener: (error: Error) => void): this;
-    prependListener(event: 'error', listener: (error: Error) => void): this;
-    prependOnceListener(event: 'consumer:group:join', listener: (payload: ConsumerGroupJoinPayload) => void): this;
-    prependOnceListener(event: 'consumer:group:leave', listener: (payload: ConsumerGroupLeavePayload) => void): this;
-    prependOnceListener(event: 'consumer:group:rejoin', listener: () => void): this;
-    prependOnceListener(event: 'consumer:group:rebalance', listener: (payload: ConsumerGroupRebalancePayload) => void): this;
-    prependOnceListener(event: 'consumer:heartbeat:start', listener: (payload?: ConsumerHeartbeatPayload) => void): this;
-    prependOnceListener(event: 'consumer:heartbeat:cancel', listener: (payload: ConsumerHeartbeatPayload) => void): this;
-    prependOnceListener(event: 'consumer:heartbeat:end', listener: (payload?: ConsumerHeartbeatPayload) => void): this;
-    prependOnceListener(event: 'consumer:heartbeat:error', listener: (payload: ConsumerHeartbeatErrorPayload) => void): this;
-    prependOnceListener(event: 'consumer:lag', listener: (lag: Offsets) => void): this;
-    prependOnceListener(event: 'consumer:lag:error', listener: (error: Error) => void): this;
-    prependOnceListener(event: 'error', listener: (error: Error) => void): this;
     close(force: boolean | CallbackWithPromise<void>, callback?: CallbackWithPromise<void>): void;
     close(force?: boolean): Promise<void>;
     isActive(): boolean;

package/dist/clients/consumer/consumer.js

@@ -8,7 +8,6 @@ import { IS_CONTROL } from "../../protocol/records.js";
 import { Writer } from "../../protocol/writer.js";
 import { kAutocommit, kRefreshOffsetsAndFetch } from "../../symbols.js";
 import { Base, kAfterCreate, kCheckNotClosed, kClosed, kCreateConnectionPool, kFetchConnections, kFormatValidationErrors, kGetApi, kGetBootstrapConnection, kGetConnection, kMetadata, kOptions, kPerformDeduplicated, kPerformWithRetry, kPrometheus, kValidateOptions } from "../base/base.js";
-import { defaultBaseOptions } from "../base/options.js";
 import { ensureMetric } from "../metrics.js";
 import { MessagesStream } from "./messages-stream.js";
 import { commitOptionsValidator, consumeOptionsValidator, consumerOptionsValidator, defaultConsumerOptions, fetchOptionsValidator, getLagOptionsValidator, groupIdAndOptionsValidator, groupOptionsValidator, listCommitsOptionsValidator, listOffsetsOptionsValidator } from "./options.js";
@@ -53,8 +52,7 @@ export class Consumer extends Base {
     #metricActiveStreams;
     #metricLags;
     constructor(options) {
-        super(options);
-        this[kOptions] = Object.assign({}, defaultBaseOptions, defaultConsumerOptions, options);
+        super({ ...defaultConsumerOptions, ...options });
         this[kValidateOptions](options, consumerOptionsValidator, '/options');
         this.groupId = options.groupId;
         this.generationId = 0;
@@ -95,26 +93,6 @@ export class Consumer extends Base {
     get coordinatorId() {
         return this.#coordinatorId;
     }
-    /* c8 ignore next 3 - Only forwards to Node.js implementation - Inserted here to please Typescript */
-    addListener(event, listener) {
-        return super.addListener(event, listener);
-    }
-    /* c8 ignore next 3 - Only forwards to Node.js implementation - Inserted here to please Typescript */
-    on(event, listener) {
-        return super.on(event, listener);
-    }
-    /* c8 ignore next 3 - Only forwards to Node.js implementation - Inserted here to please Typescript */
-    once(event, listener) {
-        return super.once(event, listener);
-    }
-    /* c8 ignore next 3 - Only forwards to Node.js implementation - Inserted here to please Typescript */
-    prependListener(event, listener) {
-        return super.prependListener(event, listener);
-    }
-    /* c8 ignore next 3 - Only forwards to Node.js implementation - Inserted here to please Typescript */
-    prependOnceListener(event, listener) {
-        return super.prependOnceListener(event, listener);
-    }
     close(force, callback) {
         if (typeof force === 'function') {
             callback = force;
@@ -434,6 +412,14 @@ export class Consumer extends Base {
                 }
                 this[kFetchConnections].get(broker, (error, connection) => {
                     if (error) {
+                        // When a connection was not available (either interrupted or not available) we
+                        // reset the leader epoch in the options so that when connection is re-established again we can continue
+                        for (const topic of options.topics) {
+                            for (const partition of topic.partitions) {
+                                partition.currentLeaderEpoch = -1;
+                                partition.lastFetchedEpoch = -1;
+                            }
+                        }
                         retryCallback(error);
                         return;
                     }

package/dist/clients/consumer/messages-stream.js

@@ -114,6 +114,10 @@ export class MessagesStream extends Readable {
         if (consumer[kPrometheus]) {
             this.#metricsConsumedMessages = ensureMetric(consumer[kPrometheus], 'Counter', 'kafka_consumed_messages', 'Number of consumed Kafka messages');
         }
+        // Whenever the consumer loses a connection, reset all the partitions epochs
+        consumer.on('client:broker:disconnect', () => {
+            this.#partitionsEpochs.clear();
+        });
         notifyCreation('messages-stream', this);
     }
     /* c8 ignore next 3 - Simple getter */

package/dist/clients/index.d.ts

@@ -1,5 +1,5 @@
 export * from './serde.ts';
-export * as adminClient from './admin/index.ts';
+export * from './admin/index.ts';
 export * from './base/index.ts';
 export * from './consumer/index.ts';
 export * from './producer/index.ts';

package/dist/clients/index.js

@@ -1,5 +1,5 @@
 export * from "./serde.js";
-export * as adminClient from "./admin/index.js";
+export * from "./admin/index.js";
 export * from "./base/index.js";
 export * from "./consumer/index.js";
 export * from "./producer/index.js";

package/dist/diagnostic.d.ts

@@ -36,24 +36,24 @@ export declare const instancesChannel: ChannelWithName<object>;
 export declare const connectionsConnectsChannel: TracingChannelWithName<ConnectionDiagnosticEvent<Record<string, unknown>>>;
 export declare const connectionsApiChannel: TracingChannelWithName<ConnectionDiagnosticEvent<Record<string, unknown>>>;
 export declare const connectionsPoolGetsChannel: TracingChannelWithName<ConnectionPoolDiagnosticEvent<Record<string, unknown>>>;
-export declare const baseApisChannel: TracingChannelWithName<ClientDiagnosticEvent<Base<import("./index.ts").BaseOptions>, Record<string, unknown>>>;
-export declare const baseMetadataChannel: TracingChannelWithName<ClientDiagnosticEvent<Base<import("./index.ts").BaseOptions>, Record<string, unknown>>>;
-export declare const adminTopicsChannel: TracingChannelWithName<ClientDiagnosticEvent<Base<import("./index.ts").BaseOptions>, Record<string, unknown>>>;
-export declare const adminGroupsChannel: TracingChannelWithName<ClientDiagnosticEvent<Base<import("./index.ts").BaseOptions>, Record<string, unknown>>>;
-export declare const adminClientQuotasChannel: TracingChannelWithName<ClientDiagnosticEvent<Base<import("./index.ts").BaseOptions>, Record<string, unknown>>>;
-export declare const adminLogDirsChannel: TracingChannelWithName<ClientDiagnosticEvent<Base<import("./index.ts").BaseOptions>, Record<string, unknown>>>;
-export declare const adminConsumerGroupOffsetsChannel: TracingChannelWithName<ClientDiagnosticEvent<Base<import("./index.ts").BaseOptions>, Record<string, unknown>>>;
-export declare const adminConfigsChannel: TracingChannelWithName<ClientDiagnosticEvent<Base<import("./index.ts").BaseOptions>, Record<string, unknown>>>;
-export declare const adminAclsChannel: TracingChannelWithName<ClientDiagnosticEvent<Base<import("./index.ts").BaseOptions>, Record<string, unknown>>>;
-export declare const adminOffsetsChannel: TracingChannelWithName<ClientDiagnosticEvent<Base<import("./index.ts").BaseOptions>, Record<string, unknown>>>;
-export declare const producerInitIdempotentChannel: TracingChannelWithName<ClientDiagnosticEvent<Base<import("./index.ts").BaseOptions>, Record<string, unknown>>>;
-export declare const producerSendsChannel: TracingChannelWithName<ClientDiagnosticEvent<Base<import("./index.ts").BaseOptions>, Record<string, unknown>>>;
-export declare const producerTransactionsChannel: TracingChannelWithName<ClientDiagnosticEvent<Base<import("./index.ts").BaseOptions>, Record<string, unknown>>>;
-export declare const consumerGroupChannel: TracingChannelWithName<ClientDiagnosticEvent<Base<import("./index.ts").BaseOptions>, Record<string, unknown>>>;
-export declare const consumerHeartbeatChannel: TracingChannelWithName<ClientDiagnosticEvent<Base<import("./index.ts").BaseOptions>, Record<string, unknown>>>;
-export declare const consumerReceivesChannel: TracingChannelWithName<ClientDiagnosticEvent<Base<import("./index.ts").BaseOptions>, Record<string, unknown>>>;
-export declare const consumerFetchesChannel: TracingChannelWithName<ClientDiagnosticEvent<Base<import("./index.ts").BaseOptions>, Record<string, unknown>>>;
-export declare const consumerConsumesChannel: TracingChannelWithName<ClientDiagnosticEvent<Base<import("./index.ts").BaseOptions>, Record<string, unknown>>>;
-export declare const consumerCommitsChannel: TracingChannelWithName<ClientDiagnosticEvent<Base<import("./index.ts").BaseOptions>, Record<string, unknown>>>;
-export declare const consumerOffsetsChannel: TracingChannelWithName<ClientDiagnosticEvent<Base<import("./index.ts").BaseOptions>, Record<string, unknown>>>;
-export declare const consumerLagChannel: ChannelWithName<ClientDiagnosticEvent<Base<import("./index.ts").BaseOptions>, Record<string, unknown>>>;
+export declare const baseApisChannel: TracingChannelWithName<ClientDiagnosticEvent<Base<import("./index.ts").BaseOptions, import("./clients/base/base.ts").BaseEvents>, Record<string, unknown>>>;
+export declare const baseMetadataChannel: TracingChannelWithName<ClientDiagnosticEvent<Base<import("./index.ts").BaseOptions, import("./clients/base/base.ts").BaseEvents>, Record<string, unknown>>>;
+export declare const adminTopicsChannel: TracingChannelWithName<ClientDiagnosticEvent<Base<import("./index.ts").BaseOptions, import("./clients/base/base.ts").BaseEvents>, Record<string, unknown>>>;
+export declare const adminGroupsChannel: TracingChannelWithName<ClientDiagnosticEvent<Base<import("./index.ts").BaseOptions, import("./clients/base/base.ts").BaseEvents>, Record<string, unknown>>>;
+export declare const adminClientQuotasChannel: TracingChannelWithName<ClientDiagnosticEvent<Base<import("./index.ts").BaseOptions, import("./clients/base/base.ts").BaseEvents>, Record<string, unknown>>>;
+export declare const adminLogDirsChannel: TracingChannelWithName<ClientDiagnosticEvent<Base<import("./index.ts").BaseOptions, import("./clients/base/base.ts").BaseEvents>, Record<string, unknown>>>;
+export declare const adminConsumerGroupOffsetsChannel: TracingChannelWithName<ClientDiagnosticEvent<Base<import("./index.ts").BaseOptions, import("./clients/base/base.ts").BaseEvents>, Record<string, unknown>>>;
+export declare const adminConfigsChannel: TracingChannelWithName<ClientDiagnosticEvent<Base<import("./index.ts").BaseOptions, import("./clients/base/base.ts").BaseEvents>, Record<string, unknown>>>;
+export declare const adminAclsChannel: TracingChannelWithName<ClientDiagnosticEvent<Base<import("./index.ts").BaseOptions, import("./clients/base/base.ts").BaseEvents>, Record<string, unknown>>>;
+export declare const adminOffsetsChannel: TracingChannelWithName<ClientDiagnosticEvent<Base<import("./index.ts").BaseOptions, import("./clients/base/base.ts").BaseEvents>, Record<string, unknown>>>;
+export declare const producerInitIdempotentChannel: TracingChannelWithName<ClientDiagnosticEvent<Base<import("./index.ts").BaseOptions, import("./clients/base/base.ts").BaseEvents>, Record<string, unknown>>>;
+export declare const producerSendsChannel: TracingChannelWithName<ClientDiagnosticEvent<Base<import("./index.ts").BaseOptions, import("./clients/base/base.ts").BaseEvents>, Record<string, unknown>>>;
+export declare const producerTransactionsChannel: TracingChannelWithName<ClientDiagnosticEvent<Base<import("./index.ts").BaseOptions, import("./clients/base/base.ts").BaseEvents>, Record<string, unknown>>>;
+export declare const consumerGroupChannel: TracingChannelWithName<ClientDiagnosticEvent<Base<import("./index.ts").BaseOptions, import("./clients/base/base.ts").BaseEvents>, Record<string, unknown>>>;
+export declare const consumerHeartbeatChannel: TracingChannelWithName<ClientDiagnosticEvent<Base<import("./index.ts").BaseOptions, import("./clients/base/base.ts").BaseEvents>, Record<string, unknown>>>;
+export declare const consumerReceivesChannel: TracingChannelWithName<ClientDiagnosticEvent<Base<import("./index.ts").BaseOptions, import("./clients/base/base.ts").BaseEvents>, Record<string, unknown>>>;
+export declare const consumerFetchesChannel: TracingChannelWithName<ClientDiagnosticEvent<Base<import("./index.ts").BaseOptions, import("./clients/base/base.ts").BaseEvents>, Record<string, unknown>>>;
+export declare const consumerConsumesChannel: TracingChannelWithName<ClientDiagnosticEvent<Base<import("./index.ts").BaseOptions, import("./clients/base/base.ts").BaseEvents>, Record<string, unknown>>>;
+export declare const consumerCommitsChannel: TracingChannelWithName<ClientDiagnosticEvent<Base<import("./index.ts").BaseOptions, import("./clients/base/base.ts").BaseEvents>, Record<string, unknown>>>;
+export declare const consumerOffsetsChannel: TracingChannelWithName<ClientDiagnosticEvent<Base<import("./index.ts").BaseOptions, import("./clients/base/base.ts").BaseEvents>, Record<string, unknown>>>;
+export declare const consumerLagChannel: ChannelWithName<ClientDiagnosticEvent<Base<import("./index.ts").BaseOptions, import("./clients/base/base.ts").BaseEvents>, Record<string, unknown>>>;

package/dist/events.d.ts

@@ -0,0 +1,22 @@
+import { EventEmitter } from 'node:events';
+export interface TypedEvents {
+    error: (error: Error) => void;
+}
+export declare class TypedEventEmitter<EventsType extends TypedEvents = TypedEvents> extends EventEmitter {
+    addListener<K extends keyof EventsType>(event: K, listener: EventsType[K]): this;
+    addListener(event: string | symbol, listener: (...args: any[]) => void): this;
+    on<K extends keyof EventsType>(event: K, listener: EventsType[K]): this;
+    on(event: string | symbol, listener: (...args: any[]) => void): this;
+    once<K extends keyof EventsType>(event: K, listener: EventsType[K]): this;
+    once(event: string | symbol, listener: (...args: any[]) => void): this;
+    prependListener<K extends keyof EventsType>(event: K, listener: EventsType[K]): this;
+    prependListener(event: string | symbol, listener: (...args: any[]) => void): this;
+    prependeOnceListener<K extends keyof EventsType>(event: K, listener: EventsType[K]): this;
+    prependeOnceListener(event: string | symbol, listener: (...args: any[]) => void): this;
+    off<K extends keyof EventsType>(event: K, listener: EventsType[K]): this;
+    off(event: string | symbol, listener: (...args: any[]) => void): this;
+    removeListener<K extends keyof EventsType>(event: K, listener: EventsType[K]): this;
+    removeListener(event: string | symbol, listener: (...args: any[]) => void): this;
+    removeAllListeners<K extends keyof EventsType>(event: K): this;
+    removeAllListeners(event: string | symbol): this;
+}

package/dist/events.js

@@ -0,0 +1,29 @@
+import { EventEmitter } from 'node:events';
+/* c8 ignore start */
+export class TypedEventEmitter extends EventEmitter {
+    addListener(event, listener) {
+        return super.addListener(event, listener);
+    }
+    on(event, listener) {
+        return super.on(event, listener);
+    }
+    once(event, listener) {
+        return super.once(event, listener);
+    }
+    prependListener(event, listener) {
+        return super.prependListener(event, listener);
+    }
+    prependeOnceListener(event, listener) {
+        return super.prependOnceListener(event, listener);
+    }
+    off(event, listener) {
+        return super.off(event, listener);
+    }
+    removeListener(event, listener) {
+        return super.removeListener(event, listener);
+    }
+    removeAllListeners(event) {
+        return super.removeAllListeners(event);
+    }
+}
+/* c8 ignore end */

package/dist/index.d.ts

@@ -1,5 +1,6 @@
 export * from './diagnostic.ts';
 export * from './errors.ts';
+export * from './events.ts';
 export * from './utils.ts';
 export * from './network/index.ts';
 export * from './protocol/index.ts';

package/dist/index.js

@@ -1,6 +1,7 @@
 // General
 export * from "./diagnostic.js";
 export * from "./errors.js";
+export * from "./events.js";
 export * from "./utils.js";
 // Networking
 export * from "./network/index.js";

package/dist/network/connection-pool.d.ts

@@ -1,7 +1,27 @@
-import EventEmitter from 'node:events';
 import { type CallbackWithPromise } from '../apis/callbacks.ts';
+import { TypedEventEmitter, type TypedEvents } from '../events.ts';
 import { Connection, type Broker, type ConnectionOptions } from './connection.ts';
-export declare class ConnectionPool extends EventEmitter {
+export interface ConnectionPoolEventPayload {
+    broker: Broker;
+    connection: Connection;
+}
+export interface ConnectionPoolEvents extends TypedEvents {
+    connecting: (payload: ConnectionPoolEventPayload) => void;
+    failed: (payload: ConnectionPoolEventPayload) => void;
+    connect: (payload: ConnectionPoolEventPayload) => void;
+    'sasl:handshake': (payload: ConnectionPoolEventPayload & {
+        mechanisms: string[];
+    }) => void;
+    'sasl:authentication': (payload: ConnectionPoolEventPayload & {
+        authentication?: Buffer;
+    }) => void;
+    'sasl:authentication:extended': (payload: ConnectionPoolEventPayload & {
+        authentication?: Buffer;
+    }) => void;
+    disconnect: (payload: ConnectionPoolEventPayload) => void;
+    drain: (payload: ConnectionPoolEventPayload) => void;
+}
+export declare class ConnectionPool extends TypedEventEmitter<ConnectionPoolEvents> {
     #private;
     constructor(clientId: string, connectionOptions?: ConnectionOptions);
     get instanceId(): number;

package/dist/network/connection-pool.js

@@ -1,10 +1,10 @@
-import EventEmitter from 'node:events';
 import { createPromisifiedCallback, kCallbackPromise, runConcurrentCallbacks } from "../apis/callbacks.js";
 import { connectionsPoolGetsChannel, createDiagnosticContext, notifyCreation } from "../diagnostic.js";
+import { TypedEventEmitter } from "../events.js";
 import { MultipleErrors } from "../errors.js";
 import { Connection, ConnectionStatuses } from "./connection.js";
 let currentInstance = 0;
-export class ConnectionPool extends EventEmitter {
+export class ConnectionPool extends TypedEventEmitter {
     #instanceId;
     #clientId;
     #closed;

package/dist/network/connection.d.ts

@@ -1,11 +1,25 @@
-import EventEmitter from 'node:events';
 import { type Socket } from 'node:net';
 import { type ConnectionOptions as TLSConnectionOptions } from 'node:tls';
 import { type CallbackWithPromise } from '../apis/callbacks.ts';
 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 { TypedEventEmitter, type TypedEvents } from '../events.ts';
+import { TimeoutError } from '../errors.ts';
 import { Writer } from '../protocol/writer.ts';
+export interface ConnectionEvents extends TypedEvents {
+    connecting: () => void;
+    timeout: (error: TimeoutError) => void;
+    error: (error: Error) => void;
+    connect: () => void;
+    ready: () => void;
+    close: () => void;
+    closing: () => void;
+    'sasl:handshake': (mechanisms: string[]) => void;
+    'sasl:authentication': (authBytes?: Buffer) => void;
+    'sasl:authentication:extended': (authBytes?: Buffer) => void;
+    drain: () => void;
+}
 export type SASLCredentialProvider<T = string> = () => T | Promise<T>;
 export interface Broker {
     host: string;
@@ -60,7 +74,7 @@ export declare const defaultOptions: {
     requestTimeout: number;
     maxInflights: number;
 };
-export declare class Connection extends EventEmitter {
+export declare class Connection extends TypedEventEmitter<ConnectionEvents> {
     #private;
     constructor(clientId?: string, options?: ConnectionOptions);
     get host(): string | undefined;

package/dist/network/connection.js

@@ -1,11 +1,11 @@
 import fastq from 'fastq';
-import EventEmitter from 'node:events';
 import { createConnection } from 'node:net';
 import { connect as createTLSConnection } from 'node:tls';
 import { createPromisifiedCallback, kCallbackPromise } from "../apis/callbacks.js";
 import { allowedSASLMechanisms, SASLMechanisms } from "../apis/enumerations.js";
 import { saslAuthenticateV2, saslHandshakeV1 } from "../apis/index.js";
 import { connectionsApiChannel, connectionsConnectsChannel, createDiagnosticContext, notifyCreation } from "../diagnostic.js";
+import { TypedEventEmitter } from "../events.js";
 import { AuthenticationError, NetworkError, TimeoutError, UnexpectedCorrelationIdError, UserError } from "../errors.js";
 import { protocolAPIsById } from "../protocol/apis.js";
 import { EMPTY_OR_SINGLE_COMPACT_LENGTH_SIZE, INT32_SIZE } from "../protocol/definitions.js";
@@ -30,7 +30,7 @@ export const defaultOptions = {
     maxInflights: 5
 };
 let currentInstance = 0;
-export class Connection extends EventEmitter {
+export class Connection extends TypedEventEmitter {
     #host;
     #port;
     #options;

package/dist/typescript-4/dist/clients/admin/admin.d.ts

@@ -5,7 +5,7 @@ import { type CallbackWithPromise } from "../../apis/callbacks";
 import { type Callback } from "../../apis/definitions";
 import { type Acl } from "../../apis/types";
 import { Base } from "../base/base";
-import { type AdminOptions, type AlterClientQuotasOptions, type AlterConfigsOptions, type AlterConsumerGroupOffsetsOptions, type BrokerLogDirDescription, type ConfigDescription, type CreateAclsOptions, type CreatedTopic, type CreatePartitionsOptions, type CreateTopicsOptions, type DeleteAclsOptions, type DeleteConsumerGroupOffsetsOptions, type DeleteGroupsOptions, type DeleteTopicsOptions, type DescribeAclsOptions, type DescribeClientQuotasOptions, type DescribeConfigsOptions, type DescribeGroupsOptions, type DescribeLogDirsOptions, type Group, type GroupBase, type IncrementalAlterConfigsOptions, type ListConsumerGroupOffsetsGroup, type ListConsumerGroupOffsetsOptions, type ListedOffsetsTopic, type ListGroupsOptions, type ListOffsetsOptions, type ListTopicsOptions, type RemoveMembersFromConsumerGroupOptions } from "./types";
+import { type AdminListOffsetsOptions, type AdminOptions, type AlterClientQuotasOptions, type AlterConfigsOptions, type AlterConsumerGroupOffsetsOptions, type BrokerLogDirDescription, type ConfigDescription, type CreateAclsOptions, type CreatedTopic, type CreatePartitionsOptions, type CreateTopicsOptions, type DeleteAclsOptions, type DeleteConsumerGroupOffsetsOptions, type DeleteGroupsOptions, type DeleteTopicsOptions, type DescribeAclsOptions, type DescribeClientQuotasOptions, type DescribeConfigsOptions, type DescribeGroupsOptions, type DescribeLogDirsOptions, type Group, type GroupBase, type IncrementalAlterConfigsOptions, type ListConsumerGroupOffsetsGroup, type ListConsumerGroupOffsetsOptions, type ListedOffsetsTopic, type ListGroupsOptions, type ListTopicsOptions, type RemoveMembersFromConsumerGroupOptions } from "./types";
 export declare class Admin extends Base<AdminOptions> {
   #private;
   constructor(options: AdminOptions);
@@ -55,6 +55,6 @@ export declare class Admin extends Base<AdminOptions> {
   describeAcls(options: DescribeAclsOptions): Promise<DescribeAclsResponseResource[]>;
   deleteAcls(options: DeleteAclsOptions, callback: CallbackWithPromise<Acl[]>): void;
   deleteAcls(options: DeleteAclsOptions): Promise<Acl[]>;
-  listOffsets(options: ListOffsetsOptions, callback: CallbackWithPromise<ListedOffsetsTopic[]>): void;
-  listOffsets(options: ListOffsetsOptions): Promise<ListedOffsetsTopic[]>;
+  listOffsets(options: AdminListOffsetsOptions, callback: CallbackWithPromise<ListedOffsetsTopic[]>): void;
+  listOffsets(options: AdminListOffsetsOptions): Promise<ListedOffsetsTopic[]>;
 }

package/dist/typescript-4/dist/clients/admin/options.d.ts

@@ -802,7 +802,7 @@ export declare const deleteAclsOptionsSchema: {
   required: string[];
   additionalProperties: boolean;
 };
-export declare const listOffsetsOptionsSchema: {
+export declare const adminListOffsetsOptionsSchema: {
   type: string;
   properties: {
     topics: {
@@ -902,6 +902,6 @@ export declare const describeAclsOptionsValidator: import("ajv").ValidateFunctio
 export declare const deleteAclsOptionsValidator: import("ajv").ValidateFunction<{
   [x: string]: {};
 }>;
-export declare const listOffsetsOptionsValidator: import("ajv").ValidateFunction<{
+export declare const adminListOffsetsOptionsValidator: import("ajv").ValidateFunction<{
   [x: string]: {};
 }>;

package/dist/typescript-4/dist/clients/admin/types.d.ts

@@ -1,16 +1,16 @@
 import { type AlterClientQuotasRequestEntry } from "../../apis/admin/alter-client-quotas-v1";
+import { type AlterConfigsRequestResource } from "../../apis/admin/alter-configs-v2";
 import { type CreatePartitionsRequestTopic } from "../../apis/admin/create-partitions-v3";
 import { type CreateTopicsRequestTopicConfig } from "../../apis/admin/create-topics-v7";
-import { type AlterConfigsRequestResource } from "../../apis/admin/alter-configs-v2";
-import { type DescribeConfigsRequestResource, type DescribeConfigsResponseConfig } from "../../apis/admin/describe-configs-v4";
 import { type DescribeClientQuotasRequestComponent } from "../../apis/admin/describe-client-quotas-v0";
+import { type DescribeConfigsRequestResource, type DescribeConfigsResponseConfig } from "../../apis/admin/describe-configs-v4";
 import { type DescribeLogDirsRequestTopic, type DescribeLogDirsResponse, type DescribeLogDirsResponseResult } from "../../apis/admin/describe-log-dirs-v4";
 import { type IncrementalAlterConfigsRequestResource } from "../../apis/admin/incremental-alter-configs-v1";
-import { type FetchIsolationLevelValue, type ConfigResourceTypeValue, type ConsumerGroupStateValue } from "../../apis/enumerations";
+import { type ConfigResourceTypeValue, type ConsumerGroupStateValue, type FetchIsolationLevelValue } from "../../apis/enumerations";
+import { type Acl, type AclFilter } from "../../apis/types";
 import { type Nullable, type NullableString } from "../../protocol/definitions";
 import { type BaseOptions } from "../base/types";
 import { type ExtendedGroupProtocolSubscription, type GroupAssignment } from "../consumer/types";
-import { type Acl, type AclFilter } from "../../apis/types";
 export interface BrokerAssignment {
   partition: number;
   brokers: number[];
@@ -173,7 +173,7 @@ export interface TopicOffsetRequest {
   name: string;
   partitions: PartitionTimestamp[];
 }
-export interface ListOffsetsOptions {
+export interface AdminListOffsetsOptions {
   topics: TopicOffsetRequest[];
   isolationLevel?: Nullable<FetchIsolationLevelValue>;
 }

package/dist/typescript-4/dist/clients/base/base.d.ts

@@ -1,10 +1,10 @@
 import { type ValidateFunction } from 'ajv';
-import { EventEmitter } from 'node:events';
 import { type CallbackWithPromise } from "../../apis/callbacks";
 import { type API, type Callback } from "../../apis/definitions";
 import { type ApiVersionsResponseApi } from "../../apis/metadata/api-versions-v3";
 import { type ClientType } from "../../diagnostic";
-import { ConnectionPool } from "../../network/connection-pool";
+import { TypedEventEmitter, type TypedEvents } from "../../events";
+import { ConnectionPool, type ConnectionPoolEventPayload } from "../../network/connection-pool";
 import { type Broker, type Connection } from "../../network/connection";
 import { kInstance } from "../../symbols";
 import { type Metrics } from "../metrics";
@@ -31,7 +31,24 @@ export declare const kFormatValidationErrors: unique symbol;
 export declare const kPrometheus: unique symbol;
 export declare const kClientType: unique symbol;
 export declare const kAfterCreate: unique symbol;
-export declare class Base<OptionsType extends BaseOptions = BaseOptions> extends EventEmitter {
+export interface BaseEvents extends TypedEvents {
+  'client:broker:connect': (payload: ConnectionPoolEventPayload) => void;
+  'client:broker:disconnect': (payload: ConnectionPoolEventPayload) => void;
+  'client:broker:failed': (payload: ConnectionPoolEventPayload) => void;
+  'client:broker:drain': (payload: ConnectionPoolEventPayload) => void;
+  'client:broker:sasl:handshake': (payload: ConnectionPoolEventPayload & {
+    mechanisms: string[];
+  }) => void;
+  'client:broker:sasl:authentication': (payload: ConnectionPoolEventPayload & {
+    authentication: Buffer;
+  }) => void;
+  'client:broker:sasl:authentication:extended': (payload: ConnectionPoolEventPayload & {
+    authentication: Buffer;
+  }) => void;
+  'client:metadata': (metadata: ClusterMetadata) => void;
+  'client:close': () => void;
+}
+export declare class Base<OptionsType extends BaseOptions = BaseOptions, EventsType extends BaseEvents = BaseEvents> extends TypedEventEmitter<EventsType> {
   #private;
   [kInstance]: number;
   [kClientId]: string;

package/dist/typescript-4/dist/clients/consumer/consumer.d.ts

@@ -1,11 +1,23 @@
 import { type CallbackWithPromise } from "../../apis/callbacks";
 import { type FetchResponse } from "../../apis/consumer/fetch-v17";
 import { type ConnectionPool } from "../../network/connection-pool";
-import { Base, kFetchConnections } from "../base/base";
+import { Base, type BaseEvents, kFetchConnections } from "../base/base";
 import { MessagesStream } from "./messages-stream";
 import { TopicsMap } from "./topics-map";
 import { type CommitOptions, type ConsumeOptions, type ConsumerGroupJoinPayload, type ConsumerGroupLeavePayload, type ConsumerGroupRebalancePayload, type ConsumerHeartbeatErrorPayload, type ConsumerHeartbeatPayload, type ConsumerOptions, type FetchOptions, type GetLagOptions, type GroupAssignment, type GroupOptions, type ListCommitsOptions, type ListOffsetsOptions, type Offsets, type OffsetsWithTimestamps } from "./types";
-export declare class Consumer<Key = Buffer, Value = Buffer, HeaderKey = Buffer, HeaderValue = Buffer> extends Base<ConsumerOptions<Key, Value, HeaderKey, HeaderValue>> {
+export interface ConsumerEvents extends BaseEvents {
+  'consumer:group:join': (payload: ConsumerGroupJoinPayload) => void;
+  'consumer:group:leave': (payload: ConsumerGroupLeavePayload) => void;
+  'consumer:group:rejoin': () => void;
+  'consumer:group:rebalance': (payload: ConsumerGroupRebalancePayload) => void;
+  'consumer:heartbeat:start': (payload?: ConsumerHeartbeatPayload) => void;
+  'consumer:heartbeat:cancel': (payload: ConsumerHeartbeatPayload) => void;
+  'consumer:heartbeat:end': (payload?: ConsumerHeartbeatPayload) => void;
+  'consumer:heartbeat:error': (payload: ConsumerHeartbeatErrorPayload) => void;
+  'consumer:lag': (lag: Offsets) => void;
+  'consumer:lag:error': (error: Error) => void;
+}
+export declare class Consumer<Key = Buffer, Value = Buffer, HeaderKey = Buffer, HeaderValue = Buffer> extends Base<ConsumerOptions<Key, Value, HeaderKey, HeaderValue>, ConsumerEvents> {
   #private;
   groupId: string;
   generationId: number;
@@ -17,61 +29,6 @@ export declare class Consumer<Key = Buffer, Value = Buffer, HeaderKey = Buffer,
   get streamsCount(): number;
   get lastHeartbeat(): Date | null;
   get coordinatorId(): number | null;
-  addListener(event: 'consumer:group:join', listener: (payload: ConsumerGroupJoinPayload) => void): this;
-  addListener(event: 'consumer:group:leave', listener: (payload: ConsumerGroupLeavePayload) => void): this;
-  addListener(event: 'consumer:group:rejoin', listener: () => void): this;
-  addListener(event: 'consumer:group:rebalance', listener: (payload: ConsumerGroupRebalancePayload) => void): this;
-  addListener(event: 'consumer:heartbeat:start', listener: (payload?: ConsumerHeartbeatPayload) => void): this;
-  addListener(event: 'consumer:heartbeat:cancel', listener: (payload: ConsumerHeartbeatPayload) => void): this;
-  addListener(event: 'consumer:heartbeat:end', listener: (payload?: ConsumerHeartbeatPayload) => void): this;
-  addListener(event: 'consumer:heartbeat:error', listener: (payload: ConsumerHeartbeatErrorPayload) => void): this;
-  addListener(event: 'consumer:lag', listener: (lag: Offsets) => void): this;
-  addListener(event: 'consumer:lag:error', listener: (error: Error) => void): this;
-  addListener(event: 'error', listener: (error: Error) => void): this;
-  on(event: 'consumer:group:join', listener: (payload: ConsumerGroupJoinPayload) => void): this;
-  on(event: 'consumer:group:leave', listener: (payload: ConsumerGroupLeavePayload) => void): this;
-  on(event: 'consumer:group:rejoin', listener: () => void): this;
-  on(event: 'consumer:group:rebalance', listener: (payload: ConsumerGroupRebalancePayload) => void): this;
-  on(event: 'consumer:heartbeat:start', listener: (payload?: ConsumerHeartbeatPayload) => void): this;
-  on(event: 'consumer:heartbeat:cancel', listener: (payload: ConsumerHeartbeatPayload) => void): this;
-  on(event: 'consumer:heartbeat:end', listener: (payload?: ConsumerHeartbeatPayload) => void): this;
-  on(event: 'consumer:heartbeat:error', listener: (payload: ConsumerHeartbeatErrorPayload) => void): this;
-  on(event: 'consumer:lag', listener: (lag: Offsets) => void): this;
-  on(event: 'consumer:lag:error', listener: (error: Error) => void): this;
-  on(event: 'error', listener: (error: Error) => void): this;
-  once(event: 'consumer:group:join', listener: (payload: ConsumerGroupJoinPayload) => void): this;
-  once(event: 'consumer:group:leave', listener: (payload: ConsumerGroupLeavePayload) => void): this;
-  once(event: 'consumer:group:rejoin', listener: () => void): this;
-  once(event: 'consumer:group:rebalance', listener: (payload: ConsumerGroupRebalancePayload) => void): this;
-  once(event: 'consumer:heartbeat:start', listener: (payload?: ConsumerHeartbeatPayload) => void): this;
-  once(event: 'consumer:heartbeat:cancel', listener: (payload: ConsumerHeartbeatPayload) => void): this;
-  once(event: 'consumer:heartbeat:end', listener: (payload?: ConsumerHeartbeatPayload) => void): this;
-  once(event: 'consumer:heartbeat:error', listener: (payload: ConsumerHeartbeatErrorPayload) => void): this;
-  once(event: 'consumer:lag', listener: (lag: Offsets) => void): this;
-  once(event: 'consumer:lag:error', listener: (error: Error) => void): this;
-  once(event: 'error', listener: (error: Error) => void): this;
-  prependListener(event: 'consumer:group:join', listener: (payload: ConsumerGroupJoinPayload) => void): this;
-  prependListener(event: 'consumer:group:leave', listener: (payload: ConsumerGroupLeavePayload) => void): this;
-  prependListener(event: 'consumer:group:rejoin', listener: () => void): this;
-  prependListener(event: 'consumer:group:rebalance', listener: (payload: ConsumerGroupRebalancePayload) => void): this;
-  prependListener(event: 'consumer:heartbeat:start', listener: (payload?: ConsumerHeartbeatPayload) => void): this;
-  prependListener(event: 'consumer:heartbeat:cancel', listener: (payload: ConsumerHeartbeatPayload) => void): this;
-  prependListener(event: 'consumer:heartbeat:end', listener: (payload?: ConsumerHeartbeatPayload) => void): this;
-  prependListener(event: 'consumer:heartbeat:error', listener: (payload: ConsumerHeartbeatErrorPayload) => void): this;
-  prependListener(event: 'consumer:lag', listener: (lag: Offsets) => void): this;
-  prependListener(event: 'consumer:lag:error', listener: (error: Error) => void): this;
-  prependListener(event: 'error', listener: (error: Error) => void): this;
-  prependOnceListener(event: 'consumer:group:join', listener: (payload: ConsumerGroupJoinPayload) => void): this;
-  prependOnceListener(event: 'consumer:group:leave', listener: (payload: ConsumerGroupLeavePayload) => void): this;
-  prependOnceListener(event: 'consumer:group:rejoin', listener: () => void): this;
-  prependOnceListener(event: 'consumer:group:rebalance', listener: (payload: ConsumerGroupRebalancePayload) => void): this;
-  prependOnceListener(event: 'consumer:heartbeat:start', listener: (payload?: ConsumerHeartbeatPayload) => void): this;
-  prependOnceListener(event: 'consumer:heartbeat:cancel', listener: (payload: ConsumerHeartbeatPayload) => void): this;
-  prependOnceListener(event: 'consumer:heartbeat:end', listener: (payload?: ConsumerHeartbeatPayload) => void): this;
-  prependOnceListener(event: 'consumer:heartbeat:error', listener: (payload: ConsumerHeartbeatErrorPayload) => void): this;
-  prependOnceListener(event: 'consumer:lag', listener: (lag: Offsets) => void): this;
-  prependOnceListener(event: 'consumer:lag:error', listener: (error: Error) => void): this;
-  prependOnceListener(event: 'error', listener: (error: Error) => void): this;
   close(force: boolean | CallbackWithPromise<void>, callback?: CallbackWithPromise<void>): void;
   close(force?: boolean): Promise<void>;
   isActive(): boolean;

package/dist/typescript-4/dist/clients/index.d.ts

@@ -1,5 +1,5 @@
 export * from "./serde";
-export * as adminClient from "./admin/index";
+export * from "./admin/index";
 export * from "./base/index";
 export * from "./consumer/index";
 export * from "./producer/index";

package/dist/typescript-4/dist/diagnostic.d.ts

@@ -36,24 +36,24 @@ export declare const instancesChannel: ChannelWithName<object>;
 export declare const connectionsConnectsChannel: TracingChannelWithName<ConnectionDiagnosticEvent<Record<string, unknown>>>;
 export declare const connectionsApiChannel: TracingChannelWithName<ConnectionDiagnosticEvent<Record<string, unknown>>>;
 export declare const connectionsPoolGetsChannel: TracingChannelWithName<ConnectionPoolDiagnosticEvent<Record<string, unknown>>>;
-export declare const baseApisChannel: TracingChannelWithName<ClientDiagnosticEvent<Base<import("./index").BaseOptions>, Record<string, unknown>>>;
-export declare const baseMetadataChannel: TracingChannelWithName<ClientDiagnosticEvent<Base<import("./index").BaseOptions>, Record<string, unknown>>>;
-export declare const adminTopicsChannel: TracingChannelWithName<ClientDiagnosticEvent<Base<import("./index").BaseOptions>, Record<string, unknown>>>;
-export declare const adminGroupsChannel: TracingChannelWithName<ClientDiagnosticEvent<Base<import("./index").BaseOptions>, Record<string, unknown>>>;
-export declare const adminClientQuotasChannel: TracingChannelWithName<ClientDiagnosticEvent<Base<import("./index").BaseOptions>, Record<string, unknown>>>;
-export declare const adminLogDirsChannel: TracingChannelWithName<ClientDiagnosticEvent<Base<import("./index").BaseOptions>, Record<string, unknown>>>;
-export declare const adminConsumerGroupOffsetsChannel: TracingChannelWithName<ClientDiagnosticEvent<Base<import("./index").BaseOptions>, Record<string, unknown>>>;
-export declare const adminConfigsChannel: TracingChannelWithName<ClientDiagnosticEvent<Base<import("./index").BaseOptions>, Record<string, unknown>>>;
-export declare const adminAclsChannel: TracingChannelWithName<ClientDiagnosticEvent<Base<import("./index").BaseOptions>, Record<string, unknown>>>;
-export declare const adminOffsetsChannel: TracingChannelWithName<ClientDiagnosticEvent<Base<import("./index").BaseOptions>, Record<string, unknown>>>;
-export declare const producerInitIdempotentChannel: TracingChannelWithName<ClientDiagnosticEvent<Base<import("./index").BaseOptions>, Record<string, unknown>>>;
-export declare const producerSendsChannel: TracingChannelWithName<ClientDiagnosticEvent<Base<import("./index").BaseOptions>, Record<string, unknown>>>;
-export declare const producerTransactionsChannel: TracingChannelWithName<ClientDiagnosticEvent<Base<import("./index").BaseOptions>, Record<string, unknown>>>;
-export declare const consumerGroupChannel: TracingChannelWithName<ClientDiagnosticEvent<Base<import("./index").BaseOptions>, Record<string, unknown>>>;
-export declare const consumerHeartbeatChannel: TracingChannelWithName<ClientDiagnosticEvent<Base<import("./index").BaseOptions>, Record<string, unknown>>>;
-export declare const consumerReceivesChannel: TracingChannelWithName<ClientDiagnosticEvent<Base<import("./index").BaseOptions>, Record<string, unknown>>>;
-export declare const consumerFetchesChannel: TracingChannelWithName<ClientDiagnosticEvent<Base<import("./index").BaseOptions>, Record<string, unknown>>>;
-export declare const consumerConsumesChannel: TracingChannelWithName<ClientDiagnosticEvent<Base<import("./index").BaseOptions>, Record<string, unknown>>>;
-export declare const consumerCommitsChannel: TracingChannelWithName<ClientDiagnosticEvent<Base<import("./index").BaseOptions>, Record<string, unknown>>>;
-export declare const consumerOffsetsChannel: TracingChannelWithName<ClientDiagnosticEvent<Base<import("./index").BaseOptions>, Record<string, unknown>>>;
-export declare const consumerLagChannel: ChannelWithName<ClientDiagnosticEvent<Base<import("./index").BaseOptions>, Record<string, unknown>>>;
+export declare const baseApisChannel: TracingChannelWithName<ClientDiagnosticEvent<Base<import("./index").BaseOptions, import("./clients/base/base").BaseEvents>, Record<string, unknown>>>;
+export declare const baseMetadataChannel: TracingChannelWithName<ClientDiagnosticEvent<Base<import("./index").BaseOptions, import("./clients/base/base").BaseEvents>, Record<string, unknown>>>;
+export declare const adminTopicsChannel: TracingChannelWithName<ClientDiagnosticEvent<Base<import("./index").BaseOptions, import("./clients/base/base").BaseEvents>, Record<string, unknown>>>;
+export declare const adminGroupsChannel: TracingChannelWithName<ClientDiagnosticEvent<Base<import("./index").BaseOptions, import("./clients/base/base").BaseEvents>, Record<string, unknown>>>;
+export declare const adminClientQuotasChannel: TracingChannelWithName<ClientDiagnosticEvent<Base<import("./index").BaseOptions, import("./clients/base/base").BaseEvents>, Record<string, unknown>>>;
+export declare const adminLogDirsChannel: TracingChannelWithName<ClientDiagnosticEvent<Base<import("./index").BaseOptions, import("./clients/base/base").BaseEvents>, Record<string, unknown>>>;
+export declare const adminConsumerGroupOffsetsChannel: TracingChannelWithName<ClientDiagnosticEvent<Base<import("./index").BaseOptions, import("./clients/base/base").BaseEvents>, Record<string, unknown>>>;
+export declare const adminConfigsChannel: TracingChannelWithName<ClientDiagnosticEvent<Base<import("./index").BaseOptions, import("./clients/base/base").BaseEvents>, Record<string, unknown>>>;
+export declare const adminAclsChannel: TracingChannelWithName<ClientDiagnosticEvent<Base<import("./index").BaseOptions, import("./clients/base/base").BaseEvents>, Record<string, unknown>>>;
+export declare const adminOffsetsChannel: TracingChannelWithName<ClientDiagnosticEvent<Base<import("./index").BaseOptions, import("./clients/base/base").BaseEvents>, Record<string, unknown>>>;
+export declare const producerInitIdempotentChannel: TracingChannelWithName<ClientDiagnosticEvent<Base<import("./index").BaseOptions, import("./clients/base/base").BaseEvents>, Record<string, unknown>>>;
+export declare const producerSendsChannel: TracingChannelWithName<ClientDiagnosticEvent<Base<import("./index").BaseOptions, import("./clients/base/base").BaseEvents>, Record<string, unknown>>>;
+export declare const producerTransactionsChannel: TracingChannelWithName<ClientDiagnosticEvent<Base<import("./index").BaseOptions, import("./clients/base/base").BaseEvents>, Record<string, unknown>>>;
+export declare const consumerGroupChannel: TracingChannelWithName<ClientDiagnosticEvent<Base<import("./index").BaseOptions, import("./clients/base/base").BaseEvents>, Record<string, unknown>>>;
+export declare const consumerHeartbeatChannel: TracingChannelWithName<ClientDiagnosticEvent<Base<import("./index").BaseOptions, import("./clients/base/base").BaseEvents>, Record<string, unknown>>>;
+export declare const consumerReceivesChannel: TracingChannelWithName<ClientDiagnosticEvent<Base<import("./index").BaseOptions, import("./clients/base/base").BaseEvents>, Record<string, unknown>>>;
+export declare const consumerFetchesChannel: TracingChannelWithName<ClientDiagnosticEvent<Base<import("./index").BaseOptions, import("./clients/base/base").BaseEvents>, Record<string, unknown>>>;
+export declare const consumerConsumesChannel: TracingChannelWithName<ClientDiagnosticEvent<Base<import("./index").BaseOptions, import("./clients/base/base").BaseEvents>, Record<string, unknown>>>;
+export declare const consumerCommitsChannel: TracingChannelWithName<ClientDiagnosticEvent<Base<import("./index").BaseOptions, import("./clients/base/base").BaseEvents>, Record<string, unknown>>>;
+export declare const consumerOffsetsChannel: TracingChannelWithName<ClientDiagnosticEvent<Base<import("./index").BaseOptions, import("./clients/base/base").BaseEvents>, Record<string, unknown>>>;
+export declare const consumerLagChannel: ChannelWithName<ClientDiagnosticEvent<Base<import("./index").BaseOptions, import("./clients/base/base").BaseEvents>, Record<string, unknown>>>;

package/dist/typescript-4/dist/events.d.ts

@@ -0,0 +1,22 @@
+import { EventEmitter } from 'node:events';
+export interface TypedEvents {
+  error: (error: Error) => void;
+}
+export declare class TypedEventEmitter<EventsType extends TypedEvents = TypedEvents> extends EventEmitter {
+  addListener<K extends keyof EventsType>(event: K, listener: EventsType[K]): this;
+  addListener(event: string | symbol, listener: (...args: any[]) => void): this;
+  on<K extends keyof EventsType>(event: K, listener: EventsType[K]): this;
+  on(event: string | symbol, listener: (...args: any[]) => void): this;
+  once<K extends keyof EventsType>(event: K, listener: EventsType[K]): this;
+  once(event: string | symbol, listener: (...args: any[]) => void): this;
+  prependListener<K extends keyof EventsType>(event: K, listener: EventsType[K]): this;
+  prependListener(event: string | symbol, listener: (...args: any[]) => void): this;
+  prependeOnceListener<K extends keyof EventsType>(event: K, listener: EventsType[K]): this;
+  prependeOnceListener(event: string | symbol, listener: (...args: any[]) => void): this;
+  off<K extends keyof EventsType>(event: K, listener: EventsType[K]): this;
+  off(event: string | symbol, listener: (...args: any[]) => void): this;
+  removeListener<K extends keyof EventsType>(event: K, listener: EventsType[K]): this;
+  removeListener(event: string | symbol, listener: (...args: any[]) => void): this;
+  removeAllListeners<K extends keyof EventsType>(event: K): this;
+  removeAllListeners(event: string | symbol): this;
+}

package/dist/typescript-4/dist/index.d.ts

@@ -1,5 +1,6 @@
 export * from "./diagnostic";
 export * from "./errors";
+export * from "./events";
 export * from "./utils";
 export * from "./network/index";
 export * from "./protocol/index";

package/dist/typescript-4/dist/network/connection-pool.d.ts

@@ -1,7 +1,27 @@
-import EventEmitter from 'node:events';
 import { type CallbackWithPromise } from "../apis/callbacks";
+import { TypedEventEmitter, type TypedEvents } from "../events";
 import { Connection, type Broker, type ConnectionOptions } from "./connection";
-export declare class ConnectionPool extends EventEmitter {
+export interface ConnectionPoolEventPayload {
+  broker: Broker;
+  connection: Connection;
+}
+export interface ConnectionPoolEvents extends TypedEvents {
+  connecting: (payload: ConnectionPoolEventPayload) => void;
+  failed: (payload: ConnectionPoolEventPayload) => void;
+  connect: (payload: ConnectionPoolEventPayload) => void;
+  'sasl:handshake': (payload: ConnectionPoolEventPayload & {
+    mechanisms: string[];
+  }) => void;
+  'sasl:authentication': (payload: ConnectionPoolEventPayload & {
+    authentication?: Buffer;
+  }) => void;
+  'sasl:authentication:extended': (payload: ConnectionPoolEventPayload & {
+    authentication?: Buffer;
+  }) => void;
+  disconnect: (payload: ConnectionPoolEventPayload) => void;
+  drain: (payload: ConnectionPoolEventPayload) => void;
+}
+export declare class ConnectionPool extends TypedEventEmitter<ConnectionPoolEvents> {
   #private;
   constructor(clientId: string, connectionOptions?: ConnectionOptions);
   get instanceId(): number;

package/dist/typescript-4/dist/network/connection.d.ts

@@ -1,11 +1,25 @@
-import EventEmitter from 'node:events';
 import { type Socket } from 'node:net';
 import { type ConnectionOptions as TLSConnectionOptions } from 'node:tls';
 import { type CallbackWithPromise } from "../apis/callbacks";
 import { type Callback, type ResponseParser } from "../apis/definitions";
 import { type SASLMechanismValue } from "../apis/enumerations";
 import { type SaslAuthenticateResponse, type SASLAuthenticationAPI } from "../apis/security/sasl-authenticate-v2";
+import { TypedEventEmitter, type TypedEvents } from "../events";
+import { TimeoutError } from "../errors";
 import { Writer } from "../protocol/writer";
+export interface ConnectionEvents extends TypedEvents {
+  connecting: () => void;
+  timeout: (error: TimeoutError) => void;
+  error: (error: Error) => void;
+  connect: () => void;
+  ready: () => void;
+  close: () => void;
+  closing: () => void;
+  'sasl:handshake': (mechanisms: string[]) => void;
+  'sasl:authentication': (authBytes?: Buffer) => void;
+  'sasl:authentication:extended': (authBytes?: Buffer) => void;
+  drain: () => void;
+}
 export type SASLCredentialProvider<T = string> = () => T | Promise<T>;
 export interface Broker {
   host: string;
@@ -60,7 +74,7 @@ export declare const defaultOptions: {
   requestTimeout: number;
   maxInflights: number;
 };
-export declare class Connection extends EventEmitter {
+export declare class Connection extends TypedEventEmitter<ConnectionEvents> {
   #private;
   constructor(clientId?: string, options?: ConnectionOptions);
   get host(): string | undefined;

package/dist/version.js

@@ -1,2 +1,2 @@
 export const name = "@platformatic/kafka";
-export const version = "1.24.0";
+export const version = "1.25.0";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@platformatic/kafka",
-  "version": "1.24.0",
+  "version": "1.25.0",
   "description": "Modern and performant client for Apache Kafka",
   "homepage": "https://github.com/platformatic/kafka",
   "author": "Platformatic Inc. <oss@platformatic.dev> (https://platformatic.dev)",