@drarzter/kafka-client 0.9.4 → 0.11.0

package/dist/core.d.mts

@@ -1,314 +0,0 @@
-import { q as KafkaLogger, K as KafkaInstrumentation, s as MessageLostContext, F as TtlExpiredContext, T as TopicMapConstraint, C as ClientId, G as GroupId, b as TopicDescriptor, v as SendOptions, M as MessageHeaders, B as BatchMessageItem, d as BatchSendOptions, z as TransactionContext, k as EventEnvelope, a as ConsumerOptions, h as ConsumerHandle, c as BatchMeta, J as WindowMeta, W as WindowConsumerOptions, t as RoutingOptions, A as TransactionalHandlerContext, r as KafkaMetrics } from './consumer.types-fFCag3VJ.mjs';
-export { e as BeforeConsumeResult, f as CircuitBreakerOptions, g as CompressionType, i as ConsumerInterceptor, D as DeduplicationOptions, j as DlqReason, E as EnvelopeHeaderOptions, H as HEADER_CORRELATION_ID, l as HEADER_EVENT_ID, m as HEADER_LAMPORT_CLOCK, n as HEADER_SCHEMA_VERSION, o as HEADER_TIMESTAMP, p as HEADER_TRACEPARENT, I as InferSchema, R as RetryOptions, S as SchemaLike, u as SchemaParseContext, w as SubscribeRetryOptions, x as TTopicMessageMap, y as TopicsFrom, L as buildEnvelopeHeaders, N as decodeHeaders, O as extractEnvelope, P as getEnvelopeContext, Q as runWithEnvelopeContext, U as topic } from './consumer.types-fFCag3VJ.mjs';
-import { K as KafkaTransport, I as IKafkaClient, D as DlqReplayOptions, R as ReadSnapshotOptions, t as CheckpointResult, z as RestoreCheckpointOptions, s as CheckpointRestoreResult, r as KafkaHealthResult, u as ConsumerGroupSummary, T as TopicDescription } from './client-1irhGEu0.mjs';
-export { C as CheckpointEntry, v as IKafkaAdmin, w as IKafkaConsumer, x as IKafkaLifecycle, y as IKafkaProducer, A as TopicPartitionInfo } from './client-1irhGEu0.mjs';
-
-/**
- * Options for `KafkaClient` constructor.
- *
- * @example
- * ```ts
- * const kafka = new KafkaClient(kafkaConfig, 'my-service', {
- *   transactionalId: `my-service-tx-${replicaIndex}`,
- *   lagThrottle: { maxLag: 10_000, pollIntervalMs: 3_000 },
- *   clockRecovery: { topics: ['orders.created'] },
- *   onMessageLost: (ctx) => alerting.fire('kafka.message-lost', ctx),
- *   instrumentation: [otelInstrumentation()],
- * });
- * ```
- */
-interface KafkaClientOptions {
-    /** Auto-create topics via admin before the first `sendMessage`, `sendBatch`, or `transaction` for each topic. Useful for development — not recommended in production. */
-    autoCreateTopics?: boolean;
-    /** When `true`, string topic keys are validated against any schema previously registered via a TopicDescriptor. Default: `true`. */
-    strictSchemas?: boolean;
-    /** Custom logger. Defaults to console with `[KafkaClient:<clientId>]` prefix. */
-    logger?: KafkaLogger;
-    /** Number of partitions for auto-created topics. Default: `1`. */
-    numPartitions?: number;
-    /** Client-wide instrumentation hooks (e.g. OTel). Applied to both send and consume paths. */
-    instrumentation?: KafkaInstrumentation[];
-    /**
-     * Override the transactional producer ID used by `transaction()`.
-     * Defaults to `${clientId}-tx`.
-     *
-     * The transactional ID must be **unique per producer instance** across the
-     * entire Kafka cluster. Two `KafkaClient` instances with the same ID will
-     * cause Kafka to fence one of the producers — the fenced producer will fail
-     * on the next `transaction()` call. Set a distinct value per replica when
-     * running multiple instances of the same service.
-     */
-    transactionalId?: string;
-    /**
-     * Called when a message is dropped without being sent to a DLQ.
-     * Fires when the handler throws after all retries, or schema validation fails — and `dlq` is not enabled.
-     * Use this to alert, log to external systems, or trigger fallback logic.
-     */
-    onMessageLost?: (ctx: MessageLostContext) => void | Promise<void>;
-    /**
-     * Called when a message is dropped due to TTL expiration (`messageTtlMs`).
-     * Fires instead of `onMessageLost` for expired messages when `dlq` is not enabled.
-     * When `dlq: true`, expired messages go to the DLQ and this callback is NOT called.
-     *
-     * **Client-wide fallback**: if `ConsumerOptions.onTtlExpired` is set on the consumer,
-     * it takes precedence over this client-level callback.
-     */
-    onTtlExpired?: (ctx: TtlExpiredContext) => void | Promise<void>;
-    /**
-     * Called whenever a consumer group rebalance occurs.
-     * - `'assign'` — new partitions were granted to this instance.
-     * - `'revoke'` — partitions were taken away (e.g. another consumer joined).
-     *
-     * Applied to every consumer created by this client. If you need per-consumer
-     * rebalance handling, use separate `KafkaClient` instances.
-     */
-    onRebalance?: (type: "assign" | "revoke", partitions: Array<{
-        topic: string;
-        partition: number;
-    }>) => void;
-    /**
-     * Recover the Lamport clock from the last message in the given topics on `connectProducer()`.
-     *
-     * On startup the producer creates a short-lived consumer, seeks each partition to its
-     * last message (`highWatermark − 1`), reads the `x-lamport-clock` header, then
-     * initialises `_lamportClock` to the maximum value found. This guarantees monotonic
-     * clock values across restarts without an external store.
-     *
-     * Topics that do not exist or are empty are silently skipped.
-     */
-    clockRecovery?: {
-        /** Topic names to scan for the highest Lamport clock. */
-        topics: string[];
-    };
-    /**
-     * Delay `sendMessage` / `sendBatch` / `sendTombstone` when the observed lag of a
-     * consumer group exceeds `maxLag`. Resumes immediately when lag drops below the threshold.
-     *
-     * Lag is polled via `getConsumerLag()` every `pollIntervalMs` in the background;
-     * no admin call is made on each individual send.
-     *
-     * When `maxWaitMs` is exceeded the send is unblocked with a warning — this is
-     * best-effort throttling, not hard back-pressure.
-     *
-     * Requires `connectProducer()` to have been called to start the polling loop.
-     */
-    lagThrottle?: {
-        /** Consumer group whose lag is monitored. Defaults to the client's default group. */
-        groupId?: string;
-        /** Lag threshold (number of messages) above which sends are delayed. */
-        maxLag: number;
-        /** How often to poll `getConsumerLag()`. Default: `5000` ms. */
-        pollIntervalMs?: number;
-        /**
-         * Maximum time (ms) a send will wait while throttled before proceeding anyway.
-         * Default: `30_000` ms.
-         */
-        maxWaitMs?: number;
-    };
-    /**
-     * Custom transport implementation.
-     *
-     * By default `KafkaClient` uses `ConfluentTransport` which wraps
-     * `@confluentinc/kafka-javascript` (librdkafka). Inject a different
-     * `KafkaTransport` to target an alternative broker library, or to supply
-     * a deterministic fake in unit tests without mocking the confluentinc module.
-     *
-     * @example
-     * ```ts
-     * // In tests — no jest.mock() needed
-     * const kafka = new KafkaClient('svc', 'grp', [], {
-     *   transport: new FakeTransport(),
-     * });
-     * ```
-     */
-    transport?: KafkaTransport;
-}
-
-/**
- * Type-safe Kafka client.
- * Wraps @confluentinc/kafka-javascript (librdkafka) with JSON serialization,
- * retries, DLQ, transactions, and interceptors.
- *
- * @typeParam T - Topic-to-message type mapping for compile-time safety.
- */
-declare class KafkaClient<T extends TopicMapConstraint<T>> implements IKafkaClient<T> {
-    readonly clientId: ClientId;
-    private readonly ctx;
-    /**
-     * Create a new KafkaClient.
-     * @param clientId Unique client identifier (used in Kafka metadata and logs).
-     * @param groupId Default consumer group ID for this client.
-     * @param brokers Array of broker addresses, e.g. `['localhost:9092']`.
-     * @param options Optional client-wide configuration.
-     * @example
-     * ```ts
-     * const kafka = new KafkaClient('my-service', 'my-service-group', ['localhost:9092'], {
-     *   lagThrottle: { maxLag: 10_000 },
-     *   onMessageLost: (ctx) => logger.error('Message lost', ctx),
-     * });
-     * await kafka.connectProducer();
-     * ```
-     */
-    constructor(clientId: ClientId, groupId: GroupId, brokers: string[], options?: KafkaClientOptions);
-    /** @inheritDoc */
-    sendMessage<D extends TopicDescriptor<string & keyof T, T[string & keyof T]>>(descriptor: D, message: D["__type"], options?: SendOptions): Promise<void>;
-    sendMessage<K extends keyof T>(topic: K, message: T[K], options?: SendOptions): Promise<void>;
-    /** @inheritDoc */
-    sendTombstone(topic: string, key: string, headers?: MessageHeaders): Promise<void>;
-    /** @inheritDoc */
-    sendBatch<D extends TopicDescriptor<string & keyof T, T[string & keyof T]>>(descriptor: D, messages: Array<BatchMessageItem<D["__type"]>>, options?: BatchSendOptions): Promise<void>;
-    sendBatch<K extends keyof T>(topic: K, messages: Array<BatchMessageItem<T[K]>>, options?: BatchSendOptions): Promise<void>;
-    /** @inheritDoc */
-    transaction(fn: (ctx: TransactionContext<T>) => Promise<void>): Promise<void>;
-    /** @inheritDoc */
-    connectProducer(): Promise<void>;
-    /** @internal */
-    disconnectProducer(): Promise<void>;
-    /** @inheritDoc */
-    startConsumer<K extends Array<keyof T>>(topics: K, handleMessage: (envelope: EventEnvelope<T[K[number]]>) => Promise<void>, options?: ConsumerOptions<T>): Promise<ConsumerHandle>;
-    startConsumer<D extends TopicDescriptor<string & keyof T, T[string & keyof T]>>(topics: D[], handleMessage: (envelope: EventEnvelope<D["__type"]>) => Promise<void>, options?: ConsumerOptions<T>): Promise<ConsumerHandle>;
-    /** @inheritDoc */
-    startBatchConsumer<K extends Array<keyof T>>(topics: K, handleBatch: (envelopes: EventEnvelope<T[K[number]]>[], meta: BatchMeta) => Promise<void>, options?: ConsumerOptions<T>): Promise<ConsumerHandle>;
-    startBatchConsumer<D extends TopicDescriptor<string & keyof T, T[string & keyof T]>>(topics: D[], handleBatch: (envelopes: EventEnvelope<D["__type"]>[], meta: BatchMeta) => Promise<void>, options?: ConsumerOptions<T>): Promise<ConsumerHandle>;
-    /** @inheritDoc */
-    consume<K extends keyof T & string>(topic: K, options?: ConsumerOptions<T>): AsyncIterableIterator<EventEnvelope<T[K]>>;
-    /** @inheritDoc */
-    startWindowConsumer<K extends keyof T & string>(topic: K, handler: (envelopes: EventEnvelope<T[K]>[], meta: WindowMeta) => Promise<void>, options: WindowConsumerOptions<T>): Promise<ConsumerHandle>;
-    /** @inheritDoc */
-    startRoutedConsumer<K extends Array<keyof T>>(topics: K, routing: RoutingOptions<T[K[number]]>, options?: ConsumerOptions<T>): Promise<ConsumerHandle>;
-    /** @inheritDoc */
-    startTransactionalConsumer<K extends Array<keyof T>>(topics: K, handler: (envelope: EventEnvelope<T[K[number]]>, tx: TransactionalHandlerContext<T>) => Promise<void>, options?: ConsumerOptions<T>): Promise<ConsumerHandle>;
-    /** @inheritDoc */
-    stopConsumer(groupId?: string): Promise<void>;
-    /** @inheritDoc */
-    pauseConsumer(groupId: string | undefined, assignments: Array<{
-        topic: string;
-        partitions: number[];
-    }>): void;
-    /** @inheritDoc */
-    resumeConsumer(groupId: string | undefined, assignments: Array<{
-        topic: string;
-        partitions: number[];
-    }>): void;
-    /** @inheritDoc */
-    replayDlq(topic: string, options?: DlqReplayOptions): Promise<{
-        replayed: number;
-        skipped: number;
-    }>;
-    /** @inheritDoc */
-    readSnapshot<K extends keyof T & string>(topic: K, options?: ReadSnapshotOptions): Promise<Map<string, EventEnvelope<T[K]>>>;
-    /** @inheritDoc */
-    checkpointOffsets(groupId: string | undefined, checkpointTopic: string): Promise<CheckpointResult>;
-    /** @inheritDoc */
-    restoreFromCheckpoint(groupId: string | undefined, checkpointTopic: string, options?: RestoreCheckpointOptions): Promise<CheckpointRestoreResult>;
-    /** @inheritDoc */
-    resetOffsets(groupId: string | undefined, topic: string, position: "earliest" | "latest"): Promise<void>;
-    /** @inheritDoc */
-    seekToOffset(groupId: string | undefined, assignments: Array<{
-        topic: string;
-        partition: number;
-        offset: string;
-    }>): Promise<void>;
-    /** @inheritDoc */
-    seekToTimestamp(groupId: string | undefined, assignments: Array<{
-        topic: string;
-        partition: number;
-        timestamp: number;
-    }>): Promise<void>;
-    /** @inheritDoc */
-    getConsumerLag(groupId?: string): Promise<Array<{
-        topic: string;
-        partition: number;
-        lag: number;
-    }>>;
-    /** @inheritDoc */
-    checkStatus(): Promise<KafkaHealthResult>;
-    /** @inheritDoc */
-    listConsumerGroups(): Promise<ConsumerGroupSummary[]>;
-    /** @inheritDoc */
-    describeTopics(topics?: string[]): Promise<TopicDescription[]>;
-    /** @inheritDoc */
-    deleteRecords(topic: string, partitions: Array<{
-        partition: number;
-        offset: string;
-    }>): Promise<void>;
-    /** @inheritDoc */
-    getCircuitState(topic: string, partition: number, groupId?: string): {
-        status: "closed" | "open" | "half-open";
-        failures: number;
-        windowSize: number;
-    } | undefined;
-    /** @inheritDoc */
-    getMetrics(topic?: string): Readonly<KafkaMetrics>;
-    /** @inheritDoc */
-    resetMetrics(topic?: string): void;
-    getClientId(): ClientId;
-    /** @inheritDoc */
-    disconnect(drainTimeoutMs?: number): Promise<void>;
-    /** NestJS lifecycle hook — called automatically on module teardown. */
-    onModuleDestroy(): Promise<void>;
-    /** @inheritDoc */
-    enableGracefulShutdown(signals?: NodeJS.Signals[], drainTimeoutMs?: number): void;
-}
-
-/**
- * Error thrown when a consumer message handler fails.
- * @example
- * ```ts
- * await kafka.startConsumer(['orders'], async (envelope) => {
- *   try { await process(envelope); }
- *   catch (err) {
- *     if (err instanceof KafkaProcessingError) {
- *       console.error(err.topic, err.originalMessage);
- *     }
- *   }
- * });
- * ```
- */
-declare class KafkaProcessingError extends Error {
-    readonly topic: string;
-    readonly originalMessage: unknown;
-    readonly cause?: Error;
-    constructor(message: string, topic: string, originalMessage: unknown, options?: {
-        cause?: Error;
-    });
-}
-/**
- * Error thrown when schema validation fails on send or consume.
- * @example
- * ```ts
- * try { await kafka.sendMessage('orders.created', invalidPayload); }
- * catch (err) {
- *   if (err instanceof KafkaValidationError) {
- *     console.error('Validation failed for topic:', err.topic);
- *   }
- * }
- * ```
- */
-declare class KafkaValidationError extends Error {
-    readonly topic: string;
-    readonly originalMessage: unknown;
-    readonly cause?: Error;
-    constructor(topic: string, originalMessage: unknown, options?: {
-        cause?: Error;
-    });
-}
-/**
- * Error thrown when all retry attempts are exhausted for a message.
- * @example
- * ```ts
- * const kafka = new KafkaClient(config, groupId, { onMessageLost: (ctx) => {
- *   if (ctx.error instanceof KafkaRetryExhaustedError) {
- *     console.error(`Exhausted after ${ctx.error.attempts} attempts on ${ctx.error.topic}`);
- *   }
- * }});
- * ```
- */
-declare class KafkaRetryExhaustedError extends KafkaProcessingError {
-    readonly attempts: number;
-    constructor(topic: string, originalMessage: unknown, attempts: number, options?: {
-        cause?: Error;
-    });
-}
-
-export { BatchMessageItem, BatchMeta, BatchSendOptions, CheckpointRestoreResult, CheckpointResult, ClientId, ConsumerGroupSummary, ConsumerHandle, ConsumerOptions, DlqReplayOptions, EventEnvelope, GroupId, IKafkaClient, KafkaClient, type KafkaClientOptions, KafkaHealthResult, KafkaInstrumentation, KafkaLogger, KafkaMetrics, KafkaProcessingError, KafkaRetryExhaustedError, KafkaValidationError, MessageHeaders, MessageLostContext, ReadSnapshotOptions, RestoreCheckpointOptions, RoutingOptions, SendOptions, TopicDescription, TopicDescriptor, TopicMapConstraint, TransactionContext, TransactionalHandlerContext, TtlExpiredContext, WindowConsumerOptions, WindowMeta };

package/dist/index.d.mts

@@ -1,128 +0,0 @@
-import { KafkaClientOptions } from './core.mjs';
-export { KafkaClient, KafkaProcessingError, KafkaRetryExhaustedError, KafkaValidationError } from './core.mjs';
-import { T as TopicMapConstraint, C as ClientId, G as GroupId, K as KafkaInstrumentation, S as SchemaLike, a as ConsumerOptions, b as TopicDescriptor } from './consumer.types-fFCag3VJ.mjs';
-export { B as BatchMessageItem, c as BatchMeta, d as BatchSendOptions, e as BeforeConsumeResult, f as CircuitBreakerOptions, g as CompressionType, h as ConsumerHandle, i as ConsumerInterceptor, D as DeduplicationOptions, j as DlqReason, E as EnvelopeHeaderOptions, k as EventEnvelope, H as HEADER_CORRELATION_ID, l as HEADER_EVENT_ID, m as HEADER_LAMPORT_CLOCK, n as HEADER_SCHEMA_VERSION, o as HEADER_TIMESTAMP, p as HEADER_TRACEPARENT, I as InferSchema, q as KafkaLogger, r as KafkaMetrics, M as MessageHeaders, s as MessageLostContext, R as RetryOptions, t as RoutingOptions, u as SchemaParseContext, v as SendOptions, w as SubscribeRetryOptions, x as TTopicMessageMap, y as TopicsFrom, z as TransactionContext, A as TransactionalHandlerContext, F as TtlExpiredContext, W as WindowConsumerOptions, J as WindowMeta, L as buildEnvelopeHeaders, N as decodeHeaders, O as extractEnvelope, P as getEnvelopeContext, Q as runWithEnvelopeContext, U as topic } from './consumer.types-fFCag3VJ.mjs';
-import { DynamicModule, OnModuleInit } from '@nestjs/common';
-import { DiscoveryService, ModuleRef } from '@nestjs/core';
-import { I as IKafkaClient, r as KafkaHealthResult } from './client-1irhGEu0.mjs';
-export { C as CheckpointEntry, s as CheckpointRestoreResult, t as CheckpointResult, u as ConsumerGroupSummary, D as DlqReplayOptions, v as IKafkaAdmin, w as IKafkaConsumer, x as IKafkaLifecycle, y as IKafkaProducer, R as ReadSnapshotOptions, z as RestoreCheckpointOptions, T as TopicDescription, A as TopicPartitionInfo } from './client-1irhGEu0.mjs';
-
-/** Shared configuration fields for both `register()` and `registerAsync()`. */
-interface KafkaModuleBaseOptions {
-    /** Optional name for multi-client setups. Must match `@InjectKafkaClient(name)`. */
-    name?: string;
-    /** If true, makes KAFKA_CLIENT available globally without importing KafkaModule in every feature module. */
-    isGlobal?: boolean;
-}
-/** Synchronous configuration for `KafkaModule.register()`. */
-interface KafkaModuleOptions extends KafkaModuleBaseOptions {
-    /** Unique Kafka client identifier. */
-    clientId: ClientId;
-    /** Consumer group identifier. */
-    groupId: GroupId;
-    /** List of Kafka broker addresses. */
-    brokers: string[];
-    /** Auto-create topics via admin on first use (send/consume). Useful for development. */
-    autoCreateTopics?: boolean;
-    /** When `true`, string topic keys are validated against any schema previously registered via a TopicDescriptor. Default: `true`. */
-    strictSchemas?: boolean;
-    /** Number of partitions for auto-created topics. Default: `1`. */
-    numPartitions?: number;
-    /** Client-wide instrumentation hooks (e.g. OTel). Applied to both send and consume paths. */
-    instrumentation?: KafkaInstrumentation[];
-    /** Called when a message is dropped without being sent to a DLQ. @see `KafkaClientOptions.onMessageLost` */
-    onMessageLost?: KafkaClientOptions["onMessageLost"];
-    /** Called whenever a consumer group rebalance occurs. @see `KafkaClientOptions.onRebalance` */
-    onRebalance?: KafkaClientOptions["onRebalance"];
-}
-/** Async configuration for `KafkaModule.registerAsync()` with dependency injection. */
-interface KafkaModuleAsyncOptions extends KafkaModuleBaseOptions {
-    imports?: any[];
-    useFactory: (...args: any[]) => KafkaModuleOptions | Promise<KafkaModuleOptions>;
-    inject?: any[];
-}
-/**
- * NestJS dynamic module for registering type-safe Kafka clients.
- * Use `register()` for static config or `registerAsync()` for DI-based config.
- */
-declare class KafkaModule {
-    /** Register a Kafka client with static options. */
-    static register<T extends TopicMapConstraint<T>>(options: KafkaModuleOptions): DynamicModule;
-    /** Register a Kafka client with async/factory-based options. */
-    static registerAsync<T extends TopicMapConstraint<T>>(asyncOptions: KafkaModuleAsyncOptions): DynamicModule;
-    private static buildClient;
-}
-
-/** Default DI token for the Kafka client. */
-declare const KAFKA_CLIENT = "KAFKA_CLIENT";
-/** Returns the DI token for a named (or default) Kafka client instance. */
-declare const getKafkaClientToken: (name?: string) => string;
-
-/** Reflect metadata key used to store `@SubscribeTo` entries on a class constructor. */
-declare const KAFKA_SUBSCRIBER_METADATA = "KAFKA_SUBSCRIBER_METADATA";
-/** Internal shape stored per `@SubscribeTo()` decoration on a class. */
-interface KafkaSubscriberMetadata {
-    /** Resolved topic name strings (descriptors are unwrapped to their `__topic` string). */
-    topics: string[];
-    /** Per-topic schema validators extracted from `TopicDescriptor` objects (if any). */
-    schemas?: Map<string, SchemaLike>;
-    /** Additional consumer options forwarded to `startConsumer` / `startBatchConsumer`. */
-    options?: ConsumerOptions;
-    /** Named client identifier — resolves to `KAFKA_CLIENT_<clientName>` in the DI container. */
-    clientName?: string;
-    /** When `true`, routes to `startBatchConsumer` instead of `startConsumer`. */
-    batch?: boolean;
-    /** Name of the decorated method on the provider class. */
-    methodName?: string | symbol;
-}
-/** Inject a `KafkaClient` instance. Pass a name to target a specific named client. */
-declare const InjectKafkaClient: (name?: string) => ParameterDecorator;
-/**
- * Method decorator that auto-subscribes the decorated method to one or more Kafka topics
- * when the NestJS module initialises.
- *
- * The decorated method receives a fully-decoded `EventEnvelope` for each message
- * (or an array of envelopes + `BatchMeta` when `batch: true`).
- *
- * @param topics One or more topic names or `TopicDescriptor` objects. Schemas embedded in
- *   descriptors are automatically extracted and forwarded to the consumer.
- * @param options Consumer and routing options:
- *   - All `ConsumerOptions` fields (`groupId`, `retry`, `dlq`, `fromBeginning`, …)
- *   - `clientName` — target a named `KafkaClient` (resolves `KAFKA_CLIENT_<name>` from the DI container)
- *   - `batch` — use `startBatchConsumer` instead of `startConsumer`
- *
- * @example
- * ```ts
- * @SubscribeTo('orders.created', { groupId: 'orders-svc', retry: { maxRetries: 3 } })
- * async handleOrder(envelope: EventEnvelope<Order>) { ... }
- *
- * @SubscribeTo(OrdersTopic, { batch: true })
- * async handleBatch(envelopes: EventEnvelope<Order>[], meta: BatchMeta) { ... }
- * ```
- */
-declare const SubscribeTo: (topics: string | string[] | TopicDescriptor | TopicDescriptor[] | (string | TopicDescriptor)[], options?: ConsumerOptions & {
-    clientName?: string;
-    batch?: boolean;
-}) => MethodDecorator;
-
-/** Discovers `@SubscribeTo()` decorators and wires them to their Kafka clients on startup. */
-declare class KafkaExplorer implements OnModuleInit {
-    private readonly discoveryService;
-    private readonly moduleRef;
-    private readonly logger;
-    constructor(discoveryService: DiscoveryService, moduleRef: ModuleRef);
-    /**
-     * Scan all NestJS providers for `@SubscribeTo()` metadata and wire each decorated
-     * method to its Kafka client via `startConsumer` or `startBatchConsumer`.
-     *
-     * Called automatically by the NestJS lifecycle — do not invoke manually.
-     */
-    onModuleInit(): Promise<void>;
-}
-
-/** Health check service. Call `check(client)` to verify broker connectivity. */
-declare class KafkaHealthIndicator {
-    check<T extends TopicMapConstraint<T>>(client: IKafkaClient<T>): Promise<KafkaHealthResult>;
-}
-
-export { ClientId, ConsumerOptions, GroupId, IKafkaClient, InjectKafkaClient, KAFKA_CLIENT, KAFKA_SUBSCRIBER_METADATA, KafkaClientOptions, KafkaExplorer, KafkaHealthIndicator, KafkaHealthResult, KafkaInstrumentation, KafkaModule, type KafkaModuleAsyncOptions, type KafkaModuleOptions, type KafkaSubscriberMetadata, SchemaLike, SubscribeTo, TopicDescriptor, TopicMapConstraint, getKafkaClientToken };

package/dist/otel.d.mts

@@ -1,27 +0,0 @@
-import { K as KafkaInstrumentation } from './consumer.types-fFCag3VJ.mjs';
-
-/**
- * Create a `KafkaInstrumentation` that automatically propagates
- * W3C Trace Context via Kafka headers.
- *
- * Requires `@opentelemetry/api` as a peer dependency.
- *
- * **Send path:** injects `traceparent` into message headers from the
- * active OpenTelemetry context.
- *
- * **Consume path:** extracts `traceparent` from message headers,
- * starts a `CONSUMER` span as a child of the extracted context,
- * and ends it when the handler completes.
- *
- * @example
- * ```ts
- * import { otelInstrumentation } from '@drarzter/kafka-client/otel';
- *
- * const kafka = new KafkaClient('my-app', 'my-group', brokers, {
- *   instrumentation: [otelInstrumentation()],
- * });
- * ```
- */
-declare function otelInstrumentation(): KafkaInstrumentation;
-
-export { otelInstrumentation };