@tstdl/base 0.92.167 → 0.93.0

package/migration/mongo/migration-state-repository.js

@@ -1,32 +0,0 @@
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-};
-var __metadata = (this && this.__metadata) || function (k, v) {
-    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
-};
-var __param = (this && this.__param) || function (paramIndex, decorator) {
-    return function (target, key) { decorator(target, key, paramIndex); }
-};
-import { ForwardArg, ResolveArg, Singleton, resolveArgumentType } from '../../injector/index.js';
-import { Logger } from '../../logger/index.js';
-import { Collection } from '../../database/mongo/classes.js';
-import { MongoEntityRepository, noopTransformer } from '../../database/mongo/mongo-entity-repository.js';
-import { mongoMigrationStateRepositoryModuleConfig } from './module.js';
-const indexes = [
-    { key: { name: 1 }, unique: true }
-];
-let MongoMigrationStateRepository = class MongoMigrationStateRepository extends MongoEntityRepository {
-    constructor(collection, logger) {
-        super(collection, noopTransformer, { logger, indexes });
-    }
-};
-MongoMigrationStateRepository = __decorate([
-    Singleton({ defaultArgumentProvider: () => mongoMigrationStateRepositoryModuleConfig.defaultMigrationStateRepositoryConfig }),
-    __param(0, ForwardArg()),
-    __param(1, ResolveArg('MongoMigrationStateRepository')),
-    __metadata("design:paramtypes", [Collection, Logger])
-], MongoMigrationStateRepository);
-export { MongoMigrationStateRepository };

package/migration/mongo/module.d.ts

@@ -1,12 +0,0 @@
-import type { MongoRepositoryConfig } from '../../database/mongo/index.js';
-import type { MigrationState } from '../../migration/migration-state.js';
-export type MongoMigrationStateRepositoryModuleConfig = {
-    defaultMigrationStateRepositoryConfig: MongoRepositoryConfig<MigrationState> | undefined;
-};
-export declare const mongoMigrationStateRepositoryModuleConfig: MongoMigrationStateRepositoryModuleConfig;
-/**
- * configure mongo migration state repository module
- * @param migrationStateRepositoryConfig repository configuration for states
- * @param register whether to register for {@link MigrationStateRepository}
- */
-export declare function configureMongoMigrationStateRepository(migrationStateRepositoryConfig: MongoRepositoryConfig<MigrationState>, register?: boolean): void;

package/migration/mongo/module.js

@@ -1,17 +0,0 @@
-import { Injector } from '../../injector/injector.js';
-import { MigrationStateRepository } from '../../migration/migration-state-repository.js';
-import { MongoMigrationStateRepository } from './migration-state-repository.js';
-export const mongoMigrationStateRepositoryModuleConfig = {
-    defaultMigrationStateRepositoryConfig: undefined
-};
-/**
- * configure mongo migration state repository module
- * @param migrationStateRepositoryConfig repository configuration for states
- * @param register whether to register for {@link MigrationStateRepository}
- */
-export function configureMongoMigrationStateRepository(migrationStateRepositoryConfig, register = true) {
-    mongoMigrationStateRepositoryModuleConfig.defaultMigrationStateRepositoryConfig = migrationStateRepositoryConfig;
-    if (register) {
-        Injector.registerSingleton(MigrationStateRepository, { useToken: MongoMigrationStateRepository });
-    }
-}

package/module/module-base.d.ts

@@ -1,18 +0,0 @@
-import type { CancellationSignal } from '../cancellation/index.js';
-import { CancellationToken } from '../cancellation/index.js';
-import type { StringMap } from '../types/index.js';
-import type { Module, ModuleMetric } from './module.js';
-import { ModuleState } from './module.js';
-export declare abstract class ModuleBase implements Module {
-    private runPromise;
-    private _state;
-    protected readonly cancellationToken: CancellationToken;
-    readonly name: string;
-    abstract readonly metrics: StringMap<ModuleMetric>;
-    get state(): ModuleState;
-    private get stateString();
-    constructor(name: string);
-    run(): Promise<void>;
-    stop(): Promise<void>;
-    protected abstract _run(cancellationSignal: CancellationSignal): Promise<void>;
-}

package/module/module-base.js

@@ -1,40 +0,0 @@
-import { CancellationToken } from '../cancellation/index.js';
-import { ModuleState } from './module.js';
-export class ModuleBase {
-    runPromise;
-    _state;
-    cancellationToken;
-    name;
-    get state() {
-        return this._state;
-    }
-    get stateString() {
-        return ModuleState[this._state].toLowerCase();
-    }
-    constructor(name) {
-        this.name = name;
-        this.runPromise = Promise.resolve();
-        this._state = ModuleState.Stopped;
-        this.cancellationToken = new CancellationToken();
-    }
-    async run() {
-        if (this._state != ModuleState.Stopped) {
-            throw new Error(`cannot start module, it is ${this.stateString}`);
-        }
-        this.cancellationToken.unset();
-        try {
-            this._state = ModuleState.Running;
-            this.runPromise = this._run(this.cancellationToken);
-            await this.runPromise;
-            this._state = ModuleState.Stopped;
-        }
-        catch (error) {
-            this._state = ModuleState.Erroneous;
-            throw error;
-        }
-    }
-    async stop() {
-        this.cancellationToken.set();
-        await this.runPromise.catch(() => { });
-    }
-}

package/module/module-metric-reporter.d.ts

@@ -1,29 +0,0 @@
-import type { CancellationSignal } from '../cancellation/index.js';
-import type { MetricAggregation, MetricAggregationOptions } from '../utils/moving-metric.js';
-import { MovingMetric } from '../utils/moving-metric.js';
-import type { ModuleMetric } from './module.js';
-export type MetricReport<Aggregation extends MetricAggregation> = {
-    displayName: string;
-    aggregation: Aggregation;
-    aggregationOptions?: MetricAggregationOptions<Aggregation>;
-};
-export type MetricReportRegistration = {
-    metric: ModuleMetric;
-    moving: MovingMetric;
-    reports: MetricReport<MetricAggregation>[];
-};
-export declare class ModuleMetricReporter {
-    private readonly metricGroups;
-    private readonly sampleInterval;
-    private readonly sampleCount;
-    private readonly reportEveryNthSample;
-    private longestGroupName;
-    private longestDisplayName;
-    constructor(sampleInterval: number, sampleCount: number, reportEveryNthSample: number);
-    register(groupName: string, ...metrics: {
-        metric: ModuleMetric;
-        reports: MetricReport<MetricAggregation>[];
-    }[]): void;
-    run(cancellationSignal: CancellationSignal): Promise<void>;
-    private updateNameLengths;
-}

package/module/module-metric-reporter.js

@@ -1,62 +0,0 @@
-/* eslint-disable no-console */
-import { reduce } from '../utils/iterable-helpers/reduce.js';
-import { MovingMetric } from '../utils/moving-metric.js';
-import { cancelableTimeout } from '../utils/timing.js';
-export class ModuleMetricReporter {
-    metricGroups;
-    sampleInterval;
-    sampleCount;
-    reportEveryNthSample;
-    longestGroupName;
-    longestDisplayName;
-    constructor(sampleInterval, sampleCount, reportEveryNthSample) {
-        this.sampleInterval = sampleInterval;
-        this.sampleCount = sampleCount;
-        this.reportEveryNthSample = reportEveryNthSample;
-        this.metricGroups = [];
-        this.longestGroupName = 0;
-        this.longestDisplayName = 0;
-    }
-    register(groupName, ...metrics) {
-        const registrations = metrics.map(({ metric, reports }) => {
-            const registration = {
-                metric,
-                moving: new MovingMetric(this.sampleCount * this.sampleInterval),
-                reports,
-            };
-            return registration;
-        });
-        this.metricGroups.push({ groupName, registrations });
-        this.updateNameLengths();
-    }
-    async run(cancellationSignal) {
-        let counter = 0;
-        while (cancellationSignal.isUnset) {
-            for (const { registrations } of this.metricGroups) {
-                for (const { metric, moving } of registrations) {
-                    moving.add(metric.getValue());
-                }
-            }
-            if (counter++ % this.reportEveryNthSample == 0) {
-                for (const { groupName, registrations } of this.metricGroups) {
-                    console.log(`--- ${groupName} `.padEnd(this.longestGroupName + 8));
-                    for (const { moving, reports } of registrations) {
-                        for (const report of reports) { // eslint-disable-line max-depth
-                            const value = moving.aggregate(report.aggregation, report.aggregationOptions);
-                            const paddedName = report.displayName.padEnd(this.longestDisplayName);
-                            console.log(`| ${paddedName} : ${value}`);
-                        }
-                    }
-                }
-            }
-            await cancelableTimeout(this.sampleInterval, cancellationSignal);
-        }
-    }
-    updateNameLengths() {
-        this.longestGroupName = reduce(this.metricGroups, (longest, { groupName }) => Math.max(longest, groupName.length), 0);
-        this.longestDisplayName = this.metricGroups
-            .flatMap((group) => group.registrations)
-            .flatMap((registration) => registration.reports)
-            .reduce((longest, report) => Math.max(longest, report.displayName.length), 0);
-    }
-}

package/openid-connect/mongo-oidc-state.repository.d.ts

@@ -1,21 +0,0 @@
-import type { CollectionArgument, MongoRepositoryConfig } from '../database/mongo/index.js';
-import { Collection, MongoEntityRepository } from '../database/mongo/index.js';
-import type { Resolvable } from '../injector/index.js';
-import { resolveArgumentType } from '../injector/index.js';
-import { Logger } from '../logger/index.js';
-import type { TypedOmit } from '../types/index.js';
-import type { OidcState } from './oidc-state.model.js';
-import { OidcStateRepository } from './oidc-state.repository.js';
-export type MongoOidcState = TypedOmit<OidcState, 'expiration'> & {
-    expiration: Date;
-};
-export declare class MongoOidcStateRepository extends MongoEntityRepository<OidcState, MongoOidcState> implements OidcStateRepository, Resolvable<CollectionArgument<MongoOidcState>> {
-    readonly [resolveArgumentType]: CollectionArgument<MongoOidcState>;
-    constructor(collection: Collection<MongoOidcState>, logger: Logger);
-}
-/**
- * configure mongo oidc state repository module
- * @param mongoOidcStateRepositoryConfig repository configuration for states
- * @param register whether to register for {@link OidcStateRepository}
- */
-export declare function configureMongoOidcStateRepository(mongoOidcStateRepositoryConfig: MongoRepositoryConfig<OidcState, MongoOidcState>, register?: boolean): void;

package/openid-connect/mongo-oidc-state.repository.js

@@ -1,52 +0,0 @@
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-};
-var __metadata = (this && this.__metadata) || function (k, v) {
-    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
-};
-var __param = (this && this.__param) || function (paramIndex, decorator) {
-    return function (target, key) { decorator(target, key, paramIndex); }
-};
-import { Collection, MongoEntityRepository, mapTo } from '../database/mongo/index.js';
-import { ForwardArg, ResolveArg, Singleton, resolveArgumentType } from '../injector/index.js';
-import { Injector } from '../injector/injector.js';
-import { Logger } from '../logger/index.js';
-import { OidcStateRepository } from './oidc-state.repository.js';
-let repositoryConfig;
-const indexes = [
-    { key: { value: 1 }, unique: true },
-    { key: { expiration: 1 }, expireAfterSeconds: 1 }
-];
-const transformer = {
-    transform: (state) => ({ ...state, expiration: new Date(state.expiration) }),
-    untransform: (state) => ({ ...state, expiration: state.expiration.getTime() }),
-    mapping: {
-        expiration: mapTo('expiration', (timestamp) => new Date(timestamp))
-    }
-};
-let MongoOidcStateRepository = class MongoOidcStateRepository extends MongoEntityRepository {
-    constructor(collection, logger) {
-        super(collection, transformer, { logger, indexes });
-    }
-};
-MongoOidcStateRepository = __decorate([
-    Singleton({ defaultArgumentProvider: () => repositoryConfig }),
-    __param(0, ForwardArg()),
-    __param(1, ResolveArg('MongoOidcStateRepository')),
-    __metadata("design:paramtypes", [Collection, Logger])
-], MongoOidcStateRepository);
-export { MongoOidcStateRepository };
-/**
- * configure mongo oidc state repository module
- * @param mongoOidcStateRepositoryConfig repository configuration for states
- * @param register whether to register for {@link OidcStateRepository}
- */
-export function configureMongoOidcStateRepository(mongoOidcStateRepositoryConfig, register = true) {
-    repositoryConfig = mongoOidcStateRepositoryConfig;
-    if (register) {
-        Injector.registerSingleton(OidcStateRepository, { useToken: MongoOidcStateRepository });
-    }
-}

package/openid-connect/oidc-state.repository.d.ts

@@ -1,4 +0,0 @@
-import { EntityRepository } from '../database/index.js';
-import type { OidcState } from './oidc-state.model.js';
-export declare abstract class OidcStateRepository extends EntityRepository<OidcState> {
-}

package/openid-connect/oidc-state.repository.js

@@ -1,3 +0,0 @@
-import { EntityRepository } from '../database/index.js';
-export class OidcStateRepository extends EntityRepository {
-}

package/process-shutdown.d.ts

@@ -1,9 +0,0 @@
-import type { CancellationSignal } from './cancellation/index.js';
-import { CancellationToken } from './cancellation/index.js';
-import type { Logger } from './logger/index.js';
-export declare function getShutdownToken(): CancellationToken;
-export declare function getShutdownSignal(): CancellationSignal;
-export declare function setProcessShutdownLogger(shutdownLogger: Logger): void;
-export declare function requestShutdown(exitCode?: number): void;
-export declare function forceShutdown(exitCode?: number): void;
-export declare function initializeSignals(): void;

package/process-shutdown.js

@@ -1,65 +0,0 @@
-import { CancellationToken } from './cancellation/index.js';
-import { isDefined, isUndefined } from './utils/type-guards.js';
-const quitSignals = ['SIGTERM', 'SIGINT', 'SIGHUP', 'SIGBREAK'];
-const quitEvents = ['uncaughtException' /* , 'multipleResolves' */, 'unhandledRejection', 'rejectionHandled'];
-let shutdownToken;
-export function getShutdownToken() {
-    if (isUndefined(shutdownToken)) {
-        shutdownToken = new CancellationToken();
-    }
-    return shutdownToken;
-}
-export function getShutdownSignal() {
-    return getShutdownToken().signal;
-}
-let logger;
-export function setProcessShutdownLogger(shutdownLogger) {
-    logger = shutdownLogger;
-}
-let shutdownRequested = false;
-export function requestShutdown(exitCode = 1) {
-    if (shutdownRequested) {
-        return;
-    }
-    shutdownRequested = true;
-    getShutdownToken().set();
-    const timeout = setTimeout(() => {
-        logger.warn('forcefully quitting after 20 seconds...');
-        setTimeout(() => process.exit(exitCode), 1);
-    }, 20000);
-    timeout.unref();
-}
-export function forceShutdown(exitCode = 1) {
-    logger.warn('forcefully quitting');
-    setTimeout(() => process.exit(exitCode), 1);
-}
-let signalsInitialized = false;
-export function initializeSignals() {
-    if (signalsInitialized || (typeof process == 'undefined')) {
-        return;
-    }
-    signalsInitialized = true;
-    let signalCounter = 0;
-    let quitReason;
-    process.on('beforeExit', () => {
-        if (isDefined(quitReason)) {
-            console.info('\nquit reason:', ...quitReason);
-        }
-    });
-    for (const event of quitEvents) {
-        process.on(event, (...args) => {
-            console.error(event, ...args);
-            quitReason = args;
-            requestShutdown();
-        });
-    }
-    for (const quitSignal of quitSignals) {
-        process.on(quitSignal, (signal) => {
-            logger.info(`${signal} received, quitting.`);
-            requestShutdown();
-            if (++signalCounter > 1) {
-                forceShutdown();
-            }
-        });
-    }
-}

package/queue/mongo/index.d.ts

@@ -1,4 +0,0 @@
-export * from './job.js';
-export * from './mongo-job.repository.js';
-export * from './queue.js';
-export * from './queue.provider.js';

package/queue/mongo/index.js

@@ -1,4 +0,0 @@
-export * from './job.js';
-export * from './mongo-job.repository.js';
-export * from './queue.js';
-export * from './queue.provider.js';

package/queue/mongo/job.d.ts

@@ -1,12 +0,0 @@
-import type { Entity, NewEntity } from '../../database/index.js';
-import type { Job } from '../../queue/index.js';
-import type { TypedOmit } from '../../types/index.js';
-export type MongoJob<T = unknown> = Entity & TypedOmit<Job<T>, 'id'> & {
-    queue: string;
-    jobId: string;
-    enqueueTimestamp: number;
-    tries: number;
-    lastDequeueTimestamp: number;
-    batch: null | string;
-};
-export type NewMongoJob<T> = NewEntity<MongoJob<T>>;

package/queue/mongo/job.js

@@ -1 +0,0 @@
-export {};

package/queue/mongo/mongo-job.repository.d.ts

@@ -1,13 +0,0 @@
-import type { CollectionArgument } from '../../database/mongo/index.js';
-import { Collection, MongoEntityRepository } from '../../database/mongo/index.js';
-import type { Resolvable } from '../../injector/index.js';
-import { resolveArgumentType } from '../../injector/index.js';
-import { Logger } from '../../logger/index.js';
-import { UniqueTagStrategy } from '../../queue/index.js';
-import type { MongoJob, NewMongoJob } from './job.js';
-export declare class MongoJobRepository<T> extends MongoEntityRepository<MongoJob<T>> implements Resolvable<CollectionArgument<MongoJob<T>>> {
-    readonly [resolveArgumentType]: CollectionArgument<MongoJob<T>>;
-    constructor(collection: Collection<MongoJob<T>>, logger: Logger);
-    insertWithUniqueTagStrategy(newJob: NewMongoJob<T>, uniqueTagStrategy: UniqueTagStrategy): Promise<MongoJob<T>>;
-    bulkInsertWithUniqueTagStrategy(newJobs: NewMongoJob<T>[], uniqueTagStrategy: UniqueTagStrategy): Promise<void>;
-}

package/queue/mongo/mongo-job.repository.js

@@ -1,54 +0,0 @@
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-};
-var __metadata = (this && this.__metadata) || function (k, v) {
-    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
-};
-var __param = (this && this.__param) || function (paramIndex, decorator) {
-    return function (target, key) { decorator(target, key, paramIndex); }
-};
-import { getNewId } from '../../database/index.js';
-import { Collection, MongoEntityRepository, noopTransformer } from '../../database/mongo/index.js';
-import { ForwardArg, ResolveArg, Singleton, resolveArgumentType } from '../../injector/index.js';
-import { Logger } from '../../logger/index.js';
-import { UniqueTagStrategy } from '../../queue/index.js';
-const indexes = [
-    { key: { queue: 1, jobId: 1 }, unique: true },
-    { key: { queue: 1, priority: 1, enqueueTimestamp: 1, lastDequeueTimestamp: 1, tries: 1 } },
-    { key: { queue: 1, tag: 1 } },
-    { key: { queue: 1, batch: 1 } },
-    { key: { queue: 1, tries: 1 } },
-];
-let MongoJobRepository = class MongoJobRepository extends MongoEntityRepository {
-    constructor(collection, logger) {
-        super(collection, noopTransformer, { indexes: indexes, logger });
-    }
-    async insertWithUniqueTagStrategy(newJob, uniqueTagStrategy) {
-        const { queue, tag, ...rest } = newJob;
-        const updateQuery = (uniqueTagStrategy == UniqueTagStrategy.KeepOld)
-            ? { $setOnInsert: { _id: getNewId(), ...rest } }
-            : { $set: rest, $setOnInsert: { _id: getNewId() } };
-        return await this.baseRepository.loadByFilterAndUpdate({ queue, tag }, updateQuery, { upsert: true, returnDocument: 'after' });
-    }
-    async bulkInsertWithUniqueTagStrategy(newJobs, uniqueTagStrategy) {
-        const bulk = this.baseRepository.bulk();
-        for (const newJob of newJobs) {
-            const { queue, tag, ...rest } = newJob;
-            const updateQuery = (uniqueTagStrategy == UniqueTagStrategy.KeepOld)
-                ? { $setOnInsert: { _id: getNewId(), ...rest } }
-                : { $set: rest, $setOnInsert: { _id: getNewId() } };
-            bulk.update({ queue, tag }, updateQuery, { upsert: true });
-        }
-        await bulk.execute(false);
-    }
-};
-MongoJobRepository = __decorate([
-    Singleton(),
-    __param(0, ForwardArg()),
-    __param(1, ResolveArg(MongoJobRepository.name)),
-    __metadata("design:paramtypes", [Collection, Logger])
-], MongoJobRepository);
-export { MongoJobRepository };

package/queue/mongo/queue.d.ts

@@ -1,38 +0,0 @@
-import type { CancellationSignal } from '../../cancellation/index.js';
-import { Lock } from '../../lock/index.js';
-import { MessageBusProvider } from '../../message-bus/index.js';
-import type { EnqueueManyItem, EnqueueManyOptions, EnqueueOneOptions, Job, JobTag } from '../../queue/index.js';
-import { Queue, type QueueConfig } from '../../queue/index.js';
-import { MongoJobRepository } from './mongo-job.repository.js';
-export declare class MongoQueue<T = unknown> extends Queue<T> {
-    private readonly repository;
-    private readonly lock;
-    private readonly queueKey;
-    private readonly messageBus;
-    readonly processTimeout: number;
-    readonly maxTries: number;
-    constructor(repository: MongoJobRepository<T>, lock: Lock, messageBusProvider: MessageBusProvider, key: string, config?: QueueConfig);
-    enqueue(data: T, options?: EnqueueOneOptions): Promise<Job<T>>;
-    enqueueMany(items: EnqueueManyItem<T>[], options?: EnqueueManyOptions & {
-        returnJobs?: false;
-    }): Promise<void>;
-    enqueueMany(items: EnqueueManyItem<T>[], options: EnqueueManyOptions & {
-        returnJobs: true;
-    }): Promise<Job<T>[]>;
-    enqueueMany(items: EnqueueManyItem<T>[], options?: EnqueueManyOptions): Promise<void | Job<T>[]>;
-    has(id: string): Promise<boolean>;
-    countByTag(tag: JobTag): Promise<number>;
-    get(id: string): Promise<Job<T> | undefined>;
-    getByTag(tag: JobTag): Promise<Job<T>[]>;
-    getByTags(tags: JobTag[]): Promise<Job<T>[]>;
-    cancel(id: string): Promise<void>;
-    cancelMany(ids: string[]): Promise<void>;
-    cancelByTag(tag: JobTag): Promise<void>;
-    cancelByTags(tags: JobTag[]): Promise<void>;
-    dequeue(): Promise<Job<T> | undefined>;
-    dequeueMany(count: number): Promise<Job<T>[]>;
-    acknowledge(job: Job<T>): Promise<void>;
-    acknowledgeMany(jobs: Job<T>[]): Promise<void>;
-    getConsumer(cancellationSignal: CancellationSignal): AsyncIterableIterator<Job<T>>;
-    getBatchConsumer(size: number, cancellationSignal: CancellationSignal): AsyncIterableIterator<Job<T>[]>;
-}