@platformatic/kafka 2.9.0-alpha.1 → 2.9.0

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

@@ -2,7 +2,7 @@ import { Readable } from 'node:stream';
 import { createPromisifiedCallback, kCallbackPromise, noopCallback } from "../../apis/callbacks.js";
 import { ListOffsetTimestamps } from "../../apis/enumerations.js";
 import { consumerReceivesChannel, createDiagnosticContext, notifyCreation } from "../../diagnostic.js";
-import { protocolErrors, UserError } from "../../errors.js";
+import { findErrorBy, protocolErrors, UserError } from "../../errors.js";
 import { IS_CONTROL } from "../../protocol/records.js";
 import { runAsyncSeries } from "../../registries/abstract.js";
 import { kAutocommit, kGetFetchNode, kInstance, kRefreshOffsetsAndFetch } from "../../symbols.js";
@@ -454,7 +454,7 @@ export class MessagesStream extends Readable {
         });
     }
     #handleOffsetOutOfRange(error, topicIds, callback) {
-        if (!error.findBy?.('apiId', 'OFFSET_OUT_OF_RANGE')) {
+        if (!findErrorBy(error, 'apiId', 'OFFSET_OUT_OF_RANGE')) {
             callback(null, false);
             return;
         }
@@ -613,6 +613,7 @@ export class MessagesStream extends Readable {
                             let payloadType = 'headerKey';
                             let deserializedKey;
                             let deserializedValue;
+                            let deserializationError;
                             try {
                                 for (const [headerKey, headerValue] of record.headers) {
                                     payloadType = 'headerKey';
@@ -640,16 +641,46 @@ export class MessagesStream extends Readable {
                                     timestamp: firstTimestamp + record.timestampDelta,
                                     commit: commit
                                 };
-                                const shouldDestroy = this.#deserializationErrorHandler
-                                    ? this.#deserializationErrorHandler(context) !== DeserializationErrorActions.SKIP
-                                    : this.#corruptedMessageHandler(record, topic, partition, firstTimestamp, firstOffset, commit, error);
-                                if (shouldDestroy) {
+                                const action = this.#deserializationErrorHandler
+                                    ? this.#deserializationErrorHandler(context)
+                                    : this.#corruptedMessageHandler(record, topic, partition, firstTimestamp, firstOffset, commit, error)
+                                        ? DeserializationErrorActions.FAIL
+                                        : DeserializationErrorActions.SKIP;
+                                if (action === DeserializationErrorActions.CONTINUE) {
+                                    /*
+                                      Deliver the message in a degraded form, so that nothing is lost: whatever was
+                                      already deserialized is kept, while the payload which failed and the ones which
+                                      were never attempted, since deserialization goes headers, key and then value,
+                                      are delivered as the original bytes.
+                  
+                                      The error is reported on the message metadata and published on the diagnostic
+                                      channel, which is where callers should react to it: logging here would be a log
+                                      storm waiting to happen.
+                                    */
+                                    diagnosticContext.error = error;
+                                    consumerReceivesChannel.error.publish(diagnosticContext);
+                                    const headersFailed = payloadType === 'headerKey' || payloadType === 'headerValue';
+                                    if (headersFailed) {
+                                        headers.clear();
+                                        for (const [headerKey, headerValue] of record.headers) {
+                                            headers.set(headerKey, headerValue);
+                                        }
+                                    }
+                                    if (headersFailed || payloadType === 'key') {
+                                        deserializedKey = (record.key ?? undefined);
+                                    }
+                                    deserializedValue = (record.value ?? undefined);
+                                    deserializationError = { error, payloadType };
+                                }
+                                else if (action === DeserializationErrorActions.SKIP) {
+                                    continue;
+                                }
+                                else {
                                     diagnosticContext.error = error;
                                     consumerReceivesChannel.error.publish(diagnosticContext);
                                     this.destroy(new UserError('Failed to deserialize a message.', { cause: error }));
                                     return;
                                 }
-                                continue;
                             }
                             this.#metricsConsumedMessages?.inc();
                             const message = {
@@ -661,7 +692,12 @@ export class MessagesStream extends Readable {
                                 timestamp: firstTimestamp + record.timestampDelta,
                                 offset,
                                 commit,
-                                metadata: messageMetadata,
+                                // Deserializers and hooks can enrich the metadata of the message they processed
+                                metadata: deserializationError
+                                    ? { ...messageMetadata, ...messageToConsume.metadata, deserializationError }
+                                    : messageToConsume.metadata
+                                        ? { ...messageMetadata, ...messageToConsume.metadata }
+                                        : messageMetadata,
                                 toJSON: messageToJSON
                             };
                             diagnosticContext.result = message;
@@ -747,7 +783,7 @@ export class MessagesStream extends Readable {
                 // Only destroy the stream when the broker requires a group rejoin
                 // (ILLEGAL_GENERATION, UNKNOWN_MEMBER_ID, REBALANCE_IN_PROGRESS).
                 // Transient coordinator errors must not tear down the consumption loop.
-                if (error.findBy?.('needsRejoin', true)) {
+                if (findErrorBy(error, 'needsRejoin', true)) {
                     this.destroy(error);
                 }
                 return;

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

@@ -35,6 +35,7 @@ export interface PreferredReadReplica {
 export declare const DeserializationErrorActions: {
     readonly FAIL: "fail";
     readonly SKIP: "skip";
+    readonly CONTINUE: "continue";
 };
 export type DeserializationErrorAction = (typeof DeserializationErrorActions)[keyof typeof DeserializationErrorActions];
 export interface DeserializationErrorContext {
@@ -47,6 +48,10 @@ export interface DeserializationErrorContext {
     timestamp: bigint;
     commit: Message['commit'];
 }
+export interface MessageDeserializationError {
+    error: unknown;
+    payloadType: BeforeHookPayloadType;
+}
 export type DeserializationErrorHandler = (context: DeserializationErrorContext) => DeserializationErrorAction;
 /**
  * @deprecated Use `DeserializationErrorHandler` instead.

package/dist/clients/consumer/types.js

@@ -1,6 +1,7 @@
 export const DeserializationErrorActions = {
     FAIL: 'fail',
-    SKIP: 'skip'
+    SKIP: 'skip',
+    CONTINUE: 'continue'
 };
 export const MessagesStreamModes = {
     LATEST: 'latest',

package/dist/clients/producer/producer.js

@@ -2,7 +2,7 @@ import { randomUUID } from 'crypto';
 import { createPromisifiedCallback, kCallbackPromise, runConcurrentCallbacks } from "../../apis/callbacks.js";
 import { FindCoordinatorKeyTypes, ProduceAcks } from "../../apis/enumerations.js";
 import { createDiagnosticContext, producerInitIdempotentChannel, producerSendsChannel, producerTransactionsChannel } from "../../diagnostic.js";
-import { GenericError, UserError } from "../../errors.js";
+import { findErrorBy, UserError } from "../../errors.js";
 import { runAsyncSeries } from "../../registries/abstract.js";
 import { kInstance, kTransaction, kTransactionAddOffsets, kTransactionAddPartitions, kTransactionCancel, kTransactionCommitOffset, kTransactionEnd, kTransactionFindCoordinator, kTransactionPrepare } from "../../symbols.js";
 import { emitExperimentalApiWarning, NumericMap } from "../../utils.js";
@@ -353,12 +353,7 @@ export class Producer extends Base {
                             retryCallback(error);
                             return;
                         }
-                        api(connection, FindCoordinatorKeyTypes.TRANSACTION, [transactionalId], (error, response) => {
-                            if (response && api.version < 4) {
-                                response.coordinators[0].key = transactionalId;
-                            }
-                            retryCallback(error, response);
-                        });
+                        api(connection, FindCoordinatorKeyTypes.TRANSACTION, [transactionalId], retryCallback);
                     });
                 }, attempt);
             }, (error, response) => {
@@ -775,11 +770,8 @@ export class Producer extends Base {
                 if (error) {
                     // If the last error was due to stale metadata, we retry the operation with this set of messages
                     // since the partition is already set, it should attempt on the new destination
-                    /* c8 ignore next 3 - Hard to test */
-                    const kafkaError = GenericError.isGenericError(error)
-                        ? error
-                        : null;
-                    const hasStaleMetadata = kafkaError?.findBy('hasStaleMetadata', true);
+                    /* c8 ignore next - Hard to test */
+                    const hasStaleMetadata = findErrorBy(error, 'hasStaleMetadata', true);
                     if (hasStaleMetadata && repeatOnStaleMetadata) {
                         this.clearMetadata();
                         this.#performSingleDestinationSend(topics, messages, timeout, acks, autocreateTopics, false, produceOptions, recoverOnProducerStateLoss, callback);
@@ -801,17 +793,16 @@ export class Producer extends Base {
                 callback(error, results);
             }, 0, [], error => {
                 /* c8 ignore next 3 - Hard to test */
-                if (!repeatOnStaleMetadata || !GenericError.isGenericError(error)) {
+                if (!repeatOnStaleMetadata) {
                     return false;
                 }
-                return !!error.findBy('hasStaleMetadata', true);
+                return !!findErrorBy(error, 'hasStaleMetadata', true);
             });
         });
     }
     #isProducerStateLost(error) {
-        const kafkaError = error;
-        return !!(GenericError.isGenericError(error) &&
-            (kafkaError.findBy('apiId', 'UNKNOWN_PRODUCER_ID') || kafkaError.findBy('apiId', 'OUT_OF_ORDER_SEQUENCE_NUMBER')));
+        return !!(findErrorBy(error, 'apiId', 'UNKNOWN_PRODUCER_ID') ||
+            findErrorBy(error, 'apiId', 'OUT_OF_ORDER_SEQUENCE_NUMBER'));
     }
     #recoverIdempotentProducer(messages, produceOptions, callback) {
         this.#producerInfo = undefined;
@@ -864,20 +855,17 @@ export class Producer extends Base {
         });
     }
     #handleFencingError(error) {
-        if (error.findBy?.('producerFenced', true)) {
+        if (findErrorBy(error, 'producerFenced', true)) {
             this.#producerInfo = undefined;
             this.#transaction = undefined;
         }
     }
     #handleError(error) {
-        const kafkaError = error;
-        if (kafkaError) {
-            if (kafkaError.findBy('code', 'PLT_KFK_NETWORK') ||
-                kafkaError.findBy('apiId', 'COORDINATOR_LOAD_IN_PROGRESS') ||
-                kafkaError.findBy('apiId', 'COORDINATOR_NOT_AVAILABLE') ||
-                kafkaError.findBy('apiId', 'NOT_COORDINATOR')) {
-                this.#coordinatorId = undefined;
-            }
+        if (findErrorBy(error, 'code', 'PLT_KFK_NETWORK') ||
+            findErrorBy(error, 'apiId', 'COORDINATOR_LOAD_IN_PROGRESS') ||
+            findErrorBy(error, 'apiId', 'COORDINATOR_NOT_AVAILABLE') ||
+            findErrorBy(error, 'apiId', 'NOT_COORDINATOR')) {
+            this.#coordinatorId = undefined;
         }
         return error;
     }

package/dist/errors.d.ts

@@ -28,6 +28,7 @@ export declare class MultipleErrors extends AggregateError {
     findBy<ErrorType extends GenericError | MultipleErrors = MultipleErrors>(property: string, value: unknown): ErrorType | null;
     toString(): string;
 }
+export declare function findErrorBy<ErrorType extends GenericError = GenericError>(error: Error | null | undefined, property: string, value: unknown): ErrorType | null;
 export * from './protocol/errors.ts';
 export declare class AuthenticationError extends GenericError {
     static code: ErrorCode;

package/dist/errors.js

@@ -98,6 +98,18 @@ export class MultipleErrors extends AggregateError {
         return `Error ${this.code}: ${this.message} (caused by: ${this.errors.map(error => error.toString()).join(', ')})`;
     }
 }
+// findBy only exists on the library's own error classes, but errors also come from user code, Node
+// internals and third parties. This brand checks first, so classification is total: an error that
+// cannot be classified reports no match instead of throwing. Use it for any error whose origin is
+// not statically known.
+export function findErrorBy(error, property, value) {
+    if (!error || !GenericError.isGenericError(error)) {
+        return null;
+    }
+    // GenericError and MultipleErrors declare findBy with different generic defaults, so the union is
+    // not callable. The brand check above guarantees the call is safe either way.
+    return error.findBy(property, value);
+}
 export * from "./protocol/errors.js";
 export class AuthenticationError extends GenericError {
     static code = 'PLT_KFK_AUTHENTICATION';

package/dist/network/connection-pool.js

@@ -92,7 +92,9 @@ export class ConnectionPool extends TypedEventEmitter {
     }
     #get(broker, callback) {
         if (this.#closed) {
-            callback(new Error('Connection pool is closed.'));
+            // A closed pool never reopens, so this must not be retried. It also has to be a library error:
+            // clients classify errors via findBy, which only exists on GenericError subclasses.
+            callback(new NetworkError('Connection pool is closed.', { canRetry: false, closed: true, broker }));
             return;
         }
         if (broker == null || broker.host == null || broker.port == null) {

package/dist/network/connection.js

@@ -4,8 +4,7 @@ import { createConnection } from 'node:net';
 import { connect as createTLSConnection } from 'node:tls';
 import { createPromisifiedCallback, kCallbackPromise } from "../apis/callbacks.js";
 import { allowedSASLMechanisms, SASLMechanisms } from "../apis/enumerations.js";
-import { clientSoftwareName, clientSoftwareVersion } from "../clients/base/options.js";
-import { apiVersionsV1, saslAuthenticateV0, saslAuthenticateV1, saslAuthenticateV2, saslHandshakeV1 } from "../apis/index.js";
+import { saslAuthenticateV2, saslHandshakeV1 } from "../apis/index.js";
 import { connectionsApiChannel, connectionsConnectsChannel, createDiagnosticContext, notifyCreation } from "../diagnostic.js";
 import { AuthenticationError, NetworkError, TimeoutError, UnexpectedCorrelationIdError, UserError } from "../errors.js";
 import { TypedEventEmitter } from "../events.js";
@@ -53,8 +52,6 @@ export class Connection extends TypedEventEmitter {
     #socketMustBeDrained;
     #detectMissingTLS;
     #reauthenticationTimeout;
-    // Negotiated once per connection: reauthentication runs the same path again.
-    #saslAuthenticateApi;
     constructor(clientId, options = {}) {
         super();
         this.setMaxListeners(0);
@@ -343,71 +340,28 @@ export class Connection extends TypedEventEmitter {
             this.#onConnectionError(host, port, diagnosticContext, new UserError(`SASL mechanism ${mechanism} not supported.`));
             return;
         }
-        this.#negotiateSaslAuthenticate(saslAuthenticate => {
-            saslHandshakeV1.api(this, mechanism, (error, response) => {
-                if (error) {
-                    this.#onConnectionError(host, port, diagnosticContext, new AuthenticationError('Cannot find a suitable SASL mechanism.', { cause: error }));
-                    return;
-                }
-                this.emit('sasl:handshake', response.mechanisms);
-                const callback = this.#onSaslAuthenticate.bind(this, host, port, diagnosticContext);
-                if (authenticate) {
-                    authenticate(mechanism, this, saslAuthenticate, username, password, token, callback);
-                }
-                else if (mechanism === SASLMechanisms.PLAIN) {
-                    saslPlain.authenticate(saslAuthenticate, this, username, password, callback);
-                }
-                else if (mechanism === SASLMechanisms.OAUTHBEARER) {
-                    saslOAuthBearer.authenticate(saslAuthenticate, this, token, oauthBearerExtensions, callback);
-                }
-                else if (mechanism === SASLMechanisms.GSSAPI) {
-                    callback(new UserError('No custom SASL/GSSAPI authenticator provided.'));
-                }
-                else {
-                    saslScramSha.authenticate(saslAuthenticate, this, mechanism.substring(6), username, password, defaultCrypto, callback);
-                }
-            });
-        });
-    }
-    /**
-     * Chooses the SaslAuthenticate version to authenticate with.
-     *
-     * The version cannot be assumed: v1 arrived in Apache Kafka 2.0 and v2 in 2.4, so pinning the
-     * newest makes authentication fail outright on older brokers, which answer an unparseable request
-     * with InvalidRequestException and drop the connection.
-     *
-     * Brokers accept ApiVersions before authentication precisely so that clients can ask, and it has
-     * to happen before SaslHandshake: once the handshake is sent the connection only accepts
-     * SaslAuthenticate. The result is cached because reauthentication runs this path again.
-     *
-     * SaslHandshake itself stays at v1. v0 signals the pre-1.0 flow, where the SASL tokens are written
-     * raw on the wire rather than wrapped in SaslAuthenticate requests, which this package does not
-     * implement.
-     */
-    #negotiateSaslAuthenticate(callback) {
-        if (this.#saslAuthenticateApi) {
-            callback(this.#saslAuthenticateApi);
-            return;
-        }
-        const candidates = [
-            [2, saslAuthenticateV2.api],
-            [1, saslAuthenticateV1.api],
-            [0, saslAuthenticateV0.api]
-        ];
-        apiVersionsV1.api(this, clientSoftwareName, clientSoftwareVersion, (error, response) => {
-            let selected;
-            /* c8 ignore next 3 - Only reachable against a broker which refuses ApiVersions before authentication */
+        saslHandshakeV1.api(this, mechanism, (error, response) => {
             if (error) {
-                selected = undefined;
+                this.#onConnectionError(host, port, diagnosticContext, new AuthenticationError('Cannot find a suitable SASL mechanism.', { cause: error }));
+                return;
+            }
+            this.emit('sasl:handshake', response.mechanisms);
+            const callback = this.#onSaslAuthenticate.bind(this, host, port, diagnosticContext);
+            if (authenticate) {
+                authenticate(mechanism, this, saslAuthenticateV2.api, username, password, token, callback);
+            }
+            else if (mechanism === SASLMechanisms.PLAIN) {
+                saslPlain.authenticate(saslAuthenticateV2.api, this, username, password, callback);
+            }
+            else if (mechanism === SASLMechanisms.OAUTHBEARER) {
+                saslOAuthBearer.authenticate(saslAuthenticateV2.api, this, token, oauthBearerExtensions, callback);
+            }
+            else if (mechanism === SASLMechanisms.GSSAPI) {
+                callback(new UserError('No custom SASL/GSSAPI authenticator provided.'));
             }
             else {
-                const advertised = response.apiKeys.find(api => api.apiKey === saslAuthenticateV2.api.key);
-                selected = candidates.find(([version]) => advertised && version >= advertised.minVersion && version <= advertised.maxVersion)?.[1];
+                saslScramSha.authenticate(saslAuthenticateV2.api, this, mechanism.substring(6), username, password, defaultCrypto, callback);
             }
-            // Falling back to the newest version keeps the previous behaviour for brokers which do not
-            // answer the probe, rather than failing a connection which would otherwise have worked.
-            this.#saslAuthenticateApi = selected ?? saslAuthenticateV2.api;
-            callback(this.#saslAuthenticateApi);
         });
     }
     /*

package/dist/protocol/definitions.js

@@ -7,5 +7,5 @@ export const EMPTY_BUFFER = Buffer.alloc(0);
 export const EMPTY_UUID = Buffer.alloc(UUID_SIZE);
 // Since it is serialized at either 0 (for nullable) or 1 (since length is stored as length + 1), it always uses a single byte
 export const EMPTY_OR_SINGLE_COMPACT_LENGTH_SIZE = INT8_SIZE;
-// Flexible-version messages use this zero-length tagged-field section.
+// TODO: Tagged fields are not supported yet
 export const EMPTY_TAGGED_FIELDS_BUFFER = Buffer.from([0]);

package/dist/protocol/reader.js

@@ -300,7 +300,7 @@ export class Reader {
         }
         return reader();
     }
-    // Skip unknown tagged fields because codecs do not expose them to callers.
+    // TODO: Tagged fields are not supported yet
     readTaggedFields() {
         const length = this.readUnsignedVarInt();
         for (let i = 0; i < length; i++) {

package/dist/protocol/records.d.ts

@@ -71,6 +71,7 @@ export interface KafkaRecord {
 export interface MessageToConsume extends KafkaRecord {
     topic: string;
     partition: number;
+    metadata?: Record<string, unknown>;
 }
 export interface RecordsBatch {
     firstOffset: bigint;

package/dist/protocol/writer.js

@@ -1,6 +1,6 @@
 import { DynamicBuffer } from '@platformatic/dynamic-buffer';
 import { humanize } from "../utils.js";
-import { EMPTY_TAGGED_FIELDS_BUFFER, EMPTY_UUID, UUID_SIZE } from "./definitions.js";
+import { EMPTY_TAGGED_FIELDS_BUFFER, EMPTY_UUID } from "./definitions.js";
 const instanceIdentifier = Symbol('plt.kafka.writer.instanceIdentifier');
 export class Writer {
     context;
@@ -125,12 +125,6 @@ export class Writer {
             return this.append(EMPTY_UUID);
         }
         const buffer = Buffer.from(value.replaceAll('-', ''), 'hex');
-        // UUIDs are fixed width and carry no length prefix, so anything that is not exactly 16 bytes
-        // would silently desync the rest of the request. Buffer.from() stops at the first non hex
-        // character, so a topic name used as a topic id would append nothing at all here.
-        if (buffer.length !== UUID_SIZE) {
-            throw new RangeError(`Expected a UUID, got ${JSON.stringify(value)}.`);
-        }
         this.#buffer.append(buffer);
         return this;
     }
@@ -144,9 +138,7 @@ export class Writer {
         else {
             this.appendInt32(value.length);
         }
-        if (value.length > 0) {
-            this.#buffer.append(value);
-        }
+        this.#buffer.append(value);
         return this;
     }
     // Note that this does not follow the wire protocol specification and thus the length is not +1ed
@@ -155,12 +147,7 @@ export class Writer {
             return this.appendVarInt(-1);
         }
         this.appendVarInt(value.length);
-        // Appending an empty buffer corrupts DynamicBuffer's positional reads, so it must be skipped:
-        // see https://github.com/platformatic/dynamic-buffer/issues/12. Record keys and values are
-        // allowed to be empty without being null, so this is reachable.
-        if (value.length > 0) {
-            this.#buffer.append(value);
-        }
+        this.#buffer.append(value);
         return this;
     }
     appendArray(value, entryWriter, compact = true, appendTrailingTaggedFields = true) {
@@ -223,7 +210,7 @@ export class Writer {
         }
         return this;
     }
-    // This client emits only empty tagged-field sections; it does not expose tagged fields to callers.
+    // TODO: Tagged fields are not supported yet
     appendTaggedFields(_ = []) {
         return this.append(EMPTY_TAGGED_FIELDS_BUFFER);
     }

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

@@ -1,5 +1,6 @@
 import { type ErrorObject, type Options, type ValidateFunction } from 'ajv';
 import { type Type } from 'avsc';
+import { type ConnectionOptions as TLSConnectionOptions } from 'node:tls';
 import { type Root } from 'protobufjs';
 import { type Callback } from '../apis/definitions.ts';
 import { type BeforeDeserializationHook, type BeforeHookPayloadType, type BeforeSerializationHook, type Deserializers, type Serializers } from '../clients/serde.ts';
@@ -7,10 +8,25 @@ import { type CredentialProvider, UserError } from '../index.ts';
 import { type MessageToConsume, type MessageToProduce } from '../protocol/records.ts';
 import { AbstractSchemaRegistry } from './abstract.ts';
 type ConfluentSchemaRegistryMessageToProduce = MessageToProduce<unknown, unknown, unknown, unknown>;
+export type UndiciDispatcher = NonNullable<RequestInit['dispatcher']>;
+export interface UndiciAgentOptions {
+    connect: TLSConnectionOptions;
+}
+export type UndiciAgentConstructor = new (options: UndiciAgentOptions) => UndiciDispatcher;
+export declare function createUndiciAgent(options: UndiciAgentOptions): UndiciDispatcher;
 export interface ConfluentSchemaRegistryMetadata {
-    schemas?: Record<BeforeHookPayloadType, number>;
+    schemas?: Partial<Record<BeforeHookPayloadType, number>>;
+}
+export interface ConfluentSchemaRegistryConsumedMetadata {
+    lengths?: {
+        key?: number;
+        value?: number;
+    };
 }
 export type ConfluentSchemaRegistryProtobufTypeMapper = (id: number, type: BeforeHookPayloadType, context: ConfluentSchemaRegistryMessageToProduce | MessageToConsume) => string;
+export type ConfluentSchemaRegistryHeaders = Record<string, string>;
+export type ConfluentSchemaRegistryHeadersProvider = () => ConfluentSchemaRegistryHeaders | Promise<ConfluentSchemaRegistryHeaders>;
+export type ConfluentSchemaRegistryRetryDelayGetter = (attempt: number, retries: number, error: Error) => number;
 export interface ConfluentSchemaRegistryOptions {
     url: string;
     auth?: {
@@ -18,10 +34,22 @@ export interface ConfluentSchemaRegistryOptions {
         password?: string | CredentialProvider;
         token?: string | CredentialProvider;
     };
+    headers?: ConfluentSchemaRegistryHeaders | ConfluentSchemaRegistryHeadersProvider;
+    timeout?: number;
+    retries?: number;
+    retryDelay?: number | ConfluentSchemaRegistryRetryDelayGetter;
+    tls?: TLSConnectionOptions;
+    ssl?: TLSConnectionOptions;
     protobufTypeMapper?: ConfluentSchemaRegistryProtobufTypeMapper;
     jsonValidateSend?: boolean;
     jsonAjvOptions?: Options;
 }
+export declare const defaultConfluentSchemaRegistryOptions: {
+    timeout: number;
+    retries: number;
+    retryDelay: number;
+};
+export declare const retriableSchemaRegistryStatuses: number[];
 export type SchemaValidationPhase = 'serialization' | 'deserialization';
 export interface SchemaValidationErrorProperties {
     schemaId: number;
@@ -49,6 +77,8 @@ export interface Schema {
     type: 'avro' | 'protobuf' | 'json';
     schema: Type | Root | ValidateFunction;
 }
+export declare function trackConsumedSchemaId(message: MessageToConsume | undefined, type: BeforeHookPayloadType, schemaId: number): void;
+export declare function trackConsumedPayloadLength(message: MessageToConsume | undefined, type: 'key' | 'value', data: Buffer): void;
 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;