@tstdl/base 0.93.87 → 0.93.90

package/task-queue/postgres/task-queue.provider.d.ts

@@ -0,0 +1,7 @@
+import { TaskQueueProvider, type QueueConfig } from '../../task-queue/index.js';
+import type { ObjectLiteral } from '../../types/index.js';
+import { PostgresQueue } from './task-queue.js';
+export declare class PostgresTaskQueueProvider extends TaskQueueProvider {
+    #private;
+    get<Data extends ObjectLiteral, State extends ObjectLiteral, Result extends ObjectLiteral>(namespace: string, config?: QueueConfig): PostgresQueue<Data, State, Result>;
+}

package/{queue/postgres/queue.provider.js → task-queue/postgres/task-queue.provider.js}

@@ -7,15 +7,15 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 import { Singleton } from '../../injector/decorators.js';
 import { inject } from '../../injector/inject.js';
 import { Injector } from '../../injector/injector.js';
-import { QueueProvider } from '../../queue/index.js';
-import { PostgresQueue } from './queue.js';
-let PostgresQueueProvider = class PostgresQueueProvider extends QueueProvider {
+import { TaskQueueProvider } from '../../task-queue/index.js';
+import { PostgresQueue } from './task-queue.js';
+let PostgresTaskQueueProvider = class PostgresTaskQueueProvider extends TaskQueueProvider {
     #injector = inject(Injector);
-    get(name, config) {
-        return this.#injector.resolve((PostgresQueue), { ...config, name: name });
+    get(namespace, config) {
+        return this.#injector.resolve((PostgresQueue), { ...config, namespace });
     }
 };
-PostgresQueueProvider = __decorate([
+PostgresTaskQueueProvider = __decorate([
     Singleton()
-], PostgresQueueProvider);
-export { PostgresQueueProvider };
+], PostgresTaskQueueProvider);
+export { PostgresTaskQueueProvider };

package/task-queue/postgres/task.model.d.ts

@@ -0,0 +1,39 @@
+import { BaseEntity, type Json, type Timestamp } from '../../orm/index.js';
+import type { ObjectLiteral, TypedOmit } from '../../types/types.js';
+import { DependencyJoinMode, type Task, TaskState } from '../task-queue.js';
+export declare abstract class PostgresTaskBase<Data extends ObjectLiteral = ObjectLiteral, State extends ObjectLiteral = ObjectLiteral, Result extends ObjectLiteral = ObjectLiteral> extends BaseEntity implements TypedOmit<Task<Data, State, Result>, 'parentId'> {
+    namespace: string;
+    type: string;
+    status: TaskState;
+    idempotencyKey: string | null;
+    traceId: string | null;
+    tags: string[];
+    completeAfterTags: string[];
+    scheduleAfterTags: string[];
+    failFast: boolean;
+    dependencyJoinMode: DependencyJoinMode;
+    dependencyTriggerStates: TaskState[];
+    priority: number;
+    token: string | null;
+    creationTimestamp: Timestamp;
+    priorityAgeTimestamp: Timestamp;
+    scheduleTimestamp: Timestamp;
+    startTimestamp: Timestamp | null;
+    timeToLive: Timestamp | null;
+    visibilityDeadline: Timestamp | null;
+    completeTimestamp: Timestamp | null;
+    tries: number;
+    progress: number;
+    data: Json<Data> | null;
+    state: Json<State> | null;
+    result: Json<Result> | null;
+    error: Json<ObjectLiteral> | null;
+}
+export declare class PostgresTask<Data extends ObjectLiteral = ObjectLiteral, State extends ObjectLiteral = ObjectLiteral, Result extends ObjectLiteral = ObjectLiteral> extends PostgresTaskBase<Data, State, Result> implements Task<Data, State, Result> {
+    static readonly entityName = "Task";
+    parentId: string | null;
+}
+export declare class PostgresTaskArchive<Data extends ObjectLiteral = ObjectLiteral, State extends ObjectLiteral = ObjectLiteral, Result extends ObjectLiteral = ObjectLiteral> extends PostgresTaskBase<Data, State, Result> implements PostgresTask<Data, State, Result> {
+    static readonly entityName = "TaskArchive";
+    parentId: string | null;
+}

package/task-queue/postgres/task.model.js

@@ -0,0 +1,178 @@
+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);
+};
+import { BaseEntity, Index, JsonProperty, Reference, Table, TimestampProperty, Unique, UuidProperty } from '../../orm/index.js';
+import { Array as ArrayProperty, BooleanProperty, Enumeration, Integer, NumberProperty, StringProperty } from '../../schema/index.js';
+import { DependencyJoinMode, TaskState } from '../task-queue.js';
+export class PostgresTaskBase extends BaseEntity {
+    namespace;
+    type;
+    status;
+    idempotencyKey;
+    traceId;
+    tags;
+    completeAfterTags;
+    scheduleAfterTags;
+    failFast;
+    dependencyJoinMode;
+    dependencyTriggerStates;
+    priority;
+    token;
+    creationTimestamp;
+    priorityAgeTimestamp;
+    scheduleTimestamp;
+    startTimestamp;
+    timeToLive;
+    visibilityDeadline;
+    completeTimestamp;
+    tries;
+    progress;
+    data;
+    state;
+    result;
+    error;
+}
+__decorate([
+    StringProperty(),
+    __metadata("design:type", String)
+], PostgresTaskBase.prototype, "namespace", void 0);
+__decorate([
+    StringProperty(),
+    __metadata("design:type", String)
+], PostgresTaskBase.prototype, "type", void 0);
+__decorate([
+    Enumeration(TaskState),
+    __metadata("design:type", String)
+], PostgresTaskBase.prototype, "status", void 0);
+__decorate([
+    StringProperty({ nullable: true }),
+    __metadata("design:type", Object)
+], PostgresTaskBase.prototype, "idempotencyKey", void 0);
+__decorate([
+    StringProperty({ nullable: true }),
+    __metadata("design:type", Object)
+], PostgresTaskBase.prototype, "traceId", void 0);
+__decorate([
+    ArrayProperty(String),
+    __metadata("design:type", Array)
+], PostgresTaskBase.prototype, "tags", void 0);
+__decorate([
+    ArrayProperty(String),
+    __metadata("design:type", Array)
+], PostgresTaskBase.prototype, "completeAfterTags", void 0);
+__decorate([
+    ArrayProperty(String),
+    __metadata("design:type", Array)
+], PostgresTaskBase.prototype, "scheduleAfterTags", void 0);
+__decorate([
+    BooleanProperty(),
+    __metadata("design:type", Boolean)
+], PostgresTaskBase.prototype, "failFast", void 0);
+__decorate([
+    Enumeration(DependencyJoinMode),
+    __metadata("design:type", String)
+], PostgresTaskBase.prototype, "dependencyJoinMode", void 0);
+__decorate([
+    Enumeration(TaskState, { array: true }),
+    __metadata("design:type", Array)
+], PostgresTaskBase.prototype, "dependencyTriggerStates", void 0);
+__decorate([
+    Integer(),
+    __metadata("design:type", Number)
+], PostgresTaskBase.prototype, "priority", void 0);
+__decorate([
+    UuidProperty({ nullable: true }),
+    __metadata("design:type", Object)
+], PostgresTaskBase.prototype, "token", void 0);
+__decorate([
+    TimestampProperty(),
+    __metadata("design:type", Number)
+], PostgresTaskBase.prototype, "creationTimestamp", void 0);
+__decorate([
+    TimestampProperty(),
+    __metadata("design:type", Number)
+], PostgresTaskBase.prototype, "priorityAgeTimestamp", void 0);
+__decorate([
+    TimestampProperty(),
+    __metadata("design:type", Number)
+], PostgresTaskBase.prototype, "scheduleTimestamp", void 0);
+__decorate([
+    TimestampProperty({ nullable: true }),
+    __metadata("design:type", Object)
+], PostgresTaskBase.prototype, "startTimestamp", void 0);
+__decorate([
+    TimestampProperty({ nullable: true }),
+    __metadata("design:type", Object)
+], PostgresTaskBase.prototype, "timeToLive", void 0);
+__decorate([
+    TimestampProperty({ nullable: true }),
+    __metadata("design:type", Object)
+], PostgresTaskBase.prototype, "visibilityDeadline", void 0);
+__decorate([
+    TimestampProperty({ nullable: true }),
+    __metadata("design:type", Object)
+], PostgresTaskBase.prototype, "completeTimestamp", void 0);
+__decorate([
+    Integer(),
+    __metadata("design:type", Number)
+], PostgresTaskBase.prototype, "tries", void 0);
+__decorate([
+    NumberProperty(),
+    __metadata("design:type", Number)
+], PostgresTaskBase.prototype, "progress", void 0);
+__decorate([
+    JsonProperty({ nullable: true }),
+    __metadata("design:type", Object)
+], PostgresTaskBase.prototype, "data", void 0);
+__decorate([
+    JsonProperty({ nullable: true }),
+    __metadata("design:type", Object)
+], PostgresTaskBase.prototype, "state", void 0);
+__decorate([
+    JsonProperty({ nullable: true }),
+    __metadata("design:type", Object)
+], PostgresTaskBase.prototype, "result", void 0);
+__decorate([
+    JsonProperty({ nullable: true }),
+    __metadata("design:type", Object)
+], PostgresTaskBase.prototype, "error", void 0);
+let PostgresTask = class PostgresTask extends PostgresTaskBase {
+    static entityName = 'Task';
+    parentId;
+};
+__decorate([
+    Reference(() => PostgresTask),
+    UuidProperty({ nullable: true }),
+    __metadata("design:type", Object)
+], PostgresTask.prototype, "parentId", void 0);
+PostgresTask = __decorate([
+    Table('task', { schema: 'task_queue' }),
+    Unique(['namespace', 'idempotencyKey']),
+    Index(['namespace', 'status', 'scheduleTimestamp', 'priority']),
+    Index(['tags'], { using: 'gin' }),
+    Index(['completeAfterTags'], { using: 'gin' }),
+    Index(['scheduleAfterTags'], { using: 'gin' }),
+    Index(['status', 'completeTimestamp']),
+    Index(['status', 'visibilityDeadline']),
+    Index(['parentId'])
+], PostgresTask);
+export { PostgresTask };
+let PostgresTaskArchive = class PostgresTaskArchive extends PostgresTaskBase {
+    static entityName = 'TaskArchive';
+    parentId;
+};
+__decorate([
+    UuidProperty({ nullable: true }),
+    __metadata("design:type", Object)
+], PostgresTaskArchive.prototype, "parentId", void 0);
+PostgresTaskArchive = __decorate([
+    Table('task_archive', { schema: 'task_queue' }),
+    Index(['namespace', 'completeTimestamp'])
+], PostgresTaskArchive);
+export { PostgresTaskArchive };

package/{queue → task-queue}/provider.d.ts

@@ -1,5 +1,5 @@
 import type { ObjectLiteral } from '../types/index.js';
-import type { Queue, QueueConfig } from './queue.js';
-export declare abstract class QueueProvider {
-    abstract get<Data extends ObjectLiteral, State extends ObjectLiteral, Result extends ObjectLiteral>(key: string, config?: QueueConfig): Queue<Data, State, Result>;
+import type { TaskQueue, QueueConfig } from './task-queue.js';
+export declare abstract class TaskQueueProvider {
+    abstract get<Data extends ObjectLiteral, State extends ObjectLiteral, Result extends ObjectLiteral>(key: string, config?: QueueConfig): TaskQueue<Data, State, Result>;
 }

package/task-queue/provider.js

@@ -0,0 +1,2 @@
+export class TaskQueueProvider {
+}

package/{queue → task-queue}/task-context.d.ts

@@ -1,25 +1,25 @@
 import type { CancellationSignal, CancellationToken } from '../cancellation/index.js';
 import type { Logger } from '../logger/index.js';
 import type { Transaction } from '../orm/server/index.js';
-import { type EnqueueManyItem, type EnqueueOptions, Queue, type Task } from './queue.js';
+import { type EnqueueManyItem, type EnqueueOptions, TaskQueue, type Task } from './task-queue.js';
 export declare class TaskContext<Data, State = unknown, Result = unknown> {
     #private;
-    constructor(queue: Queue<Data, State, Result>, task: Task<Data, State, Result>, signal: CancellationToken, logger: Logger);
+    constructor(queue: TaskQueue<Data, State, Result>, task: Task<Data, State, Result>, signal: CancellationToken, logger: Logger);
     get id(): string;
     get data(): Data;
     get attempt(): number;
     get triesLeft(): number;
     get signal(): CancellationSignal;
     get logger(): Logger;
-    acknowledge(result?: Result, transaction?: Transaction): Promise<void>;
+    complete(result?: Result, transaction?: Transaction): Promise<void>;
     checkpoint(options: {
         progress?: number;
         state?: State;
     }): Promise<void>;
-    spawn(data: Data, options?: Omit<EnqueueOptions, 'parentId'>): Promise<Task<Data, State, Result>>;
-    spawn<D, S, R>(queue: Queue<D, S, R>, data: D, options?: Omit<EnqueueOptions, 'parentId'>): Promise<Task<D, S, R>>;
+    spawn(type: string, data: Data, options?: Omit<EnqueueOptions, 'parentId'>): Promise<Task<Data, State, Result>>;
+    spawn<D, S, R>(queue: TaskQueue<D, S, R>, type: string, data: D, options?: Omit<EnqueueOptions, 'parentId'>): Promise<Task<D, S, R>>;
     spawnMany(items: EnqueueManyItem<Data>[]): Promise<Task<Data, State, Result>[]>;
-    spawnMany<D = Data, S = any, R = any>(queue: Queue<D, S, R>, items: EnqueueManyItem<D>[]): Promise<Task<D, S, R>[]>;
+    spawnMany<D = Data, S = any, R = any>(queue: TaskQueue<D, S, R>, items: EnqueueManyItem<D>[]): Promise<Task<D, S, R>[]>;
     /** Stop execution and reschedule the task for later without incrementing tries if possible */
     reschedule(timestamp: number): Promise<void>;
     reschedule(options: {
@@ -29,7 +29,7 @@ export declare class TaskContext<Data, State = unknown, Result = unknown> {
 }
 export declare class BatchTaskContext<Data, State, Result> {
     #private;
-    constructor(queue: Queue<Data, State, Result>, tasks: Task<Data, State, Result>[], signal: CancellationToken, logger: Logger);
+    constructor(queue: TaskQueue<Data, State, Result>, tasks: Task<Data, State, Result>[], signal: CancellationToken, logger: Logger);
     get tasks(): Task<Data, State, Result>[];
     get signal(): CancellationSignal;
     get logger(): Logger;

package/{queue → task-queue}/task-context.js

@@ -1,6 +1,6 @@
 import { currentTimestamp } from '../utils/date-time.js';
 import { isInstanceOf, isNumber, isUndefined } from '../utils/type-guards.js';
-import { Queue } from './queue.js';
+import { TaskQueue } from './task-queue.js';
 export class TaskContext {
     #queue;
     #logger;
@@ -30,8 +30,8 @@ export class TaskContext {
     get logger() {
         return this.#logger;
     }
-    async acknowledge(result, transaction) {
-        await this.#queue.acknowledge(this.#task, result, transaction);
+    async complete(result, transaction) {
+        await this.#queue.complete(this.#task, result, transaction);
     }
     async checkpoint(options) {
         const updatedTask = await this.#queue.touch(this.#task, options);
@@ -43,14 +43,14 @@ export class TaskContext {
             this.#task = updatedTask;
         }
     }
-    async spawn(queueOrData, dataOrOptionsOrNothing, optionsOrNothing) {
-        if (isInstanceOf(queueOrData, Queue)) {
-            return await queueOrData.enqueue(dataOrOptionsOrNothing, { ...optionsOrNothing, parentId: this.#task.id });
+    async spawn(queueOrType, typeOrData, dataOrOptionsOrNothing, optionsOrNothing) {
+        if (isInstanceOf(queueOrType, TaskQueue)) {
+            return await queueOrType.enqueue(typeOrData, dataOrOptionsOrNothing, { ...optionsOrNothing, parentId: this.#task.id });
         }
-        return await this.#queue.enqueue(queueOrData, { ...dataOrOptionsOrNothing, parentId: this.#task.id });
+        return await this.#queue.enqueue(queueOrType, typeOrData, { ...dataOrOptionsOrNothing, parentId: this.#task.id });
     }
     async spawnMany(queueOrItems, itemsOrNothing) {
-        const isForOtherQueue = isInstanceOf(queueOrItems, Queue);
+        const isForOtherQueue = isInstanceOf(queueOrItems, TaskQueue);
         const items = (isForOtherQueue ? itemsOrNothing : queueOrItems).map((item) => ({ ...item, parentId: this.#task.id }));
         if (isForOtherQueue) {
             return await queueOrItems.enqueueMany(items, { returnTasks: true });

package/{queue/queue.d.ts → task-queue/task-queue.d.ts}

@@ -1,26 +1,45 @@
 import type { CancellationSignal } from '../cancellation/token.js';
 import { type EnumType } from '../enumeration/enumeration.js';
 import type { Resolvable, resolveArgumentType } from '../injector/interfaces.js';
-import type { Logger } from '../logger/logger.js';
+import { Logger } from '../logger/logger.js';
 import type { Transaction } from '../orm/server/transaction.js';
-import type { UndefinableJson } from '../types/types.js';
-import { QueueEnqueueBatch } from './enqueue-batch.js';
+import { Transactional } from '../orm/server/transactional.js';
+import type { OneOrMany, UndefinableJson } from '../types/types.js';
+import { TaskQueueEnqueueBatch } from './enqueue-batch.js';
 import { BatchTaskContext, type TaskContext } from './task-context.js';
+type TaskResultPayload<Result> = {
+    action: 'complete';
+    result: Result | undefined;
+} | {
+    action: 'fail';
+    error: any;
+    fatal: boolean;
+} | {
+    action: 'reschedule';
+    timestamp: number;
+};
+export declare class TaskResult<Result = unknown> {
+    readonly payload: TaskResultPayload<Result>;
+    private constructor();
+    static Complete<Result>(result?: Result): TaskResult<Result>;
+    static Fail(error: any, fatal?: boolean): TaskResult;
+    static RescheduleTo(timestamp: number): TaskResult;
+    static RescheduleBy(milliseconds: number): TaskResult;
+}
 export interface ProcessWorker<Data, State, Result> {
     /**
      * A worker function that processes a single task.
      * @param context The task context providing data, logger, and orchestration helpers.
      */
-    (context: TaskContext<Data, State, Result>): void | Result | Promise<void | Result>;
+    (context: TaskContext<Data, State, Result>): TaskResult<Result> | Promise<TaskResult<Result>>;
 }
 export interface ProcessBatchWorker<Data, State, Result> {
     /**
      * A worker function that processes a batch of tasks.
      * @param context The batch context providing tasks and helpers.
      */
-    (context: BatchTaskContext<Data, State, Result>): void | Result[] | Promise<void | Result[]>;
+    (context: BatchTaskContext<Data, State, Result>): TaskResult<Result>[] | Promise<TaskResult<Result>[]>;
 }
-export type TaskTag = string | null;
 export declare const TaskState: {
     /**
      * The task is waiting to be processed.
@@ -48,21 +67,35 @@ export declare const TaskState: {
     readonly Dead: "dead";
 };
 export type TaskState = EnumType<typeof TaskState>;
+export declare const DependencyJoinMode: {
+    readonly And: "and";
+    readonly Or: "or";
+};
+export type DependencyJoinMode = EnumType<typeof DependencyJoinMode>;
 export type Task<Data = unknown, State = unknown, Result = unknown> = {
     id: string;
-    queue: string;
+    namespace: string;
+    type: string;
     status: TaskState;
-    lease: string | null;
+    token: string | null;
     /**
      * The lower the number, the higher the priority.
      * @default 1000
      */
     priority: number;
-    tag: TaskTag;
-    data: Data;
+    idempotencyKey: string | null;
+    traceId: string | null;
+    tags: string[];
+    completeAfterTags: string[];
+    scheduleAfterTags: string[];
+    failFast: boolean;
+    dependencyJoinMode: DependencyJoinMode;
+    dependencyTriggerStates: TaskState[];
+    data: Data | null;
     parentId: string | null;
     tries: number;
-    enqueueTimestamp: number;
+    creationTimestamp: number;
+    priorityAgeTimestamp: number;
     scheduleTimestamp: number;
     /**
      * Timestamp when the task most recently switched to Running state.
@@ -73,8 +106,11 @@ export type Task<Data = unknown, State = unknown, Result = unknown> = {
      * Timestamp after which the task is considered expired if it hasn't started Running.
      * If null, the task never expires in the queue.
      */
-    expirationTimestamp: number | null;
-    lockExpirationTimestamp: number | null;
+    timeToLive: number | null;
+    /**
+     * Token expiration (Soft Timeout).
+     */
+    visibilityDeadline: number | null;
     completeTimestamp: number | null;
     /** A number between 0 and 1 indicating the progress of the task. */
     progress: number;
@@ -84,46 +120,47 @@ export type Task<Data = unknown, State = unknown, Result = unknown> = {
     error: UndefinableJson | null;
 };
 export declare const defaultTaskPriority = 1000;
-export declare const UniqueTagStrategy: {
-    readonly KeepOld: 0;
-    readonly TakeNew: 1;
-};
-export type UniqueTagStrategy = EnumType<typeof UniqueTagStrategy>;
 export type EnqueueOptions = {
-    tag?: TaskTag;
     priority?: number;
     parentId?: string;
+    idempotencyKey?: string;
+    replace?: boolean;
+    tags?: string[];
+    completeAfterTags?: string[];
+    scheduleAfterTags?: string[];
+    failFast?: boolean;
+    dependencyJoinMode?: DependencyJoinMode;
+    dependencyTriggerStates?: TaskState[];
     scheduleTimestamp?: number;
-    expirationTimestamp?: number;
+    timeToLive?: number;
     transaction?: Transaction;
 };
-export type EnqueueOneOptions = EnqueueOptions & {
-    uniqueTag?: UniqueTagStrategy;
-};
+export type EnqueueOneOptions = EnqueueOptions;
 export type EnqueueManyItem<T> = EnqueueOptions & {
+    type: string;
     data: T;
 };
 export type EnqueueManyOptions = {
-    uniqueTag?: UniqueTagStrategy;
+    replace?: boolean;
     returnTasks?: boolean;
     transaction?: Transaction;
 };
 export type QueueConfig = {
     /**
-     * Duration in ms for the worker lease. The worker must heartbeat within this window.
+     * Duration (ms) before a worker token is considered lost.
+     * Corresponds to $$VisibilityTimeout$$
      */
-    processTimeout?: number;
+    visibilityTimeout?: number;
     /**
-     * Maximum duration a task is allowed to run (in ms) before being forcefully killed.
-     * This protects against infinite loops even if the worker keeps heartbeating.
+     * Hard limit for Running state (ms).
+     * Corresponds to $$MaxExecutionTime$$
      * **WARN:** CancellationSignal must still be observed by the worker!
-     * Default: 15 minutes
      */
-    executionTimeout?: number;
-    /** Maximum number of attempts to process a task before marking it as failed. Default 3 */
+    maxExecutionTime?: number;
+    /** Maximum number of attempts allowed. Default 3 */
     maxTries?: number;
-    /** Milliseconds to keep completed tasks */
-    retentionPeriod?: number;
+    /** Duration to retain terminal tasks before archival. Default: 30 days */
+    retention?: number;
     /** Maximum number of running tasks across all workers (`null` = unlimited) */
     globalConcurrency?: number | null;
     /** Number of consecutive failures before tripping the circuit breaker */
@@ -136,17 +173,35 @@ export type QueueConfig = {
     retryDelayMaximum?: number;
     /** Base for exponential backoff (delay = min * (base ^ tries)). Default: 2 */
     retryDelayGrowth?: number;
+    /** Milliseconds to retain archived tasks. Default: 30 days */
+    archiveRetention?: number;
+    /** Age at which a task's priority is promoted (ms). Default: 1 minute */
+    priorityAgingInterval?: number;
+    /** Amount to decrement priority on each aging interval. Default: 10 */
+    priorityAgingStep?: number;
+    /** Default duration for timeToLive (ms). Default: 1 day */
+    defaultTimeToLive?: number;
+    /** Token bucket size for rate limiting. Default: 100 */
+    rateLimit?: number;
+    /** Token bucket interval ms for rate limiting. Default: 1000 */
+    rateInterval?: number;
+    /** Time to retain idempotency keys (ms). Default: 1 hour */
+    idempotencyWindow?: number;
 };
-export type QueueArgument = string | (QueueConfig & {
-    name: string;
+export type TaskQueueArgument = string | (QueueConfig & {
+    namespace: string;
 });
 export declare const defaultQueueConfig: Required<QueueConfig>;
-export declare abstract class Queue<Data, State = unknown, Result = unknown> implements Resolvable<QueueArgument> {
-    readonly [resolveArgumentType]: QueueArgument;
-    abstract readonly processTimeout: number;
+export declare abstract class TaskQueue<Data, State = unknown, Result = unknown> extends Transactional implements Resolvable<TaskQueueArgument> {
+    readonly [resolveArgumentType]: TaskQueueArgument;
+    protected readonly config: QueueConfig & {
+        namespace: string;
+    };
+    protected readonly logger: Logger;
+    abstract readonly visibilityTimeout: number;
     abstract readonly maxTries: number;
-    batch(): QueueEnqueueBatch<Data, State, Result>;
-    abstract enqueue(data: Data, options?: EnqueueOneOptions): Promise<Task<Data, State, Result>>;
+    batch(): TaskQueueEnqueueBatch<Data, State, Result>;
+    abstract enqueue(type: string, data: Data, options?: EnqueueOneOptions): Promise<Task<Data, State, Result>>;
     abstract enqueueMany(items: EnqueueManyItem<Data>[], options?: EnqueueManyOptions & {
         returnTasks?: false;
     }): Promise<void>;
@@ -155,27 +210,27 @@ export declare abstract class Queue<Data, State = unknown, Result = unknown> imp
     }): Promise<Task<Data, State, Result>[]>;
     abstract enqueueMany(items: EnqueueManyItem<Data>[], options?: EnqueueManyOptions): Promise<Task<Data, State, Result>[] | undefined>;
     abstract has(id: string): Promise<boolean>;
-    abstract get(id: string): Promise<Task<Data, State, Result> | undefined>;
-    abstract getByTag(tag: TaskTag): Promise<Task<Data, State, Result>[]>;
-    abstract getByTags(tags: TaskTag[]): Promise<Task<Data, State, Result>[]>;
-    abstract countByTag(tag: TaskTag): Promise<number>;
+    abstract getTask(id: string): Promise<Task<Data, State, Result> | undefined>;
+    abstract getManyByTags(tags: OneOrMany<string>): Promise<Task<Data, State, Result>[]>;
+    abstract countByTags(tags: OneOrMany<string>): Promise<number>;
     abstract getTree(rootId: string | string[]): Promise<Task<unknown, unknown, unknown>[]>;
     abstract cancel(id: string): Promise<void>;
     abstract cancelMany(ids: string[]): Promise<void>;
-    abstract cancelByTag(tag: TaskTag): Promise<void>;
-    abstract cancelManyByTag(tags: TaskTag[]): Promise<void>;
+    abstract cancelManyByTags(tags: OneOrMany<string>): Promise<void>;
     /** Clears all tasks from the queue. Use with caution! */
     abstract clear(): Promise<void>;
     abstract dequeue(): Promise<Task<Data, State, Result> | undefined>;
-    abstract dequeueMany(count: number): Promise<Task<Data, State, Result>[]>;
+    abstract dequeueMany(count: number, options?: {
+        forceDequeue?: boolean;
+        types?: string[];
+    }): Promise<Task<Data, State, Result>[]>;
     /**
      * Reschedules a task to run at a specific time.
      * NOTE: If the task is currently running, its retry count is decremented (refunded) so this attempt doesn't count against maxTries.
      */
     abstract reschedule(id: string, timestamp: number, transaction?: Transaction): Promise<void>;
     abstract rescheduleMany(ids: string[], timestamp: number, transaction?: Transaction): Promise<void>;
-    abstract rescheduleByTag(tag: TaskTag, timestamp: number, transaction?: Transaction): Promise<void>;
-    abstract rescheduleManyByTag(tags: TaskTag[], timestamp: number, transaction?: Transaction): Promise<void>;
+    abstract rescheduleManyByTags(tags: OneOrMany<string>, timestamp: number, transaction?: Transaction): Promise<void>;
     /**
      * Updates task progress, state and lock.
      * Returns the updated task if successful, `undefined` if task is lost/cancelled/timed out.
@@ -190,23 +245,37 @@ export declare abstract class Queue<Data, State = unknown, Result = unknown> imp
      * Returns the IDs of the successfully updated tasks.
      */
     abstract touchMany(tasks: Task[], progresses?: number[], states?: State[], transaction?: Transaction): Promise<string[]>;
-    abstract acknowledge<R>(task: Task<any, any, R>, result?: R, transaction?: Transaction): Promise<void>;
-    abstract acknowledgeMany<R>(tasks: Task<any, any, R>[], results?: R[], transaction?: Transaction): Promise<void>;
+    abstract complete<R>(task: Task<any, any, R>, result?: R, transaction?: Transaction): Promise<void>;
+    abstract completeMany<R>(tasks: Task<any, any, R>[], results?: R[], transaction?: Transaction): Promise<void>;
     abstract fail(task: Task, error: any, fatal?: boolean, transaction?: Transaction): Promise<void>;
     abstract failMany(tasks: Task[], error: any, transaction?: Transaction): Promise<void>;
-    abstract prune(): Promise<void>;
-    abstract restart(id: string, transaction?: Transaction): Promise<void>;
-    abstract getConsumer(cancellationSignal: CancellationSignal): AsyncIterableIterator<Task<Data, State, Result>>;
-    abstract getBatchConsumer(size: number, cancellationSignal: CancellationSignal): AsyncIterableIterator<Task<Data, State, Result>[]>;
-    process({ concurrency, cancellationSignal }: {
+    abstract maintenance(): Promise<void>;
+    abstract restart(id: string, options?: {
+        resetState?: boolean;
+        transaction?: Transaction;
+    }): Promise<void>;
+    abstract getConsumer(cancellationSignal: CancellationSignal, options?: {
+        forceDequeue?: boolean;
+        types?: string[];
+    }): AsyncIterableIterator<Task<Data, State, Result>>;
+    abstract getBatchConsumer(size: number, cancellationSignal: CancellationSignal, options?: {
+        forceDequeue?: boolean;
+        types?: string[];
+    }): AsyncIterableIterator<Task<Data, State, Result>[]>;
+    process({ concurrency, cancellationSignal, types, forceDequeue }: {
         concurrency?: number;
         cancellationSignal: CancellationSignal;
-    }, handler: ProcessWorker<Data, State, Result>, logger: Logger): void;
-    processBatch({ batchSize, concurrency, cancellationSignal }: {
+        types?: string[];
+        forceDequeue?: boolean;
+    }, handler: ProcessWorker<Data, State, Result>): void;
+    processBatch({ batchSize, concurrency, cancellationSignal, types, forceDequeue }: {
         batchSize?: number;
         concurrency?: number;
         cancellationSignal: CancellationSignal;
-    }, handler: ProcessBatchWorker<Data, State, Result>, logger: Logger): void;
+        types?: string[];
+        forceDequeue?: boolean;
+    }, handler: ProcessBatchWorker<Data, State, Result>): void;
     private processWorker;
     private processBatchWorker;
 }
+export {};