@platformatic/kafka 1.27.0-alpha.3 → 1.28.0

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

@@ -2,8 +2,9 @@ import { type FetchRequestTopic } from "../../apis/consumer/fetch-v17";
 import { type GroupProtocols } from "../../apis/enumerations";
 import { type ConnectionPool } from "../../network/connection-pool";
 import { type KafkaRecord, type Message } from "../../protocol/records";
+import { type SchemaRegistry } from "../../registries/abstract";
 import { type BaseOptions, type ClusterMetadata, type TopicWithPartitionAndOffset } from "../base/types";
-import { type Deserializers } from "../serde";
+import { type BeforeDeserializationHook, type Deserializers } from "../serde";
 export interface GroupProtocolSubscription {
   name: string;
   version: number;
@@ -68,6 +69,8 @@ export interface ConsumeBaseOptions<Key, Value, HeaderKey, HeaderValue> {
   isolationLevel?: number;
   deserializers?: Partial<Deserializers<Key, Value, HeaderKey, HeaderValue>>;
   highWaterMark?: number;
+  beforeDeserialization?: BeforeDeserializationHook;
+  registry?: SchemaRegistry<unknown, unknown, Key, Value, HeaderKey, HeaderValue>;
 }
 export interface StreamOptions {
   topics: string[];

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

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

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

@@ -121,24 +121,8 @@ export declare const sendOptionsSchema: {
       items: {
         type: string;
         properties: {
-          key: {
-            oneOf: ({
-              type: string;
-              buffer?: undefined;
-            } | {
-              buffer: boolean;
-              type?: undefined;
-            })[];
-          };
-          value: {
-            oneOf: ({
-              type: string;
-              buffer?: undefined;
-            } | {
-              buffer: boolean;
-              type?: undefined;
-            })[];
-          };
+          key: boolean;
+          value: boolean;
           headers: {
             anyOf: ({
               map: boolean;
@@ -170,4 +154,67 @@ export declare const sendOptionsSchema: {
 };
 export declare const sendOptionsValidator: import("ajv").ValidateFunction<{
   [x: string]: {};
-}>;
+}>;
+export declare const defaultProducerStreamOptions: {
+  batchSize: number;
+  batchTime: number;
+  reportMode: "none";
+};
+export declare const producerStreamOptionsSchema: {
+  type: string;
+  properties: {
+    producerId: {
+      bigint: boolean;
+    };
+    producerEpoch: {
+      type: string;
+    };
+    idempotent: {
+      type: string;
+    };
+    transactionalId: {
+      type: string;
+    };
+    acks: {
+      type: string;
+      enumeration: {
+        allowed: (0 | 1 | -1)[];
+        errorMessage: string;
+      };
+    };
+    compression: {
+      type: string;
+      enumeration: {
+        allowed: import("../../protocol/compression").CompressionAlgorithmValue[];
+        errorMessage: string;
+      };
+    };
+    partitioner: {
+      function: boolean;
+    };
+    autocreateTopics: {
+      type: string;
+    };
+    repeatOnStaleMetadata: {
+      type: string;
+    };
+    highWaterMark: {
+      type: string;
+      minimum: number;
+    };
+    batchSize: {
+      type: string;
+      minimum: number;
+    };
+    batchTime: {
+      type: string;
+      minimum: number;
+    };
+    reportMode: {
+      type: string;
+      enum: import("./types").ProducerStreamReportModeValue[];
+    };
+  };
+  additionalProperties: boolean;
+};
+export declare const producerStreamOptionsValidator: import("ajv").ValidateFunction<unknown>;

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

@@ -0,0 +1,19 @@
+import { Writable } from 'node:stream';
+import { type CallbackWithPromise } from "../../apis/callbacks";
+import type { MessageToProduce } from "../../protocol/records";
+import type { Producer } from "./producer";
+import { type ProducerStreamOptions } from "./types";
+export declare class ProducerStream<Key = Buffer, Value = Buffer, HeaderKey = Buffer, HeaderValue = Buffer> extends Writable {
+  #private;
+  instance: number;
+  constructor(producer: Producer<Key, Value, HeaderKey, HeaderValue>, options: ProducerStreamOptions<Key, Value, HeaderKey, HeaderValue>);
+  get producer(): Producer<Key, Value, HeaderKey, HeaderValue>;
+  close(callback: CallbackWithPromise<void>): void;
+  close(): Promise<void>;
+  _write(message: MessageToProduce<Key, Value, HeaderKey, HeaderValue>, _: BufferEncoding, callback: (error?: Error | null) => void): void;
+  _writev(chunks: Array<{
+    chunk: MessageToProduce<Key, Value, HeaderKey, HeaderValue>;
+  }>, callback: (error?: Error | null) => void): void;
+  _final(callback: (error?: Error | null) => void): void;
+  _destroy(error: Error | null, callback: (error?: Error | null) => void): void;
+}

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

@@ -2,8 +2,9 @@ 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 { ProducerStream } from "./producer-stream";
 import { Transaction } from "./transaction";
-import { type ProduceOptions, type ProduceResult, type ProducerInfo, type ProducerOptions, type SendOptions } from "./types";
+import { type ProduceOptions, type ProduceResult, type ProducerInfo, type ProducerOptions, type ProducerStreamOptions, 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;
@@ -12,8 +13,9 @@ export declare class Producer<Key = Buffer, Value = Buffer, HeaderKey = Buffer,
   get producerEpoch(): number | undefined;
   get transaction(): Transaction<Key, Value, HeaderKey, HeaderValue> | undefined;
   get coordinatorId(): number;
-  close(callback: CallbackWithPromise<void>): void;
-  close(): Promise<void>;
+  get streamsCount(): number;
+  close(force: boolean | CallbackWithPromise<void>, callback?: CallbackWithPromise<void>): void;
+  close(force?: boolean): 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> & {
@@ -22,6 +24,7 @@ export declare class Producer<Key = Buffer, Value = Buffer, HeaderKey = Buffer,
   send(options: SendOptions<Key, Value, HeaderKey, HeaderValue> & {
     [kTransaction]?: number;
   }): Promise<ProduceResult>;
+  asStream(options?: ProducerStreamOptions<Key, Value, HeaderKey, HeaderValue>): ProducerStream<Key, Value, HeaderKey, HeaderValue>;
   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;

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

@@ -1,7 +1,8 @@
 import { type CompressionAlgorithmValue } from "../../protocol/compression";
 import { type MessageToProduce } from "../../protocol/records";
+import { type SchemaRegistry } from "../../registries/abstract";
 import { type BaseOptions, type TopicWithPartitionAndOffset } from "../base/types";
-import { type Serializers } from "../serde";
+import { type BeforeSerializationHook, type Serializers } from "../serde";
 export interface ProducerInfo {
   producerId: bigint;
   producerEpoch: number;
@@ -12,6 +13,16 @@ export interface ProduceResult {
   unwritableNodes?: number[];
 }
 export type Partitioner<Key, Value, HeaderKey, HeaderValue> = (message: MessageToProduce<Key, Value, HeaderKey, HeaderValue>) => number;
+export interface ProducerStreamReport {
+  batchId: number;
+  count: number;
+  result: ProduceResult;
+}
+export interface ProducerStreamMessageReport<Key, Value, HeaderKey, HeaderValue> {
+  batchId: number;
+  index: number;
+  message: MessageToProduce<Key, Value, HeaderKey, HeaderValue>;
+}
 export interface ProduceOptions<Key, Value, HeaderKey, HeaderValue> {
   producerId?: bigint;
   producerEpoch?: number;
@@ -25,7 +36,23 @@ export interface ProduceOptions<Key, Value, HeaderKey, HeaderValue> {
 export type ProducerOptions<Key, Value, HeaderKey, HeaderValue> = BaseOptions & ProduceOptions<Key, Value, HeaderKey, HeaderValue> & {
   transactionalId?: string;
   serializers?: Partial<Serializers<Key, Value, HeaderKey, HeaderValue>>;
+  beforeSerialization?: BeforeSerializationHook<Key, Value, HeaderKey, HeaderValue>;
+  registry?: SchemaRegistry<unknown, unknown, Key, Value, HeaderKey, HeaderValue>;
 };
 export type SendOptions<Key, Value, HeaderKey, HeaderValue> = {
   messages: MessageToProduce<Key, Value, HeaderKey, HeaderValue>[];
-} & ProduceOptions<Key, Value, HeaderKey, HeaderValue>;
+} & ProduceOptions<Key, Value, HeaderKey, HeaderValue>;
+export declare const ProducerStreamReportModes: {
+  readonly NONE: "none";
+  readonly BATCH: "batch";
+  readonly MESSAGE: "message";
+};
+export declare const allowedProducerStreamReportModes: ProducerStreamReportModeValue[];
+export type ProducerStreamReportMode = keyof typeof ProducerStreamReportModes;
+export type ProducerStreamReportModeValue = (typeof ProducerStreamReportModes)[keyof typeof ProducerStreamReportModes];
+export type ProducerStreamOptions<Key, Value, HeaderKey, HeaderValue> = Omit<SendOptions<Key, Value, HeaderKey, HeaderValue>, 'messages'> & {
+  highWaterMark?: number;
+  batchSize?: number;
+  batchTime?: number;
+  reportMode?: ProducerStreamReportModeValue;
+};

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

@@ -1,7 +1,9 @@
-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;
+import { type Callback } from "../apis/definitions";
+import { type MessageToConsume, type MessageToProduce } from "../protocol/records";
+export type Serializer<InputType = unknown> = (data?: InputType, metadata?: unknown) => Buffer | undefined;
+export type SerializerWithHeaders<InputType = unknown, HeaderKey = unknown, HeaderValue = unknown> = (data?: InputType, headers?: Map<HeaderKey, HeaderValue>, message?: MessageToProduce<unknown, unknown, unknown, unknown>) => Buffer | undefined;
+export type Deserializer<OutputType = unknown> = (data?: Buffer, message?: MessageToConsume) => OutputType | undefined;
+export type DeserializerWithHeaders<OutputType = unknown, HeaderKey = unknown, HeaderValue = unknown> = (data?: Buffer, headers?: Map<HeaderKey, HeaderValue>, message?: MessageToConsume) => OutputType | undefined;
 export interface Serializers<Key, Value, HeaderKey, HeaderValue> {
   key: SerializerWithHeaders<Key, HeaderKey, HeaderValue>;
   value: SerializerWithHeaders<Value, HeaderKey, HeaderValue>;
@@ -9,11 +11,14 @@ export interface Serializers<Key, Value, HeaderKey, HeaderValue> {
   headerValue: Serializer<HeaderValue>;
 }
 export interface Deserializers<Key, Value, HeaderKey, HeaderValue> {
-  key: DeserializerWithHeaders<Key>;
-  value: DeserializerWithHeaders<Value>;
+  key: DeserializerWithHeaders<Key, HeaderKey, HeaderValue>;
+  value: DeserializerWithHeaders<Value, HeaderKey, HeaderValue>;
   headerKey: Deserializer<HeaderKey>;
   headerValue: Deserializer<HeaderValue>;
 }
+export type BeforeHookPayloadType = 'key' | 'value' | 'headerKey' | 'headerValue';
+export type BeforeDeserializationHook = (payload: Buffer, type: BeforeHookPayloadType, message: MessageToConsume, callback: Callback<void>) => void | Promise<void>;
+export type BeforeSerializationHook<Key, Value, HeaderKey, HeaderValue> = (payload: unknown, type: BeforeHookPayloadType, message: MessageToProduce<Key, Value, HeaderKey, HeaderValue>, callback: Callback<void>) => void | Promise<void>;
 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;

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

@@ -4,7 +4,7 @@ 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';
+  type: ClientType | 'connection' | 'connection-pool' | 'messages-stream' | 'producer-stream';
   instance: InstanceType;
 }
 export type ConnectionDiagnosticEvent<Attributes = Record<string, unknown>> = {
@@ -29,7 +29,7 @@ export type DiagnosticContext<BaseContext = {}> = BaseContext & {
 };
 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 notifyCreation<InstanceType>(type: ClientType | 'connection' | 'connection-pool' | 'messages-stream' | 'producer-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>;

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

@@ -2,7 +2,7 @@ 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 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_FORMAT", "PLT_KFK_UNSUPPORTED", "PLT_KFK_USER"];
 export type ErrorCode = (typeof errorCodes)[number];
 export type ErrorProperties = {
   cause?: Error;
@@ -45,10 +45,6 @@ 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);
@@ -73,6 +69,10 @@ export declare class UnsupportedCompressionError extends GenericError {
   static code: ErrorCode;
   constructor(message: string, properties?: ErrorProperties);
 }
+export declare class UnsupportedFormatError extends GenericError {
+  static code: ErrorCode;
+  constructor(message: string, properties?: ErrorProperties);
+}
 export declare class UnsupportedError extends GenericError {
   static code: ErrorCode;
   constructor(message: string, properties?: ErrorProperties);

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

@@ -5,4 +5,5 @@ export * from "./utils";
 export * from "./network/index";
 export * from "./protocol/index";
 export * from "./apis/index";
-export * from "./clients/index";
+export * from "./clients/index";
+export * from "./registries/index";

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

@@ -20,18 +20,19 @@ export interface ConnectionEvents extends TypedEvents {
   'sasl:authentication:extended': (authBytes?: Buffer) => void;
   drain: () => void;
 }
-export type SASLCredentialProvider<T = string> = () => T | Promise<T>;
+export type CredentialProvider<T = string> = () => T | Promise<T>;
+export type SASLCredentialProvider<T> = CredentialProvider<T>;
 export interface Broker {
   host: string;
   port: number;
 }
-export type SASLCustomAuthenticator = (mechanism: SASLMechanismValue, connection: Connection, authenticate: SASLAuthenticationAPI, usernameProvider: string | SASLCredentialProvider | undefined, passwordProvider: string | SASLCredentialProvider | undefined, tokenProvider: string | SASLCredentialProvider | undefined, callback: CallbackWithPromise<SaslAuthenticateResponse>) => void;
+export type SASLCustomAuthenticator = (mechanism: SASLMechanismValue, connection: Connection, authenticate: SASLAuthenticationAPI, usernameProvider: string | CredentialProvider | undefined, passwordProvider: string | CredentialProvider | undefined, tokenProvider: string | CredentialProvider | undefined, callback: CallbackWithPromise<SaslAuthenticateResponse>) => void;
 export interface SASLOptions {
   mechanism: SASLMechanismValue;
-  username?: string | SASLCredentialProvider;
-  password?: string | SASLCredentialProvider;
-  token?: string | SASLCredentialProvider;
-  oauthBearerExtensions?: Record<string, string> | SASLCredentialProvider<Record<string, string>>;
+  username?: string | CredentialProvider;
+  password?: string | CredentialProvider;
+  token?: string | CredentialProvider;
+  oauthBearerExtensions?: Record<string, string> | CredentialProvider<Record<string, string>>;
   authenticate?: SASLCustomAuthenticator;
   authBytesValidator?: (authBytes: Buffer, callback: CallbackWithPromise<Buffer>) => void;
 }

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

@@ -1,4 +1,4 @@
-import { DynamicBuffer } from "./dynamic-buffer";
+import { DynamicBuffer } from '@platformatic/dynamic-buffer';
 export type SyncCompressionPhase = (data: Buffer | DynamicBuffer) => Buffer;
 export type CompressionOperation = (data: Buffer) => Buffer;
 export interface CompressionAlgorithmSpecification {

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

@@ -1,4 +1,4 @@
-import { DynamicBuffer } from "./dynamic-buffer";
+import { DynamicBuffer } from '@platformatic/dynamic-buffer';
 export declare function loadNativeCRC32C(): typeof jsCRC32C | null;
 export declare function jsCRC32C(data: Buffer | Uint8Array | DynamicBuffer): number;
 export declare const crc32c: typeof jsCRC32C;

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

@@ -1,4 +1,4 @@
-import { type DynamicBuffer } from "./dynamic-buffer";
+import { type DynamicBuffer } from '@platformatic/dynamic-buffer';
 export declare const INT8_SIZE = 1;
 export declare const INT16_SIZE = 2;
 export declare const INT32_SIZE = 4;

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

@@ -2,7 +2,6 @@ export * from "./apis";
 export * from "./compression";
 export * from "./crc32c";
 export * from "./definitions";
-export * from "./dynamic-buffer";
 export * from "./errors";
 export * from "./murmur2";
 export * from "./reader";
@@ -11,5 +10,4 @@ export * as saslOAuthBearer from "./sasl/oauth-bearer";
 export * as saslPlain from "./sasl/plain";
 export * as saslScramSha from "./sasl/scram-sha";
 export * as saslUtils from "./sasl/utils";
-export * from "./varint";
 export * from "./writer";

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

@@ -1,4 +1,4 @@
-import { DynamicBuffer } from "./dynamic-buffer";
+import { DynamicBuffer } from '@platformatic/dynamic-buffer';
 import { Writer } from "./writer";
 export type EntryReader<OutputType> = (reader: Reader, index: number) => OutputType;
 declare const instanceIdentifier: unique symbol;
@@ -48,7 +48,7 @@ export declare class Reader {
   readUUID(): string;
   readNullableBytes(compact?: boolean): Buffer | null;
   readBytes(compact?: boolean): Buffer;
-  readVarIntBytes(): Buffer;
+  readVarIntBytes(): Buffer | null;
   readNullableArray<OutputType>(reader: EntryReader<OutputType>, compact?: boolean, discardTrailingTaggedFields?: boolean): OutputType[] | null;
   readNullableMap<Key, Value>(reader: EntryReader<[Key, Value]>, compact?: boolean, discardTrailingTaggedFields?: boolean): Map<Key, Value> | null;
   readArray<OutputType>(reader: EntryReader<OutputType>, compact?: boolean, discardTrailingTaggedFields?: boolean): OutputType[];

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

@@ -1,4 +1,4 @@
-import { type NumericMap } from "../utils";
+import type { NumericMap } from "../utils";
 import { type CompressionAlgorithmValue } from "./compression";
 import { type NullableString } from "./definitions";
 import { Reader } from "./reader";
@@ -17,6 +17,7 @@ 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>;
+  metadata?: unknown;
 }
 export interface MessageConsumerMetadata {
   coordinatorId: number;
@@ -63,9 +64,13 @@ export interface KafkaRecord {
   attributes: number;
   timestampDelta: bigint;
   offsetDelta: number;
-  key: Buffer;
-  value: Buffer;
-  headers: [Buffer, Buffer][];
+  key: Buffer | null;
+  value: Buffer | null;
+  headers: [Buffer | null, Buffer | null][];
+}
+export interface MessageToConsume extends KafkaRecord {
+  topic: string;
+  partition: number;
 }
 export interface RecordsBatch {
   firstOffset: bigint;
@@ -85,24 +90,8 @@ export interface RecordsBatch {
 export declare const messageSchema: {
   type: string;
   properties: {
-    key: {
-      oneOf: ({
-        type: string;
-        buffer?: undefined;
-      } | {
-        buffer: boolean;
-        type?: undefined;
-      })[];
-    };
-    value: {
-      oneOf: ({
-        type: string;
-        buffer?: undefined;
-      } | {
-        buffer: boolean;
-        type?: undefined;
-      })[];
-    };
+    key: boolean;
+    value: boolean;
     headers: {
       anyOf: ({
         map: boolean;

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

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

package/dist/typescript-4/dist/protocol/sasl/plain.d.ts

@@ -1,5 +1,5 @@
 import { type CallbackWithPromise } from "../../apis/callbacks";
 import { type SASLAuthenticationAPI, type SaslAuthenticateResponse } from "../../apis/security/sasl-authenticate-v2";
-import { type Connection, type SASLCredentialProvider } from "../../network/connection";
-export declare function authenticate(authenticateAPI: SASLAuthenticationAPI, connection: Connection, usernameProvider: string | SASLCredentialProvider, passwordProvider: string | SASLCredentialProvider, callback: CallbackWithPromise<SaslAuthenticateResponse>): void;
-export declare function authenticate(authenticateAPI: SASLAuthenticationAPI, connection: Connection, usernameProvider: string | SASLCredentialProvider, passwordProvider: string | SASLCredentialProvider): Promise<SaslAuthenticateResponse>;
+import { type Connection, type CredentialProvider } from "../../network/connection";
+export declare function authenticate(authenticateAPI: SASLAuthenticationAPI, connection: Connection, usernameProvider: string | CredentialProvider, passwordProvider: string | CredentialProvider, callback: CallbackWithPromise<SaslAuthenticateResponse>): void;
+export declare function authenticate(authenticateAPI: SASLAuthenticationAPI, connection: Connection, usernameProvider: string | CredentialProvider, passwordProvider: string | CredentialProvider): Promise<SaslAuthenticateResponse>;

package/dist/typescript-4/dist/protocol/sasl/scram-sha.d.ts

@@ -1,6 +1,6 @@
 import { type CallbackWithPromise } from "../../apis/callbacks";
 import { type SASLAuthenticationAPI, type SaslAuthenticateResponse } from "../../apis/security/sasl-authenticate-v2";
-import { type Connection, type SASLCredentialProvider } from "../../network/connection";
+import { type Connection, type CredentialProvider } from "../../network/connection";
 export interface ScramAlgorithmDefinition {
   keyLength: number;
   algorithm: string;
@@ -35,5 +35,5 @@ export declare function hi(definition: ScramAlgorithmDefinition, password: strin
 export declare function hmac(definition: ScramAlgorithmDefinition, key: Buffer, data: string | Buffer): Buffer;
 export declare function xor(a: Buffer, b: Buffer): Buffer;
 export declare const defaultCrypto: ScramCryptoModule;
-export declare function authenticate(authenticateAPI: SASLAuthenticationAPI, connection: Connection, algorithm: ScramAlgorithm, usernameProvider: string | SASLCredentialProvider, passwordProvider: string | SASLCredentialProvider, crypto: ScramCryptoModule, callback: CallbackWithPromise<SaslAuthenticateResponse>): void;
-export declare function authenticate(authenticateAPI: SASLAuthenticationAPI, connection: Connection, algorithm: ScramAlgorithm, usernameProvider: string | SASLCredentialProvider, passwordProvider: string | SASLCredentialProvider, crypto?: ScramCryptoModule): Promise<SaslAuthenticateResponse>;
+export declare function authenticate(authenticateAPI: SASLAuthenticationAPI, connection: Connection, algorithm: ScramAlgorithm, usernameProvider: string | CredentialProvider, passwordProvider: string | CredentialProvider, crypto: ScramCryptoModule, callback: CallbackWithPromise<SaslAuthenticateResponse>): void;
+export declare function authenticate(authenticateAPI: SASLAuthenticationAPI, connection: Connection, algorithm: ScramAlgorithm, usernameProvider: string | CredentialProvider, passwordProvider: string | CredentialProvider, crypto?: ScramCryptoModule): Promise<SaslAuthenticateResponse>;

package/dist/typescript-4/dist/protocol/sasl/utils.d.ts

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

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

@@ -1,5 +1,5 @@
+import { DynamicBuffer } from '@platformatic/dynamic-buffer';
 import { type NullableString } from "./definitions";
-import { DynamicBuffer } from "./dynamic-buffer";
 export type ChildrenWriter = (w: Writer) => void;
 export type EntryWriter<InputType> = (writer: Writer, entry: InputType, index: number) => void;
 declare const instanceIdentifier: unique symbol;

package/dist/typescript-4/dist/registries/abstract.d.ts

@@ -0,0 +1,22 @@
+import { type Callback } from "../apis/definitions";
+import { type BeforeDeserializationHook, type BeforeHookPayloadType, type BeforeSerializationHook, type Deserializers, type Serializers } from "../clients/serde";
+import { type MessageToProduce } from "../protocol/records";
+export interface SchemaRegistry<Id = unknown, Schema = unknown, Key = Buffer, Value = Buffer, HeaderKey = Buffer, HeaderValue = Buffer> {
+  get(id: Id): Schema | undefined;
+  fetch(id: Id, callback?: (error?: Error) => void): void | Promise<void>;
+  getSchemaId(payload: Buffer | MessageToProduce<Key, Value, HeaderKey, HeaderValue>, type?: BeforeHookPayloadType): Id;
+  getSerializers(): Serializers<Key, Value, HeaderKey, HeaderValue>;
+  getDeserializers(): Deserializers<Key, Value, HeaderKey, HeaderValue>;
+  getBeforeSerializationHook(): BeforeSerializationHook<Key, Value, HeaderKey, HeaderValue>;
+  getBeforeDeserializationHook(): BeforeDeserializationHook;
+}
+export declare function runAsyncSeries<V>(operation: (item: V, cb: Callback<void>) => void | Promise<void>, collection: V[], index: number, callback: Callback<void>): void;
+export declare class AbstractSchemaRegistry<Id = unknown, Schema = unknown, Key = Buffer, Value = Buffer, HeaderKey = Buffer, HeaderValue = Buffer> implements SchemaRegistry<Id, Schema, Key, Value, HeaderKey, HeaderValue> {
+  get(_: Id): Schema | undefined;
+  fetch(_i: unknown, _c?: (error?: Error) => void): void | Promise<void>;
+  getSchemaId(_p: Buffer | MessageToProduce<Key, Value, HeaderKey, HeaderValue>, _t?: BeforeHookPayloadType): Id;
+  getSerializers(): Serializers<Key, Value, HeaderKey, HeaderValue>;
+  getDeserializers(): Deserializers<Key, Value, HeaderKey, HeaderValue>;
+  getBeforeSerializationHook(): BeforeSerializationHook<Key, Value, HeaderKey, HeaderValue>;
+  getBeforeDeserializationHook(): BeforeDeserializationHook;
+}

package/dist/typescript-4/dist/registries/confluent-schema-registry.d.ts

@@ -0,0 +1,41 @@
+import { type ValidateFunction } from 'ajv';
+import { type Type } from 'avsc';
+import { type Root } from 'protobufjs';
+import { type Callback } from "../apis/definitions";
+import { type BeforeDeserializationHook, type BeforeHookPayloadType, type BeforeSerializationHook, type Deserializers, type Serializers } from "../clients/serde";
+import { type CredentialProvider } from "../index";
+import { type MessageToConsume, type MessageToProduce } from "../protocol/records";
+import { AbstractSchemaRegistry } from "./abstract";
+type ConfluentSchemaRegistryMessageToProduce = MessageToProduce<unknown, unknown, unknown, unknown>;
+export interface ConfluentSchemaRegistryMetadata {
+  schemas?: Record<BeforeHookPayloadType, number>;
+}
+export type ConfluentSchemaRegistryProtobufTypeMapper = (id: number, type: BeforeHookPayloadType, context: ConfluentSchemaRegistryMessageToProduce | MessageToConsume) => string;
+export interface ConfluentSchemaRegistryOptions {
+  url: string;
+  auth?: {
+    username?: string | CredentialProvider;
+    password?: string | CredentialProvider;
+    token?: string | CredentialProvider;
+  };
+  protobufTypeMapper?: ConfluentSchemaRegistryProtobufTypeMapper;
+  jsonValidateSend?: boolean;
+}
+export interface Schema {
+  id: number;
+  type: 'avro' | 'protobuf' | 'json';
+  schema: Type | Root | ValidateFunction;
+}
+export declare function defaultProtobufTypeMapper(_: number, type: BeforeHookPayloadType, context: ConfluentSchemaRegistryMessageToProduce | MessageToConsume): string;
+export declare class ConfluentSchemaRegistry<Key = Buffer, Value = Buffer, HeaderKey = Buffer, HeaderValue = Buffer> extends AbstractSchemaRegistry<number | undefined, Schema, Key, Value, HeaderKey, HeaderValue> {
+  #private;
+  constructor(options: ConfluentSchemaRegistryOptions);
+  getSchemaId(message: Buffer | MessageToProduce<Key, Value, HeaderKey, HeaderValue>, type?: BeforeHookPayloadType): number | undefined;
+  get(id: number): Schema | undefined;
+  fetchSchema(id: number, callback: Callback<void>): Promise<void>;
+  getSerializers(): Serializers<Key, Value, HeaderKey, HeaderValue>;
+  getDeserializers(): Deserializers<Key, Value, HeaderKey, HeaderValue>;
+  getBeforeSerializationHook(): BeforeSerializationHook<Key, Value, HeaderKey, HeaderValue>;
+  getBeforeDeserializationHook(): BeforeDeserializationHook;
+}
+export {};

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

@@ -0,0 +1,2 @@
+export * from "./abstract";
+export * from "./confluent-schema-registry";

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

@@ -1,6 +1,6 @@
+import { type DynamicBuffer } from '@platformatic/dynamic-buffer';
 import { Ajv2020 } from 'ajv/dist/2020.js';
 import debug from 'debug';
-import { type DynamicBuffer } from "./protocol/dynamic-buffer";
 export interface EnumerationDefinition<T> {
   allowed: T[];
   errorMessage?: string;
@@ -34,4 +34,5 @@ export declare function enumErrorMessage(type: Record<string, unknown>, keysOnly
 export declare function groupByProperty<Key extends PropertyKey, Value>(entries: readonly Value[], property: keyof Value): [Key, Value[]][];
 export declare function humanize(label: string, buffer: Buffer | DynamicBuffer): string;
 export declare function setDebugDumpLogger(logger: DebugDumpLogger): void;
-export declare function debugDump(...values: unknown[]): void;
+export declare function debugDump(...values: unknown[]): void;
+export declare function emitExperimentalApiWarning(api: string): void;

package/dist/utils.d.ts

@@ -1,6 +1,6 @@
+import { type DynamicBuffer } from '@platformatic/dynamic-buffer';
 import { Ajv2020 } from 'ajv/dist/2020.js';
 import debug from 'debug';
-import { type DynamicBuffer } from './protocol/dynamic-buffer.ts';
 export interface EnumerationDefinition<T> {
     allowed: T[];
     errorMessage?: string;
@@ -35,3 +35,4 @@ export declare function groupByProperty<Key extends PropertyKey, Value>(entries:
 export declare function humanize(label: string, buffer: Buffer | DynamicBuffer): string;
 export declare function setDebugDumpLogger(logger: DebugDumpLogger): void;
 export declare function debugDump(...values: unknown[]): void;
+export declare function emitExperimentalApiWarning(api: string): void;

package/dist/utils.js

@@ -156,3 +156,6 @@ export function setDebugDumpLogger(logger) {
 export function debugDump(...values) {
     debugDumpLogger(new Date().toISOString(), ...values.map(v => (typeof v === 'string' ? v : inspect(v, false, 10))));
 }
+export function emitExperimentalApiWarning(api) {
+    process.emitWarning(`The ${api} API is experimental and does not follow semver. It may change in minor/patch releases.`);
+}

package/dist/version.js

@@ -1,2 +1,2 @@
 export const name = "@platformatic/kafka";
-export const version = "1.27.0-alpha.3";
+export const version = "1.28.0";