@platformatic/kafka 1.23.0 → 1.24.0

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

@@ -1,11 +1,16 @@
 import { type AlterClientQuotasRequestEntry } from "../../apis/admin/alter-client-quotas-v1";
+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 DescribeLogDirsRequestTopic, type DescribeLogDirsResponse, type DescribeLogDirsResponseResult } from "../../apis/admin/describe-log-dirs-v4";
-import { type ConsumerGroupState } from "../../apis/enumerations";
+import { type IncrementalAlterConfigsRequestResource } from "../../apis/admin/incremental-alter-configs-v1";
+import { type FetchIsolationLevelValue, type ConfigResourceTypeValue, type ConsumerGroupStateValue } from "../../apis/enumerations";
 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[];
@@ -27,7 +32,7 @@ export interface GroupMember {
 }
 export interface GroupBase {
   id: string;
-  state: ConsumerGroupState;
+  state: ConsumerGroupStateValue;
   groupType: string;
   protocolType: string;
 }
@@ -50,8 +55,12 @@ export interface ListTopicsOptions {
 export interface DeleteTopicsOptions {
   topics: string[];
 }
+export interface CreatePartitionsOptions {
+  topics: CreatePartitionsRequestTopic[];
+  validateOnly?: boolean;
+}
 export interface ListGroupsOptions {
-  states?: ConsumerGroupState[];
+  states?: ConsumerGroupStateValue[];
   types?: string[];
 }
 export interface DescribeGroupsOptions {
@@ -85,4 +94,97 @@ export interface BrokerLogDirDescription {
   throttleTimeMs: DescribeLogDirsResponse['throttleTimeMs'];
   results: Omit<DescribeLogDirsResponseResult, 'errorCode'>[];
 }
+interface GroupWithTopicPartitions {
+  groupId: string;
+  topics?: Nullable<{
+    name: string;
+    partitionIndexes: number[];
+  }[]>;
+}
+export interface ListConsumerGroupOffsetsOptions {
+  groups: (string | GroupWithTopicPartitions)[];
+  requireStable?: boolean;
+}
+interface ListConsumerGroupOffsetsPartition {
+  partitionIndex: number;
+  committedOffset: bigint;
+  committedLeaderEpoch: number;
+  metadata: NullableString;
+}
+interface ListConsumerGroupOffsetsTopic {
+  name: string;
+  partitions: ListConsumerGroupOffsetsPartition[];
+}
+export interface ListConsumerGroupOffsetsGroup {
+  groupId: string;
+  topics: ListConsumerGroupOffsetsTopic[];
+}
+interface PartitionOffset {
+  partition: number;
+  offset: bigint;
+}
+interface AlterConsumerGroupOffsetsTopic {
+  name: string;
+  partitionOffsets: PartitionOffset[];
+}
+export interface AlterConsumerGroupOffsetsOptions {
+  groupId: string;
+  topics: AlterConsumerGroupOffsetsTopic[];
+}
+export interface DeleteConsumerGroupOffsetsOptions {
+  groupId: string;
+  topics: {
+    name: string;
+    partitionIndexes: number[];
+  }[];
+}
+export interface DescribeConfigsOptions {
+  resources: DescribeConfigsRequestResource[];
+  includeSynonyms?: boolean;
+  includeDocumentation?: boolean;
+}
+export interface ConfigDescription {
+  resourceType: ConfigResourceTypeValue;
+  resourceName: string;
+  configs: DescribeConfigsResponseConfig[];
+}
+export interface AlterConfigsOptions {
+  resources: AlterConfigsRequestResource[];
+  validateOnly?: boolean;
+}
+export interface IncrementalAlterConfigsOptions {
+  resources: IncrementalAlterConfigsRequestResource[];
+  validateOnly?: boolean;
+}
+export interface CreateAclsOptions {
+  creations: Acl[];
+}
+export interface DescribeAclsOptions {
+  filter: AclFilter;
+}
+export interface DeleteAclsOptions {
+  filters: AclFilter[];
+}
+export interface PartitionTimestamp {
+  partitionIndex: number;
+  timestamp: bigint;
+}
+export interface TopicOffsetRequest {
+  name: string;
+  partitions: PartitionTimestamp[];
+}
+export interface ListOffsetsOptions {
+  topics: TopicOffsetRequest[];
+  isolationLevel?: Nullable<FetchIsolationLevelValue>;
+}
+export interface ListedOffsetsPartition {
+  partitionIndex: number;
+  timestamp: bigint;
+  offset: bigint;
+  leaderEpoch: number;
+}
+export interface ListedOffsetsTopic {
+  name: string;
+  partitions: ListedOffsetsPartition[];
+}
 export {};

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

@@ -92,7 +92,7 @@ export declare const baseOptionsSchema: {
       properties: {
         mechanism: {
           type: string;
-          enum: import("../../apis/enumerations").SASLMechanismValue[];
+          enum: ("PLAIN" | "SCRAM-SHA-256" | "SCRAM-SHA-512" | "OAUTHBEARER" | "GSSAPI")[];
         };
         username: {
           oneOf: ({
@@ -185,14 +185,11 @@ export declare const metadataOptionsSchema: {
       minimum: number;
     };
   };
-  required: string[];
   additionalProperties: boolean;
 };
 export declare const baseOptionsValidator: import("ajv").ValidateFunction<{
   [x: string]: {};
 }>;
-export declare const metadataOptionsValidator: import("ajv").ValidateFunction<{
-  [x: string]: {};
-}>;
+export declare const metadataOptionsValidator: import("ajv").ValidateFunction<unknown>;
 export declare const defaultPort = 9092;
 export declare const defaultBaseOptions: Partial<BaseOptions>;

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

@@ -1,4 +1,5 @@
 import { type Broker, type ConnectionOptions } from "../../network/connection";
+import { type NullableString } from "../../protocol/definitions";
 import { type Metrics } from "../metrics";
 export interface TopicWithPartitionAndOffset {
   topic: string;
@@ -9,6 +10,8 @@ export interface ClusterPartitionMetadata {
   leader: number;
   leaderEpoch: number;
   replicas: number[];
+  isr: number[];
+  offlineReplicas: number[];
 }
 export interface ClusterTopicMetadata {
   id: string;
@@ -16,9 +19,12 @@ export interface ClusterTopicMetadata {
   partitionsCount: number;
   lastUpdate: number;
 }
+export interface BrokerWithRack extends Broker {
+  rack: NullableString;
+}
 export interface ClusterMetadata {
   id: string;
-  brokers: Map<number, Broker>;
+  brokers: Map<number, BrokerWithRack>;
   controllerId: number;
   topics: Map<string, ClusterTopicMetadata>;
   lastUpdate: number;
@@ -35,7 +41,7 @@ export interface BaseOptions extends ConnectionOptions {
   metrics?: Metrics;
 }
 export interface MetadataOptions {
-  topics: string[];
+  topics?: string[];
   autocreateTopics?: boolean;
   forceUpdate?: boolean;
   metadataMaxAge?: number;

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

@@ -4,7 +4,7 @@ import { type ConnectionPool } from "../../network/connection-pool";
 import { Base, kFetchConnections } from "../base/base";
 import { MessagesStream } from "./messages-stream";
 import { TopicsMap } from "./topics-map";
-import { type CommitOptions, type ConsumeOptions, type ConsumerOptions, type FetchOptions, type GetLagOptions, type GroupAssignment, type GroupOptions, type ListCommitsOptions, type ListOffsetsOptions, type Offsets, type OffsetsWithTimestamps } from "./types";
+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>> {
   #private;
   groupId: string;
@@ -16,6 +16,62 @@ export declare class Consumer<Key = Buffer, Value = Buffer, HeaderKey = Buffer,
   constructor(options: ConsumerOptions<Key, Value, HeaderKey, HeaderValue>);
   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;
@@ -38,7 +94,7 @@ export declare class Consumer<Key = Buffer, Value = Buffer, HeaderKey = Buffer,
   findGroupCoordinator(callback: CallbackWithPromise<number>): void;
   findGroupCoordinator(): Promise<number>;
   joinGroup(options: GroupOptions, callback: CallbackWithPromise<string>): void;
-  joinGroup(options: GroupOptions): Promise<string>;
+  joinGroup(options?: GroupOptions): Promise<string>;
   leaveGroup(force?: boolean | CallbackWithPromise<void>, callback?: CallbackWithPromise<void>): void;
   leaveGroup(force?: boolean): Promise<void>;
 }

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

@@ -11,6 +11,7 @@ export declare class MessagesStream<Key, Value, HeaderKey, HeaderValue> extends
   #private;
   [kInstance]: number;
   constructor(consumer: Consumer<Key, Value, HeaderKey, HeaderValue>, options: ConsumeOptions<Key, Value, HeaderKey, HeaderValue>);
+  get consumer(): Consumer<Key, Value, HeaderKey, HeaderValue>;
   get offsetsToFetch(): Map<string, bigint>;
   get offsetsToCommit(): Map<string, CommitOptionsPartition>;
   get offsetsCommitted(): Map<string, bigint>;

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

@@ -99,7 +99,7 @@ export declare const consumeOptionsProperties: {
   };
   isolationLevel: {
     type: string;
-    enum: number[];
+    enum: (0 | 1)[];
   };
   deserializers: {
     type: string;
@@ -209,7 +209,7 @@ export declare const consumeOptionsSchema: {
     };
     isolationLevel: {
       type: string;
-      enum: number[];
+      enum: (0 | 1)[];
     };
     deserializers: {
       type: string;
@@ -360,7 +360,7 @@ export declare const consumerOptionsSchema: {
     };
     isolationLevel: {
       type: string;
-      enum: number[];
+      enum: (0 | 1)[];
     };
     deserializers: {
       type: string;
@@ -471,7 +471,7 @@ export declare const fetchOptionsSchema: {
     };
     isolationLevel: {
       type: string;
-      enum: number[];
+      enum: (0 | 1)[];
     };
     deserializers: {
       type: string;
@@ -673,7 +673,7 @@ export declare const listOffsetsOptionsSchema: {
     };
     isolationLevel: {
       type: string;
-      enum: number[];
+      enum: (0 | 1)[];
     };
     timestamp: {
       bigint: boolean;
@@ -743,6 +743,6 @@ export declare const defaultConsumerOptions: {
   minBytes: number;
   maxBytes: number;
   maxWaitTime: number;
-  isolationLevel: "READ_COMMITTED";
+  isolationLevel: 1;
   highWaterMark: number;
 };

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

@@ -1,5 +1,5 @@
 import { type FetchRequestTopic } from "../../apis/consumer/fetch-v17";
-import { type FetchIsolationLevel, type GroupProtocols } from "../../apis/enumerations";
+import { 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";
@@ -62,7 +62,7 @@ export interface ConsumeBaseOptions<Key, Value, HeaderKey, HeaderValue> {
   minBytes?: number;
   maxBytes?: number;
   maxWaitTime?: number;
-  isolationLevel?: FetchIsolationLevel;
+  isolationLevel?: number;
   deserializers?: Partial<Deserializers<Key, Value, HeaderKey, HeaderValue>>;
   highWaterMark?: number;
 }
@@ -95,6 +95,29 @@ export interface ListOffsetsOptions {
   topics: string[];
   partitions?: Record<string, number[]>;
   timestamp?: bigint;
-  isolationLevel?: FetchIsolationLevel;
+  isolationLevel?: number;
 }
-export type GetLagOptions = Omit<ListOffsetsOptions, 'timestamp' | 'isolationLevel'>;
+export type GetLagOptions = Omit<ListOffsetsOptions, 'timestamp' | 'isolationLevel'>;
+export interface ConsumerGroupJoinPayload {
+  groupId: string;
+  memberId: string;
+  generationId?: number;
+  isLeader?: boolean;
+  assignments?: GroupAssignment[];
+}
+export interface ConsumerGroupLeavePayload {
+  groupId: string;
+  memberId: string | null;
+  generationId?: number;
+}
+export interface ConsumerGroupRebalancePayload {
+  groupId: string;
+}
+export interface ConsumerHeartbeatPayload {
+  groupId?: string;
+  memberId?: string | null;
+  generationId?: number;
+}
+export interface ConsumerHeartbeatErrorPayload extends ConsumerHeartbeatPayload {
+  error: Error;
+}

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

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

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

@@ -8,10 +8,13 @@ export declare const produceOptionsProperties: {
   idempotent: {
     type: string;
   };
+  transactionalId: {
+    type: string;
+  };
   acks: {
     type: string;
     enumeration: {
-      allowed: number[];
+      allowed: (0 | 1 | -1)[];
       errorMessage: string;
     };
   };
@@ -44,10 +47,13 @@ export declare const produceOptionsSchema: {
     idempotent: {
       type: string;
     };
+    transactionalId: {
+      type: string;
+    };
     acks: {
       type: string;
       enumeration: {
-        allowed: number[];
+        allowed: (0 | 1 | -1)[];
         errorMessage: string;
       };
     };
@@ -84,10 +90,13 @@ export declare const sendOptionsSchema: {
     idempotent: {
       type: string;
     };
+    transactionalId: {
+      type: string;
+    };
     acks: {
       type: string;
       enumeration: {
-        allowed: number[];
+        allowed: (0 | 1 | -1)[];
         errorMessage: string;
       };
     };

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

@@ -1,5 +1,8 @@
 import { type CallbackWithPromise } from "../../apis/callbacks";
+import { type Message } from "../../protocol/records";
+import { kTransaction, kTransactionAddOffsets, kTransactionAddPartitions, kTransactionCancel, kTransactionCommitOffset, kTransactionEnd, kTransactionFindCoordinator } from "../../symbols";
 import { Base } from "../base/base";
+import { Transaction } from "./transaction";
 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>> {
@@ -7,10 +10,24 @@ export declare class Producer<Key = Buffer, Value = Buffer, HeaderKey = Buffer,
   constructor(options: ProducerOptions<Key, Value, HeaderKey, HeaderValue>);
   get producerId(): bigint | undefined;
   get producerEpoch(): number | undefined;
+  get transaction(): Transaction<Key, Value, HeaderKey, HeaderValue> | undefined;
+  get coordinatorId(): number;
   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>;
+  send(options: SendOptions<Key, Value, HeaderKey, HeaderValue> & {
+    [kTransaction]?: number;
+  }, callback: CallbackWithPromise<ProduceResult>): void;
+  send(options: SendOptions<Key, Value, HeaderKey, HeaderValue> & {
+    [kTransaction]?: number;
+  }): Promise<ProduceResult>;
+  beginTransaction(options: ProduceOptions<Key, Value, HeaderKey, HeaderValue>, callback: CallbackWithPromise<Transaction<Key, Value, HeaderKey, HeaderValue>>): void;
+  beginTransaction(options?: ProduceOptions<Key, Value, HeaderKey, HeaderValue>): Promise<Transaction<Key, Value, HeaderKey, HeaderValue>>;
+  [kTransactionFindCoordinator](callback: CallbackWithPromise<void>): void;
+  [kTransactionAddPartitions](transactionId: number, topicsPartitions: Map<string, Set<number>>, callback: CallbackWithPromise<void>): void;
+  [kTransactionAddOffsets](transactionId: number, groupId: string, callback: CallbackWithPromise<void>): void;
+  [kTransactionCommitOffset]<MessageKey = Buffer, MessageValue = Buffer, MessageHeaderKey = Buffer, MessageHeaderValue = Buffer>(transactionId: number, message: Message<MessageKey, MessageValue, MessageHeaderKey, MessageHeaderValue>, callback: CallbackWithPromise<void>): void;
+  [kTransactionEnd](transactionId: number, commit: boolean, callback: CallbackWithPromise<void>): void;
+  [kTransactionCancel](transactionId: number, callback: CallbackWithPromise<void>): void;
 }

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

@@ -0,0 +1,30 @@
+import { type CallbackWithPromise } from "../../apis/callbacks";
+import { type Callback } from "../../apis/definitions";
+import { type Message, type MessageRecord } from "../../protocol/records";
+import { kInstance, kTransactionPrepare } from "../../symbols";
+import { type ClusterMetadata } from "../base/types";
+import { type Consumer } from "../consumer/consumer";
+import { type Producer } from "./producer";
+import { type ProduceOptions, type ProduceResult, type SendOptions } from "./types";
+export declare class Transaction<Key = Buffer, Value = Buffer, HeaderKey = Buffer, HeaderValue = Buffer> {
+  #private;
+  id: string;
+  [kInstance]: number;
+  constructor(producer: Producer<Key, Value, HeaderKey, HeaderValue>);
+  get completed(): boolean;
+  [kTransactionPrepare](transactionalId: string | undefined, options: ProduceOptions<Key, Value, HeaderKey, HeaderValue>, callback: Callback<Transaction<Key, Value, HeaderKey, HeaderValue>>): void;
+  send(options: SendOptions<Key, Value, HeaderKey, HeaderValue>, callback: CallbackWithPromise<ProduceResult>): void;
+  send(options: SendOptions<Key, Value, HeaderKey, HeaderValue>): Promise<ProduceResult>;
+  addPartitions(metadata: ClusterMetadata, messages: MessageRecord[], callback: CallbackWithPromise<void>): void;
+  addPartitions(metadata: ClusterMetadata, messages: MessageRecord[]): Promise<void>;
+  addConsumer<MessageKey = Buffer, MessageValue = Buffer, MessageHeaderKey = Buffer, MessageHeaderValue = Buffer>(consumer: Consumer<MessageKey, MessageValue, MessageHeaderKey, MessageHeaderValue>, callback: CallbackWithPromise<void>): void;
+  addConsumer<MessageKey = Buffer, MessageValue = Buffer, MessageHeaderKey = Buffer, MessageHeaderValue = Buffer>(consumer: Consumer<MessageKey, MessageValue, MessageHeaderKey, MessageHeaderValue>): Promise<void>;
+  addOffset<MessageKey = Buffer, MessageValue = Buffer, MessageHeaderKey = Buffer, MessageHeaderValue = Buffer>(message: Message<MessageKey, MessageValue, MessageHeaderKey, MessageHeaderValue>, callback: CallbackWithPromise<void>): void;
+  addOffset<MessageKey = Buffer, MessageValue = Buffer, MessageHeaderKey = Buffer, MessageHeaderValue = Buffer>(message: Message<MessageKey, MessageValue, MessageHeaderKey, MessageHeaderValue>): Promise<void>;
+  commit(callback: CallbackWithPromise<void>): void;
+  commit(): Promise<void>;
+  abort(callback: CallbackWithPromise<void>): void;
+  abort(): Promise<void>;
+  cancel(callback: CallbackWithPromise<void>): void;
+  cancel(): Promise<void>;
+}

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

@@ -5,6 +5,7 @@ import { type Serializers } from "../serde";
 export interface ProducerInfo {
   producerId: bigint;
   producerEpoch: number;
+  transactionalId?: string;
 }
 export interface ProduceResult {
   offsets?: TopicWithPartitionAndOffset[];
@@ -22,6 +23,7 @@ export interface ProduceOptions<Key, Value, HeaderKey, HeaderValue> {
   repeatOnStaleMetadata?: boolean;
 }
 export type ProducerOptions<Key, Value, HeaderKey, HeaderValue> = BaseOptions & ProduceOptions<Key, Value, HeaderKey, HeaderValue> & {
+  transactionalId?: string;
   serializers?: Partial<Serializers<Key, Value, HeaderKey, HeaderValue>>;
 };
 export type SendOptions<Key, Value, HeaderKey, HeaderValue> = {

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

@@ -42,8 +42,13 @@ export declare const adminTopicsChannel: TracingChannelWithName<ClientDiagnostic
 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>>>;

package/dist/typescript-4/dist/protocol/records.d.ts

@@ -3,6 +3,11 @@ import { type CompressionAlgorithmValue } from "./compression";
 import { type NullableString } from "./definitions";
 import { Reader } from "./reader";
 import { Writer } from "./writer";
+export declare const CURRENT_RECORD_VERSION = 2;
+export declare const IS_COMPRESSED = 7;
+export declare const IS_TRANSACTIONAL: number;
+export declare const IS_CONTROL: number;
+export declare const BATCH_HEAD: number;
 export interface MessageBase<Key = Buffer, Value = Buffer> {
   key?: Key;
   value?: Value;
@@ -13,9 +18,16 @@ export interface MessageBase<Key = Buffer, Value = Buffer> {
 export interface MessageToProduce<Key = Buffer, Value = Buffer, HeaderKey = Buffer, HeaderValue = Buffer> extends MessageBase<Key, Value> {
   headers?: Map<HeaderKey, HeaderValue> | Record<string, HeaderValue>;
 }
+export interface MessageConsumerMetadata {
+  coordinatorId: number;
+  groupId: string;
+  generationId: number;
+  memberId: string;
+}
 export interface Message<Key = Buffer, Value = Buffer, HeaderKey = Buffer, HeaderValue = Buffer> extends Required<MessageBase<Key, Value>> {
   headers: Map<HeaderKey, HeaderValue>;
   offset: bigint;
+  metadata: Record<string, unknown>;
   commit(callback?: (error?: Error) => void): void | Promise<void>;
 }
 export interface MessageRecord {

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

@@ -1,3 +1,11 @@
 export declare const kInstance: unique symbol;
 export declare const kRefreshOffsetsAndFetch: unique symbol;
-export declare const kAutocommit: unique symbol;
+export declare const kAutocommit: unique symbol;
+export declare const kTransaction: unique symbol;
+export declare const kTransactionPrepare: unique symbol;
+export declare const kTransactionAddPartitions: unique symbol;
+export declare const kTransactionAddOffsets: unique symbol;
+export declare const kTransactionCommitOffset: unique symbol;
+export declare const kTransactionEnd: unique symbol;
+export declare const kTransactionCancel: unique symbol;
+export declare const kTransactionFindCoordinator: unique symbol;

package/dist/version.js

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

package/package.json

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