@tstdl/base 0.93.92 → 0.93.93

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

@@ -1,7 +1,6 @@
-import { TaskQueueProvider, type QueueConfig } from '../../task-queue/index.js';
-import type { ObjectLiteral } from '../../types/index.js';
-import { PostgresQueue } from './task-queue.js';
+import { TaskQueueProvider, type QueueConfig, type TaskDefinitionMap } from '../../task-queue/index.js';
+import { PostgresTaskQueue } 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>;
+    get<Definitions extends TaskDefinitionMap = TaskDefinitionMap>(namespace: string, config?: QueueConfig): PostgresTaskQueue<Definitions>;
 }

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

@@ -8,11 +8,11 @@ import { Singleton } from '../../injector/decorators.js';
 import { inject } from '../../injector/inject.js';
 import { Injector } from '../../injector/injector.js';
 import { TaskQueueProvider } from '../../task-queue/index.js';
-import { PostgresQueue } from './task-queue.js';
+import { PostgresTaskQueue } from './task-queue.js';
 let PostgresTaskQueueProvider = class PostgresTaskQueueProvider extends TaskQueueProvider {
     #injector = inject(Injector);
     get(namespace, config) {
-        return this.#injector.resolve((PostgresQueue), { ...config, namespace });
+        return this.#injector.resolve((PostgresTaskQueue), { ...config, namespace });
     }
 };
 PostgresTaskQueueProvider = __decorate([

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

@@ -1,10 +1,10 @@
 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'> {
+import { DependencyJoinMode, type Task, TaskStatus } 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, 'parentId'> {
     namespace: string;
     type: string;
-    status: TaskState;
+    status: TaskStatus;
     idempotencyKey: string | null;
     traceId: string | null;
     tags: string[];
@@ -12,7 +12,7 @@ export declare abstract class PostgresTaskBase<Data extends ObjectLiteral = Obje
     scheduleAfterTags: string[];
     failFast: boolean;
     dependencyJoinMode: DependencyJoinMode;
-    dependencyTriggerStates: TaskState[];
+    dependencyTriggerStatuses: TaskStatus[];
     priority: number;
     token: string | null;
     creationTimestamp: Timestamp;
@@ -29,7 +29,7 @@ export declare abstract class PostgresTaskBase<Data extends ObjectLiteral = Obje
     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> {
+export declare class PostgresTask<Data extends ObjectLiteral = ObjectLiteral, State extends ObjectLiteral = ObjectLiteral, Result extends ObjectLiteral = ObjectLiteral> extends PostgresTaskBase<Data, State, Result> implements Task {
     static readonly entityName = "Task";
     parentId: string | null;
 }

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

@@ -9,7 +9,7 @@ var __metadata = (this && this.__metadata) || function (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';
+import { DependencyJoinMode, TaskStatus } from '../task-queue.js';
 export class PostgresTaskBase extends BaseEntity {
     namespace;
     type;
@@ -21,7 +21,7 @@ export class PostgresTaskBase extends BaseEntity {
     scheduleAfterTags;
     failFast;
     dependencyJoinMode;
-    dependencyTriggerStates;
+    dependencyTriggerStatuses;
     priority;
     token;
     creationTimestamp;
@@ -47,7 +47,7 @@ __decorate([
     __metadata("design:type", String)
 ], PostgresTaskBase.prototype, "type", void 0);
 __decorate([
-    Enumeration(TaskState),
+    Enumeration(TaskStatus),
     __metadata("design:type", String)
 ], PostgresTaskBase.prototype, "status", void 0);
 __decorate([
@@ -79,9 +79,9 @@ __decorate([
     __metadata("design:type", String)
 ], PostgresTaskBase.prototype, "dependencyJoinMode", void 0);
 __decorate([
-    Enumeration(TaskState, { array: true }),
+    Enumeration(TaskStatus, { array: true }),
     __metadata("design:type", Array)
-], PostgresTaskBase.prototype, "dependencyTriggerStates", void 0);
+], PostgresTaskBase.prototype, "dependencyTriggerStatuses", void 0);
 __decorate([
     Integer(),
     __metadata("design:type", Number)

package/task-queue/provider.d.ts

@@ -1,5 +1,5 @@
-import type { ObjectLiteral } from '../types/index.js';
 import type { TaskQueue, QueueConfig } from './task-queue.js';
+import type { TaskDefinitionMap } from './types.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>;
+    abstract get<Definitions extends TaskDefinitionMap = TaskDefinitionMap>(key: string, config?: QueueConfig): TaskQueue<Definitions>;
 }

package/task-queue/task-context.d.ts

@@ -1,38 +1,54 @@
 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, TaskQueue, type Task } from './task-queue.js';
-export declare class TaskContext<Data, State = unknown, Result = unknown> {
+import { TaskQueue, type EnqueueManyItem, type EnqueueOptions } from './task-queue.js';
+import type { TaskData, TaskDefinitionMap, TaskOfType, TaskResult, TaskState, TaskTypes, TasksStates } from './types.js';
+export declare class TaskContext<Definitions extends TaskDefinitionMap, Type extends TaskTypes<Definitions>> {
     #private;
-    constructor(queue: TaskQueue<Data, State, Result>, task: Task<Data, State, Result>, signal: CancellationToken, logger: Logger);
+    constructor(queue: TaskQueue<Definitions>, task: TaskOfType<Definitions, Type>, signal: CancellationToken, logger: Logger);
     get id(): string;
-    get data(): Data;
+    get type(): Type;
+    get data(): TaskData<Definitions, Type>;
+    get state(): TaskState<Definitions, Type> | null;
     get attempt(): number;
     get triesLeft(): number;
     get signal(): CancellationSignal;
     get logger(): Logger;
-    complete(result?: Result, transaction?: Transaction): Promise<void>;
+    complete(result?: TaskResult<Definitions, Type>, options?: {
+        transaction?: Transaction;
+    }): Promise<void>;
     checkpoint(options: {
         progress?: number;
-        state?: State;
+        state?: TaskState<Definitions, Type>;
+        transaction?: Transaction;
     }): Promise<void>;
-    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: TaskQueue<D, S, R>, items: EnqueueManyItem<D>[]): Promise<Task<D, S, R>[]>;
+    spawn<Type extends TaskTypes<Definitions>>(type: Type, data: TaskData<Definitions, Type>, options?: Omit<EnqueueOptions, 'parentId'>): Promise<TaskOfType<Definitions, Type>>;
+    spawn<OtherDefinitions extends TaskDefinitionMap, T extends TaskTypes<OtherDefinitions>>(queue: TaskQueue<OtherDefinitions>, type: T, data: OtherDefinitions[T]['data'], options?: Omit<EnqueueOptions, 'parentId'>): Promise<TaskOfType<OtherDefinitions, T>>;
+    spawnMany<Type extends TaskTypes<Definitions>>(items: EnqueueManyItem<Definitions, Type>[]): Promise<TaskOfType<Definitions, Type>[]>;
+    spawnMany<OtherDefinitions extends TaskDefinitionMap, Type extends TaskTypes<OtherDefinitions>>(queue: TaskQueue<OtherDefinitions>, items: EnqueueManyItem<OtherDefinitions, Type>[]): Promise<TaskOfType<OtherDefinitions, Type>[]>;
     /** Stop execution and reschedule the task for later without incrementing tries if possible */
-    reschedule(timestamp: number): Promise<void>;
-    reschedule(options: {
+    reschedule(timestamp: number, options?: {
+        transaction?: Transaction;
+    }): Promise<void>;
+    reschedule(rescheduleOptions: {
         delay: number;
+        transaction?: Transaction;
+    }): Promise<void>;
+    fail(error: unknown, options?: {
+        fatal?: boolean;
+        transaction?: Transaction;
     }): Promise<void>;
-    fail(error: any, fatal?: boolean, transaction?: Transaction): Promise<void>;
 }
-export declare class BatchTaskContext<Data, State, Result> {
+export declare class BatchTaskContext<Definitions extends TaskDefinitionMap, Type extends TaskTypes<Definitions>> {
     #private;
-    constructor(queue: TaskQueue<Data, State, Result>, tasks: Task<Data, State, Result>[], signal: CancellationToken, logger: Logger);
-    get tasks(): Task<Data, State, Result>[];
+    constructor(queue: TaskQueue<Definitions>, tasks: TaskOfType<Definitions, Type>[], signal: CancellationToken, logger: Logger);
+    get tasks(): TaskOfType<Definitions, Type>[];
     get signal(): CancellationSignal;
     get logger(): Logger;
-    for(task: Task<Data, State, Result>): TaskContext<Data, State, Result>;
-    checkpointAll(progresses?: number[], states?: State[]): Promise<void>;
+    for<Type extends TaskTypes<Definitions>>(task: TaskOfType<Definitions, Type>): TaskContext<Definitions, Type>;
+    checkpointAll(options?: {
+        progresses?: number[];
+        states?: TasksStates<TaskOfType<Definitions, Type>[]>;
+        transaction?: Transaction;
+    }): Promise<void>;
 }

package/task-queue/task-context.js

@@ -15,9 +15,15 @@ export class TaskContext {
     get id() {
         return this.#task.id;
     }
+    get type() {
+        return this.#task.type;
+    }
     get data() {
         return this.#task.data;
     }
+    get state() {
+        return this.#task.state;
+    }
     get attempt() {
         return this.#task.tries;
     }
@@ -30,8 +36,8 @@ export class TaskContext {
     get logger() {
         return this.#logger;
     }
-    async complete(result, transaction) {
-        await this.#queue.complete(this.#task, result, transaction);
+    async complete(result, options) {
+        await this.#queue.complete(this.#task, { result, ...options });
     }
     async checkpoint(options) {
         const updatedTask = await this.#queue.touch(this.#task, options);
@@ -44,10 +50,14 @@ export class TaskContext {
         }
     }
     async spawn(queueOrType, typeOrData, dataOrOptionsOrNothing, optionsOrNothing) {
-        if (isInstanceOf(queueOrType, TaskQueue)) {
-            return await queueOrType.enqueue(typeOrData, dataOrOptionsOrNothing, { ...optionsOrNothing, parentId: this.#task.id });
+        const isForOtherQueue = isInstanceOf(queueOrType, TaskQueue);
+        const type = (isForOtherQueue ? typeOrData : queueOrType);
+        const data = isForOtherQueue ? dataOrOptionsOrNothing : typeOrData;
+        const options = (isForOtherQueue ? optionsOrNothing : dataOrOptionsOrNothing);
+        if (isForOtherQueue) {
+            return await queueOrType.enqueue(type, data, { ...options, parentId: this.#task.id });
         }
-        return await this.#queue.enqueue(queueOrType, typeOrData, { ...dataOrOptionsOrNothing, parentId: this.#task.id });
+        return await this.#queue.enqueue(type, data, { ...options, parentId: this.#task.id });
     }
     async spawnMany(queueOrItems, itemsOrNothing) {
         const isForOtherQueue = isInstanceOf(queueOrItems, TaskQueue);
@@ -58,15 +68,15 @@ export class TaskContext {
         return await this.#queue.enqueueMany(items, { returnTasks: true });
     }
     async reschedule(timestampOrDelay) {
-        const timestamp = isNumber(timestampOrDelay)
-            ? timestampOrDelay
-            : currentTimestamp() + timestampOrDelay.delay;
+        const isTimestamp = isNumber(timestampOrDelay);
+        const timestamp = isTimestamp ? timestampOrDelay : (currentTimestamp() + timestampOrDelay.delay);
+        const transaction = isTimestamp ? undefined : timestampOrDelay.transaction;
         this.#logger.debug(`Rescheduling task for ${new Date(timestamp).toISOString()}.`);
-        await this.#queue.reschedule(this.#task.id, timestamp);
+        await this.#queue.reschedule(this.#task.id, timestamp, { transaction });
         this.#signal.set();
     }
-    async fail(error, fatal, transaction) {
-        await this.#queue.fail(this.#task, error, fatal, transaction);
+    async fail(error, options) {
+        await this.#queue.fail(this.#task, error, options);
         this.#signal.set();
     }
 }
@@ -93,8 +103,8 @@ export class BatchTaskContext {
     for(task) {
         return new TaskContext(this.#queue, task, this.#signal, this.#logger);
     }
-    async checkpointAll(progresses, states) {
-        const validIds = await this.#queue.touchMany(this.#tasks, progresses, states);
+    async checkpointAll(options) {
+        const validIds = await this.#queue.touchMany(this.#tasks, options);
         if (validIds.length < this.#tasks.length) {
             this.#logger.warn(`${this.#tasks.length - validIds.length} tasks in batch lost their lease during checkpoint`);
         }

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

@@ -4,43 +4,18 @@ import type { Resolvable, resolveArgumentType } from '../injector/interfaces.js'
 import { Logger } from '../logger/logger.js';
 import type { Transaction } from '../orm/server/transaction.js';
 import { Transactional } from '../orm/server/transactional.js';
-import type { OneOrMany, UndefinableJson } from '../types/types.js';
+import type { OneOrMany, Record, 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>;
+import type { ProcessBatchWorker, ProcessWorker, TaskData, TaskDefinitionMap, TaskOfType, TaskProcessResultPayload, TaskResult, TaskState, TaskTypes, TasksResults, TasksStates } from './types.js';
+export declare class TaskProcessResult<Result = unknown> {
+    readonly payload: TaskProcessResultPayload<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>): 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>): TaskResult<Result>[] | Promise<TaskResult<Result>[]>;
+    static Complete<Result>(result?: Result): TaskProcessResult<Result>;
+    static Fail(error: unknown, fatal?: boolean): TaskProcessResult;
+    static RescheduleTo(timestamp: number): TaskProcessResult;
+    static RescheduleBy(milliseconds: number): TaskProcessResult;
 }
-export declare const TaskState: {
+export declare const TaskStatus: {
     /**
      * The task is waiting to be processed.
      */
@@ -66,59 +41,65 @@ export declare const TaskState: {
      */
     readonly Dead: "dead";
 };
-export type TaskState = EnumType<typeof TaskState>;
+export type TaskStatus = EnumType<typeof TaskStatus>;
 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;
-    namespace: string;
-    type: string;
-    status: TaskState;
-    token: string | null;
-    /**
-     * The lower the number, the higher the priority.
-     * @default 1000
-     */
-    priority: number;
-    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;
-    creationTimestamp: number;
-    priorityAgeTimestamp: number;
-    scheduleTimestamp: number;
-    /**
-     * Timestamp when the task most recently switched to Running state.
-     * Used for Hard Execution Timeouts.
-     */
-    startTimestamp: number | null;
-    /**
-     * Timestamp after which the task is considered expired if it hasn't started Running.
-     * If null, the task never expires in the queue.
-     */
-    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;
-    /** A snapshot of the current state of the task. */
-    state: State | null;
-    result: Result | null;
-    error: UndefinableJson | null;
-};
+export type Task<Definitions extends TaskDefinitionMap = Record<string, {
+    data: unknown;
+    state: unknown;
+    result: unknown;
+}>> = {
+    [Type in TaskTypes<Definitions>]: {
+        id: string;
+        namespace: string;
+        type: Type;
+        status: TaskStatus;
+        token: string | null;
+        /**
+         * The lower the number, the higher the priority.
+         * @default 1000
+         */
+        priority: number;
+        idempotencyKey: string | null;
+        traceId: string | null;
+        tags: string[];
+        completeAfterTags: string[];
+        scheduleAfterTags: string[];
+        failFast: boolean;
+        dependencyJoinMode: DependencyJoinMode;
+        dependencyTriggerStatuses: TaskStatus[];
+        data: TaskData<Definitions, Type>;
+        parentId: string | null;
+        tries: number;
+        creationTimestamp: number;
+        priorityAgeTimestamp: number;
+        scheduleTimestamp: number;
+        /**
+         * Timestamp when the task most recently switched to Running state.
+         * Used for Hard Execution Timeouts.
+         */
+        startTimestamp: number | null;
+        /**
+         * Timestamp after which the task is considered expired if it hasn't started Running.
+         * If null, the task never expires in the queue.
+         */
+        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;
+        /** A snapshot of the current state of the task. */
+        state: TaskState<Definitions, Type> | null;
+        result: TaskResult<Definitions, Type> | null;
+        error: UndefinableJson | null;
+    };
+}[Extract<keyof Definitions, string>];
 export declare const defaultTaskPriority = 1000;
 export type EnqueueOptions = {
     priority?: number;
@@ -130,16 +111,18 @@ export type EnqueueOptions = {
     scheduleAfterTags?: string[];
     failFast?: boolean;
     dependencyJoinMode?: DependencyJoinMode;
-    dependencyTriggerStates?: TaskState[];
+    dependencyTriggerStatuses?: TaskStatus[];
     scheduleTimestamp?: number;
     timeToLive?: number;
     transaction?: Transaction;
 };
 export type EnqueueOneOptions = EnqueueOptions;
-export type EnqueueManyItem<T> = EnqueueOptions & {
-    type: string;
-    data: T;
-};
+export type EnqueueManyItem<Definitions extends TaskDefinitionMap = TaskDefinitionMap, Type extends TaskTypes<Definitions> = TaskTypes<Definitions>> = {
+    [Type in TaskTypes<Definitions>]: {
+        type: Type;
+        data: TaskData<Definitions, Type>;
+    } & EnqueueOptions;
+}[Type];
 export type EnqueueManyOptions = {
     replace?: boolean;
     returnTasks?: boolean;
@@ -192,7 +175,7 @@ export type TaskQueueArgument = string | (QueueConfig & {
     namespace: string;
 });
 export declare const defaultQueueConfig: Required<QueueConfig>;
-export declare abstract class TaskQueue<Data, State = unknown, Result = unknown> extends Transactional implements Resolvable<TaskQueueArgument> {
+export declare abstract class TaskQueue<Definitions extends TaskDefinitionMap = TaskDefinitionMap> extends Transactional implements Resolvable<TaskQueueArgument> {
     readonly [resolveArgumentType]: TaskQueueArgument;
     protected readonly config: QueueConfig & {
         namespace: string;
@@ -200,82 +183,127 @@ export declare abstract class TaskQueue<Data, State = unknown, Result = unknown>
     protected readonly logger: Logger;
     abstract readonly visibilityTimeout: number;
     abstract readonly maxTries: number;
-    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 & {
+    batch(): TaskQueueEnqueueBatch<Definitions>;
+    abstract enqueue<Type extends TaskTypes<Definitions>>(type: Type, data: TaskData<Definitions, Type>, options?: EnqueueOneOptions): Promise<TaskOfType<Definitions, Type>>;
+    abstract enqueueMany<Type extends TaskTypes<Definitions>>(items: EnqueueManyItem<Definitions, Type>[], options?: EnqueueManyOptions & {
         returnTasks?: false;
     }): Promise<void>;
-    abstract enqueueMany(items: EnqueueManyItem<Data>[], options: EnqueueManyOptions & {
+    abstract enqueueMany<Type extends TaskTypes<Definitions>>(items: EnqueueManyItem<Definitions, Type>[], options: EnqueueManyOptions & {
         returnTasks: true;
-    }): 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 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 cancelManyByTags(tags: OneOrMany<string>): Promise<void>;
+    }): Promise<TaskOfType<Definitions, Type>[]>;
+    abstract enqueueMany<Type extends TaskTypes<Definitions>>(items: EnqueueManyItem<Definitions, Type>[], options?: EnqueueManyOptions): Promise<TaskOfType<Definitions, Type>[] | undefined>;
+    abstract has(id: string, options?: {
+        transaction?: Transaction;
+    }): Promise<boolean>;
+    abstract getTask(id: string, options?: {
+        transaction?: Transaction;
+    }): Promise<Task<Definitions> | undefined>;
+    abstract getManyByTags(tags: OneOrMany<string>, options?: {
+        transaction?: Transaction;
+    }): Promise<Task<Definitions>[]>;
+    abstract countByTags(tags: OneOrMany<string>, options?: {
+        transaction?: Transaction;
+    }): Promise<number>;
+    abstract getTree(rootId: string | string[], options?: {
+        transaction?: Transaction;
+    }): Promise<Task[]>;
+    abstract cancel(id: string, options?: {
+        transaction?: Transaction;
+    }): Promise<void>;
+    abstract cancelMany(ids: string[], options?: {
+        transaction?: Transaction;
+    }): Promise<void>;
+    abstract cancelManyByTags(tags: OneOrMany<string>, options?: {
+        transaction?: Transaction;
+    }): 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, options?: {
+    abstract clear(options?: {
+        transaction?: Transaction;
+    }): Promise<void>;
+    abstract dequeue<Type extends TaskTypes<Definitions>>(options?: {
         forceDequeue?: boolean;
-        types?: string[];
-    }): Promise<Task<Data, State, Result>[]>;
+        types?: Type[];
+        transaction?: Transaction;
+    }): Promise<TaskOfType<Definitions, Type> | undefined>;
+    abstract dequeueMany<Type extends TaskTypes<Definitions>>(count: number, options?: {
+        forceDequeue?: boolean;
+        types?: Type[];
+        transaction?: Transaction;
+    }): Promise<TaskOfType<Definitions, Type>[]>;
     /**
      * 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 rescheduleManyByTags(tags: OneOrMany<string>, timestamp: number, transaction?: Transaction): Promise<void>;
+    abstract reschedule(id: string, timestamp: number, options?: {
+        transaction?: Transaction;
+    }): Promise<void>;
+    abstract rescheduleMany(ids: string[], timestamp: number, options?: {
+        transaction?: Transaction;
+    }): Promise<void>;
+    abstract rescheduleManyByTags(tags: OneOrMany<string>, timestamp: number, options?: {
+        transaction?: Transaction;
+    }): Promise<void>;
     /**
      * Updates task progress, state and lock.
      * Returns the updated task if successful, `undefined` if task is lost/cancelled/timed out.
      */
-    abstract touch(task: Task, options?: {
+    abstract touch<Type extends TaskTypes<Definitions>>(task: TaskOfType<Definitions, Type>, options?: {
         progress?: number;
-        state?: State;
+        state?: TaskState<Definitions, Type>;
         transaction?: Transaction;
-    }): Promise<Task<Data, State, Result> | undefined>;
+    }): Promise<TaskOfType<Definitions, Type> | undefined>;
     /**
      * Updates multiple tasks' progress, state and lock.
      * Returns the IDs of the successfully updated tasks.
      */
-    abstract touchMany(tasks: Task[], progresses?: number[], states?: State[], transaction?: Transaction): Promise<string[]>;
-    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 maintenance(): Promise<void>;
+    abstract touchMany<Tasks extends Task<Definitions>[]>(tasks: Tasks, options?: {
+        progresses?: number[];
+        states?: TasksStates<Tasks>;
+        transaction?: Transaction;
+    }): Promise<string[]>;
+    abstract complete<Type extends TaskTypes<Definitions>>(task: TaskOfType<Definitions, Type>, options?: {
+        result?: TaskResult<Definitions, Type>;
+        transaction?: Transaction;
+    }): Promise<void>;
+    abstract completeMany<Tasks extends Task<Definitions>[]>(tasks: Tasks, options?: {
+        results?: TasksResults<Tasks>;
+        transaction?: Transaction;
+    }): Promise<void>;
+    abstract fail(task: Task<Definitions>, error: unknown, options?: {
+        fatal?: boolean;
+        transaction?: Transaction;
+    }): Promise<void>;
+    abstract failMany(tasks: Task<Definitions>[], errors: unknown[], options?: {
+        transaction?: Transaction;
+    }): Promise<void>;
+    abstract maintenance(options?: {
+        transaction?: Transaction;
+    }): Promise<void>;
     abstract restart(id: string, options?: {
         resetState?: boolean;
         transaction?: Transaction;
     }): Promise<void>;
-    abstract getConsumer(cancellationSignal: CancellationSignal, options?: {
+    abstract getConsumer<Type extends TaskTypes<Definitions>>(cancellationSignal: CancellationSignal, options?: {
         forceDequeue?: boolean;
-        types?: string[];
-    }): AsyncIterableIterator<Task<Data, State, Result>>;
-    abstract getBatchConsumer(size: number, cancellationSignal: CancellationSignal, options?: {
+        types?: Type[];
+    }): AsyncIterableIterator<TaskOfType<Definitions, Type>>;
+    abstract getBatchConsumer<Type extends TaskTypes<Definitions>>(size: number, cancellationSignal: CancellationSignal, options?: {
         forceDequeue?: boolean;
-        types?: string[];
-    }): AsyncIterableIterator<Task<Data, State, Result>[]>;
-    process({ concurrency, cancellationSignal, types, forceDequeue }: {
+        types?: Type[];
+    }): AsyncIterableIterator<TaskOfType<Definitions, Type>[]>;
+    process<Type extends TaskTypes<Definitions>>({ concurrency, cancellationSignal, types, forceDequeue }: {
         concurrency?: number;
         cancellationSignal: CancellationSignal;
-        types?: string[];
+        types?: Type[];
         forceDequeue?: boolean;
-    }, handler: ProcessWorker<Data, State, Result>): void;
-    processBatch({ batchSize, concurrency, cancellationSignal, types, forceDequeue }: {
+    }, handler: ProcessWorker<Definitions, Type>): void;
+    processBatch<Type extends TaskTypes<Definitions>>({ batchSize, concurrency, cancellationSignal, types, forceDequeue }: {
         batchSize?: number;
         concurrency?: number;
         cancellationSignal: CancellationSignal;
-        types?: string[];
+        types?: Type[];
         forceDequeue?: boolean;
-    }, handler: ProcessBatchWorker<Data, State, Result>): void;
+    }, handler: ProcessBatchWorker<Definitions, Type>): void;
     private processWorker;
     private processBatchWorker;
 }
-export {};