@platformatic/kafka 1.22.0 → 1.23.0

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

@@ -0,0 +1,3 @@
+import { type ClusterMetadata } from "../base/types";
+import { type ExtendedGroupProtocolSubscription, type GroupPartitionsAssignments } from "./types";
+export declare function roundRobinAssigner(_current: string, members: Map<string, ExtendedGroupProtocolSubscription>, topics: Set<string>, metadata: ClusterMetadata): GroupPartitionsAssignments[];

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

@@ -0,0 +1,11 @@
+import { type Gauge } from "../metrics";
+export declare class TopicsMap extends Map<string, number> {
+  #private;
+  get current(): string[];
+  clear(): void;
+  track(topic: string): boolean;
+  trackAll(...topics: string[]): boolean[];
+  untrack(topic: string): boolean;
+  untrackAll(...topics: string[]): boolean[];
+  setMetric(metric: Gauge): void;
+}

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

@@ -0,0 +1,100 @@
+import { type FetchRequestTopic } from "../../apis/consumer/fetch-v17";
+import { type FetchIsolationLevel, type GroupProtocols } from "../../apis/enumerations";
+import { type KafkaRecord, type Message } from "../../protocol/records";
+import { type BaseOptions, type ClusterMetadata, type TopicWithPartitionAndOffset } from "../base/types";
+import { type Deserializers } from "../serde";
+export interface GroupProtocolSubscription {
+  name: string;
+  version: number;
+  metadata?: Buffer | string;
+}
+export interface GroupAssignment {
+  topic: string;
+  partitions: number[];
+}
+export interface GroupPartitionsAssignments {
+  memberId: string;
+  assignments: Map<string, GroupAssignment>;
+}
+export interface ExtendedGroupProtocolSubscription extends Omit<GroupProtocolSubscription, 'name'> {
+  topics?: string[];
+  memberId: string;
+}
+export type Offsets = Map<string, bigint[]>;
+export type OffsetsWithTimestamps = Map<string, Map<number, {
+  offset: bigint;
+  timestamp: bigint;
+}>>;
+export type CorruptedMessageHandler = (record: KafkaRecord, topic: string, partition: number, firstTimestamp: bigint, firstOffset: bigint, commit: Message['commit']) => boolean;
+export type GroupPartitionsAssigner = (current: string, members: Map<string, ExtendedGroupProtocolSubscription>, topics: Set<string>, metadata: ClusterMetadata) => GroupPartitionsAssignments[];
+export declare const MessagesStreamModes: {
+  readonly LATEST: "latest";
+  readonly EARLIEST: "earliest";
+  readonly COMMITTED: "committed";
+  readonly MANUAL: "manual";
+};
+export declare const allowedMessagesStreamModes: MessagesStreamModeValue[];
+export type MessagesStreamMode = keyof typeof MessagesStreamModes;
+export type MessagesStreamModeValue = (typeof MessagesStreamModes)[keyof typeof MessagesStreamModes];
+export declare const MessagesStreamFallbackModes: {
+  readonly LATEST: "latest";
+  readonly EARLIEST: "earliest";
+  readonly FAIL: "fail";
+};
+export declare const allowedMessagesStreamFallbackModes: MessagesStreamFallbackModeValue[];
+export type MessagesStreamFallbackMode = keyof typeof MessagesStreamFallbackModes;
+export type MessagesStreamFallbackModeValue = (typeof MessagesStreamFallbackModes)[keyof typeof MessagesStreamFallbackModes];
+export interface GroupOptions {
+  groupProtocol?: typeof GroupProtocols.CLASSIC;
+  sessionTimeout?: number;
+  rebalanceTimeout?: number;
+  heartbeatInterval?: number;
+  protocols?: GroupProtocolSubscription[];
+  partitionAssigner?: GroupPartitionsAssigner;
+}
+export interface ConsumerGroupOptions {
+  groupProtocol: typeof GroupProtocols.CONSUMER;
+  groupRemoteAssignor?: string;
+  rebalanceTimeout?: number;
+}
+export interface ConsumeBaseOptions<Key, Value, HeaderKey, HeaderValue> {
+  autocommit?: boolean | number;
+  minBytes?: number;
+  maxBytes?: number;
+  maxWaitTime?: number;
+  isolationLevel?: FetchIsolationLevel;
+  deserializers?: Partial<Deserializers<Key, Value, HeaderKey, HeaderValue>>;
+  highWaterMark?: number;
+}
+export interface StreamOptions {
+  topics: string[];
+  mode?: MessagesStreamModeValue;
+  fallbackMode?: MessagesStreamFallbackModeValue;
+  maxFetches?: number;
+  offsets?: TopicWithPartitionAndOffset[];
+  onCorruptedMessage?: CorruptedMessageHandler;
+}
+export type ConsumeOptions<Key, Value, HeaderKey, HeaderValue> = StreamOptions & ConsumeBaseOptions<Key, Value, HeaderKey, HeaderValue> & GroupOptions;
+export type ConsumerOptions<Key, Value, HeaderKey, HeaderValue> = BaseOptions & {
+  groupId: string;
+} & (GroupOptions | ConsumerGroupOptions) & ConsumeBaseOptions<Key, Value, HeaderKey, HeaderValue>;
+export type FetchOptions<Key, Value, HeaderKey, HeaderValue> = Pick<ConsumeBaseOptions<Key, Value, HeaderKey, HeaderValue>, 'minBytes' | 'maxBytes' | 'maxWaitTime' | 'isolationLevel'> & {
+  node: number;
+  topics: FetchRequestTopic[];
+};
+export interface CommitOptionsPartition extends TopicWithPartitionAndOffset {
+  leaderEpoch: number;
+}
+export interface CommitOptions {
+  offsets: CommitOptionsPartition[];
+}
+export interface ListCommitsOptions {
+  topics: GroupAssignment[];
+}
+export interface ListOffsetsOptions {
+  topics: string[];
+  partitions?: Record<string, number[]>;
+  timestamp?: bigint;
+  isolationLevel?: FetchIsolationLevel;
+}
+export type GetLagOptions = Omit<ListOffsetsOptions, 'timestamp' | 'isolationLevel'>;

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

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

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

@@ -0,0 +1,60 @@
+type RegistryContentType = 'application/openmetrics-text; version=1.0.0; charset=utf-8' | 'text/plain; version=0.0.4; charset=utf-8';
+export interface Metric {
+  name?: string;
+  get(): Promise<unknown>;
+  reset: () => void;
+  labels(labels: any): any;
+}
+export interface Counter extends Metric {
+  inc: (value?: number) => void;
+}
+export interface Gauge extends Metric {
+  inc: (value?: number) => void;
+  dec: (value?: number) => void;
+}
+export interface Histogram extends Metric {
+  observe: (value: number) => void;
+}
+export interface Summary {}
+export interface Registry {
+  getSingleMetric: (name: string) => Counter | Gauge | Histogram | any;
+  metrics(): Promise<string>;
+  clear(): void;
+  resetMetrics(): void;
+  registerMetric(metric: Metric): void;
+  getMetricsAsJSON(): Promise<any>;
+  getMetricsAsArray(): any[];
+  removeSingleMetric(name: string): void;
+  setDefaultLabels(labels: object): void;
+  getSingleMetricAsString(name: string): Promise<string>;
+  readonly contentType: RegistryContentType;
+  setContentType(contentType: RegistryContentType): void;
+}
+export interface Prometheus {
+  Counter: new (options: {
+    name: string;
+    help: string;
+    registers: Registry[];
+    labelNames?: string[];
+  }) => Counter;
+  Gauge: new (options: {
+    name: string;
+    help: string;
+    registers: Registry[];
+    labelNames?: string[];
+  }) => Gauge;
+  Histogram: new (options: {
+    name: string;
+    help: string;
+    registers: Registry[];
+    labelNames?: string[];
+  }) => Histogram;
+  Registry: new (contentType?: string) => Registry;
+}
+export interface Metrics {
+  registry: Registry;
+  client: Prometheus;
+  labels?: Record<string, any>;
+}
+export declare function ensureMetric<MetricType extends Metric>(metrics: Metrics, type: 'Gauge' | 'Counter' | 'Histogram', name: string, help: string): MetricType;
+export {};

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

@@ -0,0 +1,3 @@
+export * from "./options";
+export * from "./producer";
+export * from "./types";

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

@@ -0,0 +1,164 @@
+export declare const produceOptionsProperties: {
+  producerId: {
+    bigint: boolean;
+  };
+  producerEpoch: {
+    type: string;
+  };
+  idempotent: {
+    type: string;
+  };
+  acks: {
+    type: string;
+    enumeration: {
+      allowed: number[];
+      errorMessage: string;
+    };
+  };
+  compression: {
+    type: string;
+    enumeration: {
+      allowed: import("../../protocol/compression").CompressionAlgorithmValue[];
+      errorMessage: string;
+    };
+  };
+  partitioner: {
+    function: boolean;
+  };
+  autocreateTopics: {
+    type: string;
+  };
+  repeatOnStaleMetadata: {
+    type: string;
+  };
+};
+export declare const produceOptionsSchema: {
+  type: string;
+  properties: {
+    producerId: {
+      bigint: boolean;
+    };
+    producerEpoch: {
+      type: string;
+    };
+    idempotent: {
+      type: string;
+    };
+    acks: {
+      type: string;
+      enumeration: {
+        allowed: number[];
+        errorMessage: string;
+      };
+    };
+    compression: {
+      type: string;
+      enumeration: {
+        allowed: import("../../protocol/compression").CompressionAlgorithmValue[];
+        errorMessage: string;
+      };
+    };
+    partitioner: {
+      function: boolean;
+    };
+    autocreateTopics: {
+      type: string;
+    };
+    repeatOnStaleMetadata: {
+      type: string;
+    };
+  };
+  additionalProperties: boolean;
+};
+export declare const produceOptionsValidator: import("ajv").ValidateFunction<unknown>;
+export declare const producerOptionsValidator: import("ajv").ValidateFunction<unknown>;
+export declare const sendOptionsSchema: {
+  type: string;
+  properties: {
+    producerId: {
+      bigint: boolean;
+    };
+    producerEpoch: {
+      type: string;
+    };
+    idempotent: {
+      type: string;
+    };
+    acks: {
+      type: string;
+      enumeration: {
+        allowed: number[];
+        errorMessage: string;
+      };
+    };
+    compression: {
+      type: string;
+      enumeration: {
+        allowed: import("../../protocol/compression").CompressionAlgorithmValue[];
+        errorMessage: string;
+      };
+    };
+    partitioner: {
+      function: boolean;
+    };
+    autocreateTopics: {
+      type: string;
+    };
+    repeatOnStaleMetadata: {
+      type: string;
+    };
+    messages: {
+      type: string;
+      items: {
+        type: string;
+        properties: {
+          key: {
+            oneOf: ({
+              type: string;
+              buffer?: undefined;
+            } | {
+              buffer: boolean;
+              type?: undefined;
+            })[];
+          };
+          value: {
+            oneOf: ({
+              type: string;
+              buffer?: undefined;
+            } | {
+              buffer: boolean;
+              type?: undefined;
+            })[];
+          };
+          headers: {
+            anyOf: ({
+              map: boolean;
+              type?: undefined;
+              additionalProperties?: undefined;
+            } | {
+              type: string;
+              additionalProperties: boolean;
+              map?: undefined;
+            })[];
+          };
+          topic: {
+            type: string;
+          };
+          partition: {
+            type: string;
+          };
+          timestamp: {
+            bigint: boolean;
+          };
+        };
+        required: string[];
+        additionalProperties: boolean;
+      };
+    };
+  };
+  required: string[];
+  additionalProperties: boolean;
+};
+export declare const sendOptionsValidator: import("ajv").ValidateFunction<{
+  [x: string]: {};
+}>;

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

@@ -0,0 +1,16 @@
+import { type CallbackWithPromise } from "../../apis/callbacks";
+import { Base } from "../base/base";
+import { type ProduceOptions, type ProduceResult, type ProducerInfo, type ProducerOptions, type SendOptions } from "./types";
+export declare function noopSerializer(data?: Buffer): Buffer | undefined;
+export declare class Producer<Key = Buffer, Value = Buffer, HeaderKey = Buffer, HeaderValue = Buffer> extends Base<ProducerOptions<Key, Value, HeaderKey, HeaderValue>> {
+  #private;
+  constructor(options: ProducerOptions<Key, Value, HeaderKey, HeaderValue>);
+  get producerId(): bigint | undefined;
+  get producerEpoch(): number | undefined;
+  close(callback: CallbackWithPromise<void>): void;
+  close(): Promise<void>;
+  initIdempotentProducer(options: ProduceOptions<Key, Value, HeaderKey, HeaderValue>, callback: CallbackWithPromise<ProducerInfo>): void;
+  initIdempotentProducer(options: ProduceOptions<Key, Value, HeaderKey, HeaderValue>): Promise<ProducerInfo>;
+  send(options: SendOptions<Key, Value, HeaderKey, HeaderValue>, callback: CallbackWithPromise<ProduceResult>): void;
+  send(options: SendOptions<Key, Value, HeaderKey, HeaderValue>): Promise<ProduceResult>;
+}

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

@@ -0,0 +1,29 @@
+import { type CompressionAlgorithmValue } from "../../protocol/compression";
+import { type MessageToProduce } from "../../protocol/records";
+import { type BaseOptions, type TopicWithPartitionAndOffset } from "../base/types";
+import { type Serializers } from "../serde";
+export interface ProducerInfo {
+  producerId: bigint;
+  producerEpoch: number;
+}
+export interface ProduceResult {
+  offsets?: TopicWithPartitionAndOffset[];
+  unwritableNodes?: number[];
+}
+export type Partitioner<Key, Value, HeaderKey, HeaderValue> = (message: MessageToProduce<Key, Value, HeaderKey, HeaderValue>) => number;
+export interface ProduceOptions<Key, Value, HeaderKey, HeaderValue> {
+  producerId?: bigint;
+  producerEpoch?: number;
+  idempotent?: boolean;
+  acks?: number;
+  compression?: CompressionAlgorithmValue;
+  partitioner?: Partitioner<Key, Value, HeaderKey, HeaderValue>;
+  autocreateTopics?: boolean;
+  repeatOnStaleMetadata?: boolean;
+}
+export type ProducerOptions<Key, Value, HeaderKey, HeaderValue> = BaseOptions & ProduceOptions<Key, Value, HeaderKey, HeaderValue> & {
+  serializers?: Partial<Serializers<Key, Value, HeaderKey, HeaderValue>>;
+};
+export type SendOptions<Key, Value, HeaderKey, HeaderValue> = {
+  messages: MessageToProduce<Key, Value, HeaderKey, HeaderValue>[];
+} & ProduceOptions<Key, Value, HeaderKey, HeaderValue>;

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

@@ -0,0 +1,42 @@
+export type Serializer<InputType = unknown> = (data?: InputType) => Buffer | undefined;
+export type Deserializer<OutputType = unknown> = (data?: Buffer) => OutputType | undefined;
+export type SerializerWithHeaders<InputType = unknown, HeaderKey = unknown, HeaderValue = unknown> = (data?: InputType, headers?: Map<HeaderKey, HeaderValue>) => Buffer | undefined;
+export type DeserializerWithHeaders<OutputType = unknown, HeaderKey = unknown, HeaderValue = unknown> = (data?: Buffer, headers?: Map<HeaderKey, HeaderValue>) => OutputType | undefined;
+export interface Serializers<Key, Value, HeaderKey, HeaderValue> {
+  key: SerializerWithHeaders<Key, HeaderKey, HeaderValue>;
+  value: SerializerWithHeaders<Value, HeaderKey, HeaderValue>;
+  headerKey: Serializer<HeaderKey>;
+  headerValue: Serializer<HeaderValue>;
+}
+export interface Deserializers<Key, Value, HeaderKey, HeaderValue> {
+  key: DeserializerWithHeaders<Key>;
+  value: DeserializerWithHeaders<Value>;
+  headerKey: Deserializer<HeaderKey>;
+  headerValue: Deserializer<HeaderValue>;
+}
+export declare function stringSerializer(data?: string): Buffer | undefined;
+export declare function stringDeserializer(data?: string | Buffer): string | undefined;
+export declare function jsonSerializer<T = Record<string, any>>(data?: T): Buffer | undefined;
+export declare function jsonDeserializer<T = Record<string, any>>(data?: string | Buffer): T | undefined;
+export declare function serializersFrom<T>(serializer: Serializer<T>): Serializers<T, T, T, T>;
+export declare function deserializersFrom<T>(deserializer: Deserializer<T>): Deserializers<T, T, T, T>;
+export declare const serdeProperties: {
+  type: string;
+  properties: {
+    key: {
+      function: boolean;
+    };
+    value: {
+      function: boolean;
+    };
+    headerKey: {
+      function: boolean;
+    };
+    headerValue: {
+      function: boolean;
+    };
+  };
+  additionalProperties: boolean;
+};
+export declare const stringSerializers: Serializers<string, string, string, string>;
+export declare const stringDeserializers: Deserializers<string, string, string, string>;

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

@@ -0,0 +1,54 @@
+import { type Channel, type TracingChannel } from 'node:diagnostics_channel';
+import { type Base } from "./clients/base/base";
+import { type ConnectionPool } from "./network/connection-pool";
+import { type Connection } from "./network/connection";
+export type ClientType = 'base' | 'producer' | 'consumer' | 'admin';
+export interface CreationEvent<InstanceType> {
+  type: ClientType | 'connection' | 'connectionPool';
+  instance: InstanceType;
+}
+export type ConnectionDiagnosticEvent<Attributes = Record<string, unknown>> = {
+  connection: Connection;
+} & Attributes;
+export type ConnectionPoolDiagnosticEvent<Attributes = Record<string, unknown>> = {
+  connectionPool: ConnectionPool;
+} & Attributes;
+export type ClientDiagnosticEvent<InstanceType extends Base = Base, Attributes = Record<string, unknown>> = {
+  client: InstanceType;
+} & Attributes;
+export type ChannelWithName<EventType extends object> = Channel<string, EventType> & {
+  name: string;
+};
+export type TracingChannelWithName<EventType extends object> = TracingChannel<string, EventType> & {
+  name: string;
+};
+export type DiagnosticContext<BaseContext = {}> = BaseContext & {
+  operationId: bigint;
+  result?: unknown;
+  error?: unknown;
+};
+export declare const channelsNamespace: "plt:kafka";
+export declare function createDiagnosticContext<BaseContext = {}>(context: BaseContext): DiagnosticContext<BaseContext>;
+export declare function notifyCreation<InstanceType>(type: ClientType | 'connection' | 'connection-pool' | 'messages-stream', instance: InstanceType): void;
+export declare function createChannel<DiagnosticEvent extends object>(name: string): ChannelWithName<DiagnosticEvent>;
+export declare function createTracingChannel<DiagnosticEvent extends object>(name: string): TracingChannelWithName<DiagnosticEvent>;
+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 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 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>>>;

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

@@ -0,0 +1,83 @@
+import { type NullableString } from "./protocol/definitions";
+declare const kGenericError: unique symbol;
+declare const kMultipleErrors: unique symbol;
+export declare const ERROR_PREFIX = "PLT_KFK_";
+export declare const errorCodes: readonly ["PLT_KFK_AUTHENTICATION", "PLT_KFK_MULTIPLE", "PLT_KFK_NETWORK", "PLT_KFK_OUT_OF_BOUNDS", "PLT_KFK_PROTOCOL", "PLT_KFK_RESPONSE", "PLT_KFK_TIMEOUT", "PLT_KFK_UNEXPECTED_CORRELATION_ID", "PLT_KFK_UNFINISHED_WRITE_BUFFER", "PLT_KFK_UNSUPPORTED_API", "PLT_KFK_UNSUPPORTED_COMPRESSION", "PLT_KFK_UNSUPPORTED", "PLT_KFK_USER"];
+export type ErrorCode = (typeof errorCodes)[number];
+export type ErrorProperties = {
+  cause?: Error;
+} & Record<string, any>;
+export declare class GenericError extends Error {
+  code: string;
+  [index: string]: any;
+  [kGenericError]: true;
+  static isGenericError(error: Error): error is GenericError | MultipleErrors;
+  constructor(code: ErrorCode, message: string, {
+    cause,
+    ...rest
+  }?: ErrorProperties);
+  findBy<ErrorType extends GenericError = GenericError>(property: string, value: unknown): ErrorType | null;
+}
+export declare class MultipleErrors extends AggregateError {
+  code: string;
+  [index: string]: any;
+  [kGenericError]: true;
+  [kMultipleErrors]: true;
+  static code: ErrorCode;
+  static isGenericError(error: Error): error is GenericError | MultipleErrors;
+  static isMultipleErrors(error: Error): error is MultipleErrors;
+  constructor(message: string, errors: Error[], {
+    cause,
+    ...rest
+  }?: ErrorProperties);
+  findBy<ErrorType extends GenericError | MultipleErrors = MultipleErrors>(property: string, value: unknown): ErrorType | null;
+}
+export * from "./protocol/errors";
+export declare class AuthenticationError extends GenericError {
+  static code: ErrorCode;
+  constructor(message: string, properties?: ErrorProperties);
+}
+export declare class NetworkError extends GenericError {
+  static code: ErrorCode;
+  constructor(message: string, properties?: ErrorProperties);
+}
+export declare class ProtocolError extends GenericError {
+  static code: ErrorCode;
+  constructor(codeOrId: string | number, serverErrorMessage?: NullableString, properties?: ErrorProperties, response?: unknown);
+}
+export declare class OutOfBoundsError extends GenericError {
+  static code: ErrorCode;
+  constructor(message: string, properties?: ErrorProperties);
+}
+export declare class ResponseError extends MultipleErrors {
+  static code: ErrorCode;
+  constructor(apiName: number, apiVersion: number, errors: Record<string, [number, NullableString]>, response: unknown, properties?: ErrorProperties);
+}
+export declare class TimeoutError extends GenericError {
+  static code: ErrorCode;
+  constructor(message: string, properties?: ErrorProperties);
+}
+export declare class UnexpectedCorrelationIdError extends GenericError {
+  static code: ErrorCode;
+  constructor(message: string, properties?: ErrorProperties);
+}
+export declare class UnfinishedWriteBufferError extends GenericError {
+  static code: ErrorCode;
+  constructor(message: string, properties?: ErrorProperties);
+}
+export declare class UnsupportedApiError extends GenericError {
+  static code: ErrorCode;
+  constructor(message: string, properties?: ErrorProperties);
+}
+export declare class UnsupportedCompressionError extends GenericError {
+  static code: ErrorCode;
+  constructor(message: string, properties?: ErrorProperties);
+}
+export declare class UnsupportedError extends GenericError {
+  static code: ErrorCode;
+  constructor(message: string, properties?: ErrorProperties);
+}
+export declare class UserError extends GenericError {
+  static code: ErrorCode;
+  constructor(message: string, properties?: ErrorProperties);
+}

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

@@ -0,0 +1,7 @@
+export * from "./diagnostic";
+export * from "./errors";
+export * from "./utils";
+export * from "./network/index";
+export * from "./protocol/index";
+export * from "./apis/index";
+export * from "./clients/index";

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

@@ -0,0 +1,16 @@
+import EventEmitter from 'node:events';
+import { type CallbackWithPromise } from "../apis/callbacks";
+import { Connection, type Broker, type ConnectionOptions } from "./connection";
+export declare class ConnectionPool extends EventEmitter {
+  #private;
+  constructor(clientId: string, connectionOptions?: ConnectionOptions);
+  get instanceId(): number;
+  get(broker: Broker, callback: CallbackWithPromise<Connection>): void;
+  get(broker: Broker): Promise<Connection>;
+  getFirstAvailable(brokers: Broker[], callback: CallbackWithPromise<Connection>): void;
+  getFirstAvailable(brokers: Broker[]): Promise<Connection>;
+  close(callback: CallbackWithPromise<void>): void;
+  close(): Promise<void>;
+  isActive(): boolean;
+  isConnected(): boolean;
+}