@forklaunch/implementation-worker-kafka 0.1.2 → 0.1.4

package/lib/__test__/schemaEquality.test.d.ts

@@ -1,2 +1,2 @@
 export {};
-//# sourceMappingURL=schemaEquality.test.d.ts.map
+//# sourceMappingURL=schemaEquality.test.d.ts.map

package/lib/__test__/schemaEquality.test.js

@@ -3,22 +3,14 @@ import { testSchemaEquality } from '@forklaunch/core/test';
 import { KafkaWorkerOptionsSchema as TypeboxKafkaWorkerOptionsSchema } from '../schemas/typebox/kafkaWorker.schema';
 import { KafkaWorkerOptionsSchema as ZodKafkaWorkerOptionsSchema } from '../schemas/zod/kafkaWorker.schema';
 describe('schema equality', () => {
-  it('should be equal for bullmq worker', () => {
-    expect(
-      isTrue(
-        testSchemaEquality(
-          ZodKafkaWorkerOptionsSchema,
-          TypeboxKafkaWorkerOptionsSchema,
-          {
+    it('should be equal for bullmq worker', () => {
+        expect(isTrue(testSchemaEquality(ZodKafkaWorkerOptionsSchema, TypeboxKafkaWorkerOptionsSchema, {
             brokers: ['localhost:9092'],
             clientId: 'test',
             groupId: 'test',
             retries: 1,
             interval: 1000,
             peekCount: 1
-          }
-        )
-      )
-    ).toBeTruthy();
-  });
+        }))).toBeTruthy();
+    });
 });

package/lib/consumers/index.d.ts

@@ -1,2 +1,2 @@
 export * from './kafkaWorker.consumer';
-//# sourceMappingURL=index.d.ts.map
+//# sourceMappingURL=index.d.ts.map

package/lib/consumers/kafkaWorker.consumer.d.ts

@@ -1,32 +1,19 @@
 import { WorkerConsumer } from '@forklaunch/interfaces-worker/interfaces';
-import {
-  WorkerEventEntity,
-  WorkerFailureHandler,
-  WorkerProcessFunction
-} from '@forklaunch/interfaces-worker/types';
+import { WorkerEventEntity, WorkerFailureHandler, WorkerProcessFunction } from '@forklaunch/interfaces-worker/types';
 import { WorkerOptions } from '../types/kafkaWorker.types';
-export declare class KafkaWorkerConsumer<
-  EventEntity extends WorkerEventEntity,
-  Options extends WorkerOptions
-> implements WorkerConsumer<EventEntity>
-{
-  protected readonly queueName: string;
-  protected readonly options: Options;
-  protected readonly processEventsFunction: WorkerProcessFunction<EventEntity>;
-  protected readonly failureHandler: WorkerFailureHandler<EventEntity>;
-  private kafka;
-  private producer;
-  private consumer;
-  private processedMessages;
-  constructor(
-    queueName: string,
-    options: Options,
-    processEventsFunction: WorkerProcessFunction<EventEntity>,
-    failureHandler: WorkerFailureHandler<EventEntity>
-  );
-  private setupConsumer;
-  peekEvents(): Promise<EventEntity[]>;
-  start(): Promise<void>;
-  close(): Promise<void>;
+export declare class KafkaWorkerConsumer<EventEntity extends WorkerEventEntity, Options extends WorkerOptions> implements WorkerConsumer<EventEntity> {
+    protected readonly queueName: string;
+    protected readonly options: Options;
+    protected readonly processEventsFunction: WorkerProcessFunction<EventEntity>;
+    protected readonly failureHandler: WorkerFailureHandler<EventEntity>;
+    private kafka;
+    private producer;
+    private consumer;
+    private processedMessages;
+    constructor(queueName: string, options: Options, processEventsFunction: WorkerProcessFunction<EventEntity>, failureHandler: WorkerFailureHandler<EventEntity>);
+    private setupConsumer;
+    peekEvents(): Promise<EventEntity[]>;
+    start(): Promise<void>;
+    close(): Promise<void>;
 }
-//# sourceMappingURL=kafkaWorker.consumer.d.ts.map
+//# sourceMappingURL=kafkaWorker.consumer.d.ts.map

package/lib/consumers/kafkaWorker.consumer.js

@@ -1,147 +1,149 @@
 import { Kafka } from 'kafkajs';
 export class KafkaWorkerConsumer {
-  queueName;
-  options;
-  processEventsFunction;
-  failureHandler;
-  kafka;
-  producer;
-  consumer;
-  processedMessages = new Set();
-  constructor(queueName, options, processEventsFunction, failureHandler) {
-    this.queueName = queueName;
-    this.options = options;
-    this.processEventsFunction = processEventsFunction;
-    this.failureHandler = failureHandler;
-    this.kafka = new Kafka({
-      clientId: this.options.clientId,
-      brokers: this.options.brokers
-    });
-    this.producer = this.kafka.producer();
-    this.consumer = this.kafka.consumer({
-      groupId: this.options.groupId
-    });
-  }
-  async setupConsumer() {
-    await this.consumer.connect();
-    await this.consumer.subscribe({
-      topic: this.queueName,
-      fromBeginning: false
-    });
-    await this.consumer.run({
-      eachMessage: async ({ topic, partition, message }) => {
-        if (!message.value) return;
-        const messageKey = `${topic}-${partition}-${message.offset}`;
-        if (this.processedMessages.has(messageKey)) {
-          return;
-        }
-        const events = JSON.parse(message.value.toString());
-        try {
-          await this.processEventsFunction(events);
-          this.processedMessages.add(messageKey);
-          await this.consumer.commitOffsets([
-            {
-              topic,
-              partition,
-              offset: (parseInt(message.offset) + 1).toString()
-            }
-          ]);
-        } catch (error) {
-          this.failureHandler([
-            {
-              value: events[0],
-              error: error
-            }
-          ]);
-          for (const event of events) {
-            if (event.retryCount <= this.options.retries) {
-              await this.producer.send({
-                topic: this.queueName,
-                messages: [
-                  {
-                    value: JSON.stringify([
-                      {
-                        ...event,
-                        retryCount: event.retryCount + 1
-                      }
-                    ]),
-                    key: event.id
-                  }
-                ]
-              });
-            }
-          }
-        }
-      }
-    });
-  }
-  async peekEvents() {
-    const events = [];
-    const admin = this.kafka.admin();
-    await admin.connect();
-    try {
-      // Get topic metadata to find partitions
-      const metadata = await admin.fetchTopicMetadata({
-        topics: [this.queueName]
-      });
-      const topic = metadata.topics[0];
-      if (!topic) {
-        return events;
-      }
-      // For each partition, get the latest offset
-      for (const partition of topic.partitions) {
-        const offsets = await admin.fetchTopicOffsets(this.queueName);
-        const partitionOffset = offsets.find(
-          (o) => o.partition === partition.partitionId
-        );
-        if (!partitionOffset) {
-          continue;
-        }
-        // Create a temporary consumer to read messages
-        const peekConsumer = this.kafka.consumer({
-          groupId: `${this.options.groupId}-peek-${Date.now()}`
+    queueName;
+    options;
+    processEventsFunction;
+    failureHandler;
+    kafka;
+    producer;
+    consumer;
+    processedMessages = new Set();
+    constructor(queueName, options, processEventsFunction, failureHandler) {
+        this.queueName = queueName;
+        this.options = options;
+        this.processEventsFunction = processEventsFunction;
+        this.failureHandler = failureHandler;
+        this.kafka = new Kafka({
+            clientId: this.options.clientId,
+            brokers: this.options.brokers
         });
-        try {
-          await peekConsumer.connect();
-          await peekConsumer.subscribe({
+        this.producer = this.kafka.producer();
+        this.consumer = this.kafka.consumer({
+            groupId: this.options.groupId
+        });
+    }
+    async setupConsumer() {
+        await this.consumer.connect();
+        await this.consumer.subscribe({
             topic: this.queueName,
             fromBeginning: false
-          });
-          const messagePromise = new Promise((resolve) => {
-            peekConsumer.run({
-              eachMessage: async ({ message }) => {
-                if (message.value && events.length < this.options.peekCount) {
-                  const messageEvents = JSON.parse(message.value.toString());
-                  events.push(...messageEvents);
-                  if (events.length >= this.options.peekCount) {
-                    resolve();
-                  }
+        });
+        await this.consumer.run({
+            eachMessage: async ({ topic, partition, message }) => {
+                if (!message.value)
+                    return;
+                const messageKey = `${topic}-${partition}-${message.offset}`;
+                if (this.processedMessages.has(messageKey)) {
+                    return;
+                }
+                const events = JSON.parse(message.value.toString());
+                try {
+                    await this.processEventsFunction(events);
+                    this.processedMessages.add(messageKey);
+                    await this.consumer.commitOffsets([
+                        {
+                            topic,
+                            partition,
+                            offset: (parseInt(message.offset) + 1).toString()
+                        }
+                    ]);
+                }
+                catch (error) {
+                    this.failureHandler([
+                        {
+                            value: events[0],
+                            error: error
+                        }
+                    ]);
+                    for (const event of events) {
+                        if (event.retryCount <= this.options.retries) {
+                            await this.producer.send({
+                                topic: this.queueName,
+                                messages: [
+                                    {
+                                        value: JSON.stringify([
+                                            {
+                                                ...event,
+                                                retryCount: event.retryCount + 1
+                                            }
+                                        ]),
+                                        key: event.id
+                                    }
+                                ]
+                            });
+                        }
+                    }
                 }
-              }
+            }
+        });
+    }
+    async peekEvents() {
+        const events = [];
+        const admin = this.kafka.admin();
+        await admin.connect();
+        try {
+            // Get topic metadata to find partitions
+            const metadata = await admin.fetchTopicMetadata({
+                topics: [this.queueName]
             });
-          });
-          await Promise.race([
-            messagePromise,
-            new Promise((resolve) => setTimeout(resolve, 5000))
-          ]);
-          if (events.length >= this.options.peekCount) {
-            break;
-          }
-        } finally {
-          await peekConsumer.disconnect();
+            const topic = metadata.topics[0];
+            if (!topic) {
+                return events;
+            }
+            // For each partition, get the latest offset
+            for (const partition of topic.partitions) {
+                const offsets = await admin.fetchTopicOffsets(this.queueName);
+                const partitionOffset = offsets.find((o) => o.partition === partition.partitionId);
+                if (!partitionOffset) {
+                    continue;
+                }
+                // Create a temporary consumer to read messages
+                const peekConsumer = this.kafka.consumer({
+                    groupId: `${this.options.groupId}-peek-${Date.now()}`
+                });
+                try {
+                    await peekConsumer.connect();
+                    await peekConsumer.subscribe({
+                        topic: this.queueName,
+                        fromBeginning: false
+                    });
+                    const messagePromise = new Promise((resolve) => {
+                        peekConsumer.run({
+                            eachMessage: async ({ message }) => {
+                                if (message.value && events.length < this.options.peekCount) {
+                                    const messageEvents = JSON.parse(message.value.toString());
+                                    events.push(...messageEvents);
+                                    if (events.length >= this.options.peekCount) {
+                                        resolve();
+                                    }
+                                }
+                            }
+                        });
+                    });
+                    await Promise.race([
+                        messagePromise,
+                        new Promise((resolve) => setTimeout(resolve, 5000))
+                    ]);
+                    if (events.length >= this.options.peekCount) {
+                        break;
+                    }
+                }
+                finally {
+                    await peekConsumer.disconnect();
+                }
+            }
+            return events;
         }
-      }
-      return events;
-    } finally {
-      await admin.disconnect();
+        finally {
+            await admin.disconnect();
+        }
+    }
+    async start() {
+        await this.setupConsumer();
+        await this.producer.connect();
+    }
+    async close() {
+        await this.producer.disconnect();
+        await this.consumer.disconnect();
     }
-  }
-  async start() {
-    await this.setupConsumer();
-    await this.producer.connect();
-  }
-  async close() {
-    await this.producer.disconnect();
-    await this.consumer.disconnect();
-  }
 }

package/lib/jest.config.d.ts

@@ -1,4 +1,4 @@
 import type { JestConfigWithTsJest } from 'ts-jest';
 declare const jestConfig: JestConfigWithTsJest;
 export default jestConfig;
-//# sourceMappingURL=jest.config.d.ts.map
+//# sourceMappingURL=jest.config.d.ts.map

package/lib/jest.config.js

@@ -1,19 +1,19 @@
 const jestConfig = {
-  preset: 'ts-jest/presets/default-esm', // or other ESM presets
-  moduleNameMapper: {
-    '^(\\.{1,2}/.*)\\.js$': '$1'
-  },
-  transform: {
-    // '^.+\\.[tj]sx?$' to process ts,js,tsx,jsx with `ts-jest`
-    // '^.+\\.m?[tj]sx?$' to process ts,js,tsx,jsx,mts,mjs,mtsx,mjsx with `ts-jest`
-    '^.+\\.[tj]sx?$': [
-      'ts-jest',
-      {
-        useESM: true
-      }
-    ],
-    '^.+\\.js$': 'babel-jest'
-  },
-  testPathIgnorePatterns: ['.*dist/', '.*node_modules/']
+    preset: 'ts-jest/presets/default-esm', // or other ESM presets
+    moduleNameMapper: {
+        '^(\\.{1,2}/.*)\\.js$': '$1'
+    },
+    transform: {
+        // '^.+\\.[tj]sx?$' to process ts,js,tsx,jsx with `ts-jest`
+        // '^.+\\.m?[tj]sx?$' to process ts,js,tsx,jsx,mts,mjs,mtsx,mjsx with `ts-jest`
+        '^.+\\.[tj]sx?$': [
+            'ts-jest',
+            {
+                useESM: true
+            }
+        ],
+        '^.+\\.js$': 'babel-jest'
+    },
+    testPathIgnorePatterns: ['.*dist/', '.*node_modules/']
 };
 export default jestConfig;

package/lib/producers/index.d.ts

@@ -1,2 +1,2 @@
 export * from './kafkaWorker.producer';
-//# sourceMappingURL=index.d.ts.map
+//# sourceMappingURL=index.d.ts.map

package/lib/producers/kafkaWorker.producer.d.ts

@@ -1,14 +1,11 @@
 import { WorkerEventEntity } from '@forklaunch/interfaces-worker/types';
 import { WorkerOptions } from '../types/kafkaWorker.types';
-export declare class KafkaWorkerProducer<
-  EventEntity extends WorkerEventEntity,
-  Options extends WorkerOptions
-> {
-  private readonly queueName;
-  private readonly options;
-  private producer;
-  constructor(queueName: string, options: Options);
-  enqueueJob(event: EventEntity): Promise<void>;
-  enqueueBatchJobs(events: EventEntity[]): Promise<void>;
+export declare class KafkaWorkerProducer<EventEntity extends WorkerEventEntity, Options extends WorkerOptions> {
+    private readonly queueName;
+    private readonly options;
+    private producer;
+    constructor(queueName: string, options: Options);
+    enqueueJob(event: EventEntity): Promise<void>;
+    enqueueBatchJobs(events: EventEntity[]): Promise<void>;
 }
-//# sourceMappingURL=kafkaWorker.producer.d.ts.map
+//# sourceMappingURL=kafkaWorker.producer.d.ts.map

package/lib/producers/kafkaWorker.producer.js

@@ -1,28 +1,28 @@
 import { Kafka } from 'kafkajs';
 export class KafkaWorkerProducer {
-  queueName;
-  options;
-  producer;
-  constructor(queueName, options) {
-    this.queueName = queueName;
-    this.options = options;
-    const kafka = new Kafka({
-      clientId: this.options.clientId,
-      brokers: this.options.brokers
-    });
-    this.producer = kafka.producer();
-    this.producer.connect();
-  }
-  async enqueueJob(event) {
-    await this.producer.send({
-      topic: this.queueName,
-      messages: [{ value: JSON.stringify([event]) }]
-    });
-  }
-  async enqueueBatchJobs(events) {
-    await this.producer.send({
-      topic: this.queueName,
-      messages: events.map((event) => ({ value: JSON.stringify(event) }))
-    });
-  }
+    queueName;
+    options;
+    producer;
+    constructor(queueName, options) {
+        this.queueName = queueName;
+        this.options = options;
+        const kafka = new Kafka({
+            clientId: this.options.clientId,
+            brokers: this.options.brokers
+        });
+        this.producer = kafka.producer();
+        this.producer.connect();
+    }
+    async enqueueJob(event) {
+        await this.producer.send({
+            topic: this.queueName,
+            messages: [{ value: JSON.stringify([event]) }]
+        });
+    }
+    async enqueueBatchJobs(events) {
+        await this.producer.send({
+            topic: this.queueName,
+            messages: events.map((event) => ({ value: JSON.stringify(event) }))
+        });
+    }
 }

package/lib/schemas/index.d.ts

@@ -1,2 +1,2 @@
 export * from './kafka.schema';
-//# sourceMappingURL=index.d.ts.map
+//# sourceMappingURL=index.d.ts.map

package/lib/schemas/kafka.schema.d.ts

@@ -1,64 +1,18 @@
-export declare const KafkaWorkerSchemas: <
-  SchemaValidator extends import('@forklaunch/validator').AnySchemaValidator
->(
-  options: Record<string, unknown> & {
+export declare const KafkaWorkerSchemas: <SchemaValidator extends import("@forklaunch/validator").AnySchemaValidator>(options: Record<string, unknown> & {
     validator: SchemaValidator;
-  }
-) => import('@forklaunch/core/mappers').SchemasByValidator<
-  SchemaValidator,
-  (options: Record<string, unknown>) => {
-    brokers: import('@sinclair/typebox').TArray<
-      import('@sinclair/typebox').TString
-    >;
-    clientId: import('@sinclair/typebox').TString;
-    groupId: import('@sinclair/typebox').TString;
-    retries: import('@sinclair/typebox').TTransform<
-      import('@sinclair/typebox').TUnion<
-        [
-          import('@sinclair/typebox').TNumber,
-          import('@sinclair/typebox').TString,
-          import('@sinclair/typebox').TBoolean,
-          import('@sinclair/typebox').TNull,
-          import('@sinclair/typebox').TDate,
-          import('@sinclair/typebox').TBigInt
-        ]
-      >,
-      number
-    >;
-    interval: import('@sinclair/typebox').TTransform<
-      import('@sinclair/typebox').TUnion<
-        [
-          import('@sinclair/typebox').TNumber,
-          import('@sinclair/typebox').TString,
-          import('@sinclair/typebox').TBoolean,
-          import('@sinclair/typebox').TNull,
-          import('@sinclair/typebox').TDate,
-          import('@sinclair/typebox').TBigInt
-        ]
-      >,
-      number
-    >;
-    peekCount: import('@sinclair/typebox').TTransform<
-      import('@sinclair/typebox').TUnion<
-        [
-          import('@sinclair/typebox').TNumber,
-          import('@sinclair/typebox').TString,
-          import('@sinclair/typebox').TBoolean,
-          import('@sinclair/typebox').TNull,
-          import('@sinclair/typebox').TDate,
-          import('@sinclair/typebox').TBigInt
-        ]
-      >,
-      number
-    >;
-  },
-  (options: Record<string, unknown>) => {
-    brokers: import('zod').ZodArray<import('zod').ZodString, 'many'>;
-    clientId: import('zod').ZodString;
-    groupId: import('zod').ZodString;
-    retries: import('zod').ZodNumber;
-    interval: import('zod').ZodNumber;
-    peekCount: import('zod').ZodNumber;
-  }
->;
-//# sourceMappingURL=kafka.schema.d.ts.map
+}) => import("@forklaunch/core/mappers").SchemasByValidator<SchemaValidator, (options: Record<string, unknown>) => {
+    brokers: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>;
+    clientId: import("@sinclair/typebox").TString;
+    groupId: import("@sinclair/typebox").TString;
+    retries: import("@sinclair/typebox").TTransform<import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TNumber, import("@sinclair/typebox").TString, import("@sinclair/typebox").TBoolean, import("@sinclair/typebox").TNull, import("@sinclair/typebox").TDate, import("@sinclair/typebox").TBigInt]>, number>;
+    interval: import("@sinclair/typebox").TTransform<import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TNumber, import("@sinclair/typebox").TString, import("@sinclair/typebox").TBoolean, import("@sinclair/typebox").TNull, import("@sinclair/typebox").TDate, import("@sinclair/typebox").TBigInt]>, number>;
+    peekCount: import("@sinclair/typebox").TTransform<import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TNumber, import("@sinclair/typebox").TString, import("@sinclair/typebox").TBoolean, import("@sinclair/typebox").TNull, import("@sinclair/typebox").TDate, import("@sinclair/typebox").TBigInt]>, number>;
+}, (options: Record<string, unknown>) => {
+    brokers: import("zod").ZodArray<import("zod").ZodString, "many">;
+    clientId: import("zod").ZodString;
+    groupId: import("zod").ZodString;
+    retries: import("zod").ZodNumber;
+    interval: import("zod").ZodNumber;
+    peekCount: import("zod").ZodNumber;
+}>;
+//# sourceMappingURL=kafka.schema.d.ts.map

package/lib/schemas/kafka.schema.js

@@ -1,7 +1,4 @@
 import { serviceSchemaResolver } from '@forklaunch/core/mappers';
 import { KafkaWorkerOptionsSchema as TypeBoxSchemas } from './typebox/kafkaWorker.schema';
 import { KafkaWorkerOptionsSchema as ZodSchemas } from './zod/kafkaWorker.schema';
-export const KafkaWorkerSchemas = serviceSchemaResolver(
-  () => TypeBoxSchemas,
-  () => ZodSchemas
-);
+export const KafkaWorkerSchemas = serviceSchemaResolver(() => TypeBoxSchemas, () => ZodSchemas);

package/lib/schemas/typebox/kafkaWorker.schema.d.ts

@@ -1,47 +1,9 @@
 export declare const KafkaWorkerOptionsSchema: {
-  brokers: import('@sinclair/typebox').TArray<
-    import('@sinclair/typebox').TString
-  >;
-  clientId: import('@sinclair/typebox').TString;
-  groupId: import('@sinclair/typebox').TString;
-  retries: import('@sinclair/typebox').TTransform<
-    import('@sinclair/typebox').TUnion<
-      [
-        import('@sinclair/typebox').TNumber,
-        import('@sinclair/typebox').TString,
-        import('@sinclair/typebox').TBoolean,
-        import('@sinclair/typebox').TNull,
-        import('@sinclair/typebox').TDate,
-        import('@sinclair/typebox').TBigInt
-      ]
-    >,
-    number
-  >;
-  interval: import('@sinclair/typebox').TTransform<
-    import('@sinclair/typebox').TUnion<
-      [
-        import('@sinclair/typebox').TNumber,
-        import('@sinclair/typebox').TString,
-        import('@sinclair/typebox').TBoolean,
-        import('@sinclair/typebox').TNull,
-        import('@sinclair/typebox').TDate,
-        import('@sinclair/typebox').TBigInt
-      ]
-    >,
-    number
-  >;
-  peekCount: import('@sinclair/typebox').TTransform<
-    import('@sinclair/typebox').TUnion<
-      [
-        import('@sinclair/typebox').TNumber,
-        import('@sinclair/typebox').TString,
-        import('@sinclair/typebox').TBoolean,
-        import('@sinclair/typebox').TNull,
-        import('@sinclair/typebox').TDate,
-        import('@sinclair/typebox').TBigInt
-      ]
-    >,
-    number
-  >;
+    brokers: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>;
+    clientId: import("@sinclair/typebox").TString;
+    groupId: import("@sinclair/typebox").TString;
+    retries: import("@sinclair/typebox").TTransform<import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TNumber, import("@sinclair/typebox").TString, import("@sinclair/typebox").TBoolean, import("@sinclair/typebox").TNull, import("@sinclair/typebox").TDate, import("@sinclair/typebox").TBigInt]>, number>;
+    interval: import("@sinclair/typebox").TTransform<import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TNumber, import("@sinclair/typebox").TString, import("@sinclair/typebox").TBoolean, import("@sinclair/typebox").TNull, import("@sinclair/typebox").TDate, import("@sinclair/typebox").TBigInt]>, number>;
+    peekCount: import("@sinclair/typebox").TTransform<import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TNumber, import("@sinclair/typebox").TString, import("@sinclair/typebox").TBoolean, import("@sinclair/typebox").TNull, import("@sinclair/typebox").TDate, import("@sinclair/typebox").TBigInt]>, number>;
 };
-//# sourceMappingURL=kafkaWorker.schema.d.ts.map
+//# sourceMappingURL=kafkaWorker.schema.d.ts.map