@tstdl/base 0.93.91 → 0.93.93

package/authentication/client/authentication.service.js

@@ -24,7 +24,7 @@ import { currentTimestampSeconds } from '../../utils/date-time.js';
 import { formatError } from '../../utils/format-error.js';
 import { timeout } from '../../utils/timing.js';
 import { assertDefinedPass, isDefined, isNotFunction, isNullOrUndefined, isUndefined } from '../../utils/type-guards.js';
-import { millisecondsPerSecond } from '../../utils/units.js';
+import { millisecondsPerMinute, millisecondsPerSecond } from '../../utils/units.js';
 import { AUTHENTICATION_API_CLIENT, INITIAL_AUTHENTICATION_DATA } from './tokens.js';
 const tokenStorageKey = 'AuthenticationService:token';
 const rawTokenStorageKey = 'AuthenticationService:raw-token';
@@ -36,6 +36,7 @@ const tokenUpdateBusName = 'AuthenticationService:tokenUpdate';
 const loggedOutBusName = 'AuthenticationService:loggedOut';
 const refreshLockResource = 'AuthenticationService:refresh';
 const refreshBufferSeconds = 15;
+const maxRefreshDelay = 15 * millisecondsPerMinute;
 const lockTimeout = 10000;
 const logoutTimeout = 150;
 const unrecoverableErrors = [
@@ -380,7 +381,7 @@ let AuthenticationClientService = class AuthenticationClientService {
                 if (isUndefined(token)) {
                     // Wait for login or dispose.
                     // We ignore forceRefreshToken here because we can't refresh without a token.
-                    await firstValueFrom(race([this.definedToken$, this.disposeToken]));
+                    await firstValueFrom(race([this.definedToken$, this.disposeToken]), { defaultValue: undefined });
                     continue;
                 }
                 const now = this.estimatedServerTimestampSeconds();
@@ -401,11 +402,11 @@ let AuthenticationClientService = class AuthenticationClientService {
                     if (!lockAcquired) {
                         // Lock held by another instance, wait 5 seconds or until state/token changes.
                         // We ignore forceRefreshToken here to avoid a busy loop if it is already set.
-                        await firstValueFrom(race([timer(5000), this.disposeToken, this.token$.pipe(filter((t) => t !== token))]));
+                        await firstValueFrom(race([timer(5000), this.disposeToken, this.token$.pipe(filter((t) => t !== token))]), { defaultValue: undefined });
                         continue;
                     }
                 }
-                const delay = ((this.token()?.exp ?? 0) - this.estimatedServerTimestampSeconds() - refreshBufferSeconds) * millisecondsPerSecond;
+                const delay = Math.min(maxRefreshDelay, ((this.token()?.exp ?? 0) - this.estimatedServerTimestampSeconds() - refreshBufferSeconds) * millisecondsPerSecond);
                 const wakeUpSignals = [
                     this.disposeToken,
                     this.token$.pipe(filter((t) => t != token)),
@@ -414,16 +415,15 @@ let AuthenticationClientService = class AuthenticationClientService {
                     wakeUpSignals.push(this.forceRefreshToken);
                 }
                 if (delay > 0) {
-                    await firstValueFrom(race([timer(delay), ...wakeUpSignals]));
+                    await firstValueFrom(race([timer(delay), ...wakeUpSignals]), { defaultValue: undefined });
                 }
                 else {
-                    // If expired (or within buffer) and we didn't refresh (e.g. refresh failed or lock contention), wait a bit to avoid tight loop
-                    await firstValueFrom(race([timer(5000), ...wakeUpSignals]));
+                    await firstValueFrom(race([timer(5000), ...wakeUpSignals]), { defaultValue: undefined });
                 }
             }
             catch (error) {
                 this.logger.error(error);
-                await firstValueFrom(race([timer(5000), this.disposeToken, this.token$.pipe(filter((t) => t !== this.token()))]));
+                await firstValueFrom(race([timer(5000), this.disposeToken, this.token$.pipe(filter((t) => t !== this.token()))]), { defaultValue: undefined });
             }
         }
     }

package/document-management/server/services/document-validation.service.js

@@ -14,7 +14,7 @@ import { injectionToken } from '../../../injector/token.js';
 import { Logger } from '../../../logger/logger.js';
 import { getEntityIds } from '../../../orm/index.js';
 import { injectRepository } from '../../../orm/server/index.js';
-import { TaskQueue, TaskResult } from '../../../task-queue/task-queue.js';
+import { TaskProcessResult, TaskQueue } from '../../../task-queue/task-queue.js';
 import { currentTimestamp } from '../../../utils/date-time.js';
 import { isNull, isUndefined } from '../../../utils/type-guards.js';
 import { millisecondsPerMinute } from '../../../utils/units.js';
@@ -45,10 +45,10 @@ let DocumentValidationService = DocumentValidationService_1 = class DocumentVali
         this.processQueue(cancellationSignal);
     }
     processQueue(cancellationSignal) {
-        this.#taskQueue.process({ concurrency: 5, cancellationSignal }, async (job) => {
-            this.#logger.verbose(`Processing validation execution "${job.data.executionId}"`);
-            await this.processValidationExecution(job.data.tenantId, job.data.executionId);
-            return TaskResult.Complete();
+        this.#taskQueue.process({ concurrency: 5, cancellationSignal }, async (task) => {
+            this.#logger.verbose(`Processing validation execution "${task.data.executionId}"`);
+            await this.processValidationExecution(task.data.tenantId, task.data.executionId);
+            return TaskProcessResult.Complete();
         });
     }
     async startValidationWorkflow(tenantId, documentId) {

package/document-management/server/services/document-workflow.service.js

@@ -13,7 +13,7 @@ import { inject } from '../../../injector/inject.js';
 import { afterResolve } from '../../../injector/interfaces.js';
 import { Logger } from '../../../logger/index.js';
 import { injectRepository, injectTransactional, Transactional } from '../../../orm/server/index.js';
-import { TaskQueue, TaskResult } from '../../../task-queue/task-queue.js';
+import { TaskProcessResult, TaskQueue } from '../../../task-queue/task-queue.js';
 import { toArray } from '../../../utils/array/array.js';
 import { currentTimestamp } from '../../../utils/date-time.js';
 import { _throw } from '../../../utils/throw.js';
@@ -109,7 +109,7 @@ let DocumentWorkflowService = DocumentWorkflowService_1 = class DocumentWorkflow
             else {
                 await this.setWorkflowState(workflow.id, DocumentWorkflowState.Review);
             }
-            return TaskResult.Complete();
+            return TaskProcessResult.Complete();
         }
         catch (error) {
             if (task.triesLeft == 0) {

package/orm/sqls/sqls.d.ts

@@ -152,7 +152,7 @@ export declare namespace jsonAgg {
  * @param columns - The columns or SQL expressions to check.
  * @returns A Drizzle SQL object representing the coalesced value.
  */
-export declare function coalesce<T extends (Column | SQL)[]>(...columns: T): SQL<SelectResultField<T>[number]>;
+export declare function coalesce<T extends (Column | SQL | SQL.Aliased)[]>(...columns: T): SQL<SelectResultField<T>[number]>;
 /**
  * Creates a PostgreSQL `to_jsonb` function call.
  * Converts the input column or SQL expression to a JSONB value.
@@ -160,26 +160,26 @@ export declare function coalesce<T extends (Column | SQL)[]>(...columns: T): SQL
  * @param column - The column or SQL expression to convert.
  * @returns A Drizzle SQL object representing the value as JSONB.
  */
-export declare function toJsonb<T extends (Column | SQL)>(column: T): SQL<SelectResultField<T>>;
+export declare function toJsonb<T extends (Column | SQL | SQL.Aliased)>(column: T): SQL<SelectResultField<T>>;
 /**
  * Creates a PostgreSQL `num_nulls` function call.
  * Counts the number of null arguments.
  * @param columns - The columns to check for nulls.
  * @returns A Drizzle SQL object representing the count of nulls.
  */
-export declare function numNulls(...columns: Column[]): SQL<number>;
+export declare function numNulls(...columns: (Column | SQL | SQL.Aliased)[]): SQL<number>;
 /**
  * Creates a PostgreSQL `num_nonnulls` function call.
  * Counts the number of non-null arguments.
  * @param columns - The columns to check for non-nulls.
  * @returns A Drizzle SQL object representing the count of non-nulls.
  */
-export declare function numNonNulls(...columns: Column[]): SQL<number>;
-export declare function least<T extends (Column | SQL | number)[]>(...values: T): SQL<SelectResultField<{
+export declare function numNonNulls(...columns: (Column | SQL | SQL.Aliased)[]): SQL<number>;
+export declare function least<T extends (Column | SQL | SQL.Aliased | number)[]>(...values: T): SQL<SelectResultField<{
     [P in keyof T]: T[P] extends number ? Exclude<T[P], number> | SQL<number> : T[P];
 }[number]>>;
 export declare function least<T>(...values: T[]): SQL<SelectResultField<T>>;
-export declare function greatest<T extends (Column | SQL | number)[]>(...values: T): SQL<SelectResultField<{
+export declare function greatest<T extends (Column | SQL | SQL.Aliased | number)[]>(...values: T): SQL<SelectResultField<{
     [P in keyof T]: T[P] extends number ? Exclude<T[P], number> | SQL<number> : T[P];
 }[number]>>;
 export declare function greatest<T>(...values: T[]): SQL<SelectResultField<T>>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tstdl/base",
-  "version": "0.93.91",
+  "version": "0.93.93",
   "author": "Patrick Hein",
   "publishConfig": {
     "access": "public"
@@ -167,7 +167,7 @@
     "preact": "^10.28",
     "preact-render-to-string": "^6.6",
     "sharp": "^0.34",
-    "undici": "^7.18",
+    "undici": "^7.19",
     "urlpattern-polyfill": "^10.1",
     "zod": "^3.25"
   },

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

@@ -1,17 +1,22 @@
-import type { EnqueueManyItem, EnqueueOptions, Task, TaskQueue } from './task-queue.js';
-export interface TaskQueueEnqueueBatchMethods<Data, State, Result> {
-    add(...args: Parameters<TaskQueue<Data, State, Result>['enqueue']>): void;
-    enqueue(): ReturnType<TaskQueue<Data, State, Result>['enqueueMany']>;
+import type { EnqueueManyItem, EnqueueManyOptions, EnqueueOptions, Task, TaskQueue } from './task-queue.js';
+import type { TaskData, TaskDefinitionMap, TaskTypes } from './types.js';
+export interface TaskQueueEnqueueBatchMethods<Definitions extends TaskDefinitionMap> {
+    add<Type extends TaskTypes<Definitions>>(type: Type, data: TaskData<Definitions, Type>, options?: EnqueueOptions): void;
+    enqueue(options?: EnqueueManyOptions): Promise<Task<Definitions>[] | undefined>;
 }
-export declare class TaskQueueEnqueueBatch<Data, State, Result> implements TaskQueueEnqueueBatchMethods<Data, State, Result> {
+export declare class TaskQueueEnqueueBatch<Definitions extends TaskDefinitionMap> implements TaskQueueEnqueueBatchMethods<Definitions> {
     private readonly queue;
     /** added items */
-    items: EnqueueManyItem<Data>[];
-    constructor(queue: TaskQueue<Data, State, Result>);
+    items: EnqueueManyItem<Definitions, TaskTypes<Definitions>>[];
+    constructor(queue: TaskQueue<Definitions>);
     /** add data to items */
-    add(type: string, data: Data, options?: EnqueueOptions): void;
+    add<Type extends TaskTypes<Definitions>>(type: Type, data: TaskData<Definitions, Type>, options?: EnqueueOptions): void;
     /** enqueues all added items */
-    enqueue(returnTasks?: false): Promise<void>;
-    enqueue(returnTasks: true): Promise<Task<Data, State, Result>[]>;
-    enqueue(returnTasks?: boolean): Promise<Task<Data, State, Result>[] | undefined>;
+    enqueue(options?: EnqueueManyOptions & {
+        returnTasks?: false;
+    }): Promise<void>;
+    enqueue(options: EnqueueManyOptions & {
+        returnTasks: true;
+    }): Promise<Task<Definitions>[]>;
+    enqueue(options?: EnqueueManyOptions): Promise<Task<Definitions>[] | undefined>;
 }

package/task-queue/enqueue-batch.js

@@ -10,11 +10,11 @@ export class TaskQueueEnqueueBatch {
     add(type, data, options) {
         this.items.push({ type, data, ...options });
     }
-    async enqueue(returnTasks) {
+    async enqueue(options) {
         const items = this.items;
         this.items = [];
         try {
-            return await this.queue.enqueueMany(items, { returnTasks });
+            return await this.queue.enqueueMany(items, options);
         }
         catch (error) {
             this.items.unshift(...items);

package/task-queue/index.d.ts

@@ -1,4 +1,5 @@
 export * from './enqueue-batch.js';
 export * from './provider.js';
-export * from './task-queue.js';
 export * from './task-context.js';
+export * from './task-queue.js';
+export * from './types.js';

package/task-queue/index.js

@@ -1,4 +1,5 @@
 export * from './enqueue-batch.js';
 export * from './provider.js';
-export * from './task-queue.js';
 export * from './task-context.js';
+export * from './task-queue.js';
+export * from './types.js';

package/task-queue/postgres/drizzle/{0000_thin_black_panther.sql → 0000_simple_invisible_woman.sql}

@@ -1,10 +1,10 @@
 CREATE TYPE "task_queue"."dependency_join_mode" AS ENUM('and', 'or');--> statement-breakpoint
-CREATE TYPE "task_queue"."task_state" AS ENUM('pending', 'running', 'completed', 'cancelled', 'waiting', 'dead');--> statement-breakpoint
+CREATE TYPE "task_queue"."task_status" AS ENUM('pending', 'running', 'completed', 'cancelled', 'waiting', 'dead');--> statement-breakpoint
 CREATE TABLE "task_queue"."task" (
 	"id" uuid PRIMARY KEY DEFAULT gen_random_uuid() NOT NULL,
 	"namespace" text NOT NULL,
 	"type" text NOT NULL,
-	"status" "task_queue"."task_state" NOT NULL,
+	"status" "task_queue"."task_status" NOT NULL,
 	"idempotency_key" text,
 	"trace_id" text,
 	"tags" text[] NOT NULL,
@@ -12,7 +12,7 @@ CREATE TABLE "task_queue"."task" (
 	"schedule_after_tags" text[] NOT NULL,
 	"fail_fast" boolean NOT NULL,
 	"dependency_join_mode" "task_queue"."dependency_join_mode" NOT NULL,
-	"dependency_trigger_states" "task_queue"."task_state"[] NOT NULL,
+	"dependency_trigger_statuses" "task_queue"."task_status"[] NOT NULL,
 	"priority" integer NOT NULL,
 	"token" uuid,
 	"creation_timestamp" timestamp with time zone NOT NULL,
@@ -36,7 +36,7 @@ CREATE TABLE "task_queue"."task_archive" (
 	"id" uuid PRIMARY KEY DEFAULT gen_random_uuid() NOT NULL,
 	"namespace" text NOT NULL,
 	"type" text NOT NULL,
-	"status" "task_queue"."task_state" NOT NULL,
+	"status" "task_queue"."task_status" NOT NULL,
 	"idempotency_key" text,
 	"trace_id" text,
 	"tags" text[] NOT NULL,
@@ -44,7 +44,7 @@ CREATE TABLE "task_queue"."task_archive" (
 	"schedule_after_tags" text[] NOT NULL,
 	"fail_fast" boolean NOT NULL,
 	"dependency_join_mode" "task_queue"."dependency_join_mode" NOT NULL,
-	"dependency_trigger_states" "task_queue"."task_state"[] NOT NULL,
+	"dependency_trigger_statuses" "task_queue"."task_status"[] NOT NULL,
 	"priority" integer NOT NULL,
 	"token" uuid,
 	"creation_timestamp" timestamp with time zone NOT NULL,

package/task-queue/postgres/drizzle/meta/0000_snapshot.json

@@ -1,5 +1,5 @@
 {
-  "id": "0d47b6da-b49b-4717-b789-f4ea71b3b8e7",
+  "id": "4a091e17-ecca-4dcc-9681-ee533ba465a9",
   "prevId": "00000000-0000-0000-0000-000000000000",
   "version": "7",
   "dialect": "postgresql",
@@ -29,7 +29,7 @@
         },
         "status": {
           "name": "status",
-          "type": "task_state",
+          "type": "task_status",
           "typeSchema": "task_queue",
           "primaryKey": false,
           "notNull": true
@@ -77,9 +77,9 @@
           "primaryKey": false,
           "notNull": true
         },
-        "dependency_trigger_states": {
-          "name": "dependency_trigger_states",
-          "type": "task_state[]",
+        "dependency_trigger_statuses": {
+          "name": "dependency_trigger_statuses",
+          "type": "task_status[]",
           "typeSchema": "task_queue",
           "primaryKey": false,
           "notNull": true
@@ -374,7 +374,7 @@
         },
         "status": {
           "name": "status",
-          "type": "task_state",
+          "type": "task_status",
           "typeSchema": "task_queue",
           "primaryKey": false,
           "notNull": true
@@ -422,9 +422,9 @@
           "primaryKey": false,
           "notNull": true
         },
-        "dependency_trigger_states": {
-          "name": "dependency_trigger_states",
-          "type": "task_state[]",
+        "dependency_trigger_statuses": {
+          "name": "dependency_trigger_statuses",
+          "type": "task_status[]",
           "typeSchema": "task_queue",
           "primaryKey": false,
           "notNull": true
@@ -566,8 +566,8 @@
         "or"
       ]
     },
-    "task_queue.task_state": {
-      "name": "task_state",
+    "task_queue.task_status": {
+      "name": "task_status",
       "schema": "task_queue",
       "values": [
         "pending",

package/task-queue/postgres/drizzle/meta/_journal.json

@@ -5,8 +5,8 @@
     {
       "idx": 0,
       "version": "7",
-      "when": 1768609540962,
-      "tag": "0000_thin_black_panther",
+      "when": 1769034172474,
+      "tag": "0000_simple_invisible_woman",
       "breakpoints": true
     }
   ]

package/task-queue/postgres/module.js

@@ -3,7 +3,7 @@ import { Injector } from '../../injector/injector.js';
 import { Database, migrate } from '../../orm/server/index.js';
 import { TaskQueueProvider } from '../provider.js';
 import { TaskQueue } from '../task-queue.js';
-import { PostgresQueue } from './task-queue.js';
+import { PostgresTaskQueue } from './task-queue.js';
 import { PostgresTaskQueueProvider } from './task-queue.provider.js';
 export class PostgresTaskQueueModuleConfig {
     database;
@@ -15,7 +15,7 @@ export function configurePostgresTaskQueue({ injector, ...config } = {}) {
     const targetInjector = injector ?? Injector;
     targetInjector.register(PostgresTaskQueueModuleConfig, { useValue: config });
     targetInjector.registerSingleton(TaskQueueProvider, { useToken: PostgresTaskQueueProvider });
-    targetInjector.registerSingleton(TaskQueue, { useToken: PostgresQueue });
+    targetInjector.registerSingleton(TaskQueue, { useToken: PostgresTaskQueue });
 }
 export async function migratePostgresTaskQueueSchema() {
     const connection = inject(PostgresTaskQueueModuleConfig, undefined, { optional: true })?.database?.connection;

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

@@ -1,6 +1,6 @@
 import { PostgresTask, PostgresTaskArchive } from './task.model.js';
 export declare const taskQueueSchema: import("../../orm/server/index.js").DatabaseSchema<"task_queue">;
-export declare const taskState: import("../../orm/enums.js").PgEnumFromEnumeration<{
+export declare const taskStatus: import("../../orm/enums.js").PgEnumFromEnumeration<{
     readonly Pending: "pending";
     readonly Running: "running";
     readonly Completed: "completed";

package/task-queue/postgres/schemas.js

@@ -1,8 +1,8 @@
 import { databaseSchema } from '../../orm/server/index.js';
-import { DependencyJoinMode, TaskState } from '../task-queue.js';
+import { DependencyJoinMode, TaskStatus } from '../task-queue.js';
 import { PostgresTask, PostgresTaskArchive } from './task.model.js';
 export const taskQueueSchema = databaseSchema('task_queue');
-export const taskState = taskQueueSchema.getEnum(TaskState);
+export const taskStatus = taskQueueSchema.getEnum(TaskStatus);
 export const dependencyJoinMode = taskQueueSchema.getEnum(DependencyJoinMode);
 export const task = taskQueueSchema.getTable(PostgresTask);
 export const taskArchive = taskQueueSchema.getTable(PostgresTaskArchive);

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

@@ -3,9 +3,9 @@ import { afterResolve } from '../../injector/index.js';
 import type { Query } from '../../orm/index.js';
 import { type Transaction } from '../../orm/server/index.js';
 import type { OneOrMany } from '../../schema/index.js';
-import type { ObjectLiteral } from '../../types/index.js';
 import { TaskQueue, type EnqueueManyItem, type EnqueueManyOptions, type EnqueueOneOptions, type Task } from '../task-queue.js';
-export declare class PostgresQueue<Data extends ObjectLiteral, State extends ObjectLiteral, Result extends ObjectLiteral> extends TaskQueue<Data, State, Result> {
+import type { TaskData, TaskDefinitionMap, TaskOfType, TaskResult, TasksResults, TasksStates, TaskState, TaskTypes } from '../types.js';
+export declare class PostgresTaskQueue<Definitions extends TaskDefinitionMap = TaskDefinitionMap> extends TaskQueue<Definitions> {
     #private;
     readonly visibilityTimeout: number;
     readonly maxExecutionTime: number;
@@ -23,61 +23,115 @@ export declare class PostgresQueue<Data extends ObjectLiteral, State extends Obj
     readonly idempotencyWindow: number;
     readonly globalConcurrency: number | null;
     [afterResolve](): void;
-    enqueue(type: string, data: Data, options?: EnqueueOneOptions): Promise<Task<Data, State, Result>>;
-    enqueueMany(items: EnqueueManyItem<Data>[], options?: EnqueueManyOptions & {
+    enqueue<Type extends TaskTypes<Definitions>>(type: Type, data: TaskData<Definitions, Type>, options?: EnqueueOneOptions): Promise<TaskOfType<Definitions, Type>>;
+    enqueueMany<Type extends TaskTypes<Definitions>>(items: EnqueueManyItem<Definitions, Type>[], options?: EnqueueManyOptions & {
         returnTasks?: false;
     }): Promise<void>;
-    enqueueMany(items: EnqueueManyItem<Data>[], options: EnqueueManyOptions & {
+    enqueueMany<Type extends TaskTypes<Definitions>>(items: EnqueueManyItem<Definitions, Type>[], options: EnqueueManyOptions & {
         returnTasks: true;
-    }): Promise<Task<Data, State, Result>[]>;
-    enqueueMany(items: EnqueueManyItem<Data>[], options?: EnqueueManyOptions): Promise<Task<Data, State, Result>[] | undefined>;
-    has(id: string): Promise<boolean>;
-    countByTags(tags: OneOrMany<string>): Promise<number>;
-    getTask(id: string): Promise<Task<Data, State, Result> | undefined>;
-    getManyByTags(tags: OneOrMany<string>): Promise<Task<Data, State, Result>[]>;
-    getTree(idOrIds: string | string[], transaction?: Transaction): Promise<Task<unknown, unknown, unknown>[]>;
-    getTreeByQuery(query: Query<Task>, transaction?: Transaction): Promise<Task<unknown, unknown, unknown>[]>;
-    cancel(id: string, transaction?: Transaction): Promise<void>;
-    cancelMany(ids: string[], transaction?: Transaction): Promise<void>;
-    cancelManyByTags(tags: OneOrMany<string>): Promise<void>;
-    clear(): Promise<void>;
-    dequeue(options?: {
+    }): Promise<TaskOfType<Definitions, Type>[]>;
+    enqueueMany<Type extends TaskTypes<Definitions>>(items: EnqueueManyItem<Definitions, Type>[], options?: EnqueueManyOptions): Promise<TaskOfType<Definitions, Type>[] | undefined>;
+    has(id: string, options?: {
+        transaction?: Transaction;
+    }): Promise<boolean>;
+    countByTags(tags: OneOrMany<string>, options?: {
+        transaction?: Transaction;
+    }): Promise<number>;
+    getTask<Type extends TaskTypes<Definitions> = TaskTypes<Definitions>>(id: string, options?: {
+        transaction?: Transaction;
+    }): Promise<TaskOfType<Definitions, Type> | undefined>;
+    getManyByTags<Type extends TaskTypes<Definitions>>(tags: OneOrMany<string>, options?: {
+        transaction?: Transaction;
+    }): Promise<TaskOfType<Definitions, Type>[]>;
+    getTree(rootId: string | string[], options?: {
+        transaction?: Transaction;
+    }): Promise<Task[]>;
+    getTreeByQuery(query: Query<Task>, options?: {
+        transaction?: Transaction;
+    }): Promise<Task[]>;
+    cancel(id: string, options?: {
+        transaction?: Transaction;
+    }): Promise<void>;
+    cancelMany(ids: string[], options?: {
+        transaction?: Transaction;
+    }): Promise<void>;
+    cancelManyByTags(tags: OneOrMany<string>, options?: {
+        transaction?: Transaction;
+    }): Promise<void>;
+    clear(options?: {
+        transaction?: Transaction;
+    }): Promise<void>;
+    dequeue<Type extends TaskTypes<Definitions>>(options?: {
         forceDequeue?: boolean;
-        types?: string[];
-    }): Promise<Task<Data, State, Result> | undefined>;
-    dequeueMany(count: number, options?: {
+        types?: Type[];
+        transaction?: Transaction;
+    }): Promise<TaskOfType<Definitions, Type> | undefined>;
+    dequeueMany<Type extends TaskTypes<Definitions>>(count: number, options?: {
         forceDequeue?: boolean;
-        types?: string[];
-    }): Promise<Task<Data, State, Result>[]>;
-    reschedule(id: string, timestamp: number, transaction?: Transaction): Promise<void>;
-    rescheduleMany(ids: string[], timestamp: number, transaction?: Transaction): Promise<void>;
-    rescheduleManyByTags(tags: OneOrMany<string>, timestamp: number, transaction?: Transaction): Promise<void>;
-    touch(task: Task, options?: {
+        types?: Type[];
+        transaction?: Transaction;
+    }): Promise<TaskOfType<Definitions, Type>[]>;
+    reschedule(id: string, timestamp: number, options?: {
+        transaction?: Transaction;
+    }): Promise<void>;
+    rescheduleMany(ids: string[], timestamp: number, options?: {
+        transaction?: Transaction;
+    }): Promise<void>;
+    rescheduleManyByTags(tags: OneOrMany<string>, timestamp: number, options?: {
+        transaction?: Transaction;
+    }): Promise<void>;
+    touch<Type extends TaskTypes<Definitions>>(task: TaskOfType<Definitions, Type>, options?: {
         progress?: number;
-        state?: State;
-        transaction?: Transaction;
-    }): Promise<Task<Data, State, Result> | undefined>;
-    touchMany(tasks: Task[], progresses?: number[], states?: State[], transaction?: Transaction): Promise<string[]>;
-    complete<R>(task: Task<any, any, R>, result?: R, transaction?: Transaction): Promise<void>;
-    completeMany<R>(tasks: Task<any, any, R>[], results?: R[], transaction?: Transaction): Promise<void>;
-    fail(task: Task, error: any, fatal?: boolean, transaction?: Transaction): Promise<void>;
-    triggerTagFanIn(tags: string[], transaction?: Transaction): Promise<void>;
-    failMany(tasks: Task[], errors: any[], transaction?: Transaction): Promise<void>;
-    resolveDependencies(targetTags: string[]): Promise<void>;
-    maintenance(): Promise<void>;
+        state?: TaskState<Definitions, Type>;
+        transaction?: Transaction;
+    }): Promise<TaskOfType<Definitions, Type> | undefined>;
+    touchMany<T extends Task<Definitions>[]>(tasks: T, options?: {
+        progresses?: number[];
+        states?: TasksStates<T>;
+        transaction?: Transaction;
+    }): Promise<string[]>;
+    complete<Type extends TaskTypes<Definitions>>(task: TaskOfType<Definitions, Type>, options?: {
+        result?: TaskResult<Definitions, Type>;
+        transaction?: Transaction;
+    }): Promise<void>;
+    completeMany<Tasks extends Task<Definitions>[]>(tasks: Tasks, options?: {
+        results?: TasksResults<Tasks>;
+        transaction?: Transaction;
+    }): Promise<void>;
+    fail(task: Task<Definitions>, error: unknown, options?: {
+        fatal?: boolean;
+        transaction?: Transaction;
+    }): Promise<void>;
+    triggerTagFanIn(tags: string[], options?: {
+        transaction?: Transaction;
+    }): Promise<void>;
+    failMany(tasks: Task<Definitions>[], errors: unknown[], options?: {
+        transaction?: Transaction;
+    }): Promise<void>;
+    private resolveDependencies;
+    maintenance(options?: {
+        transaction?: Transaction;
+    }): Promise<void>;
     restart(id: string, options?: {
         resetState?: boolean;
         transaction?: Transaction;
     }): Promise<void>;
-    getConsumer(cancellationSignal: CancellationSignal, options?: {
+    getConsumer<Type extends TaskTypes<Definitions>>(cancellationSignal: CancellationSignal, options?: {
         forceDequeue?: boolean;
-        types?: string[];
-    }): AsyncIterableIterator<Task<Data, State, Result>>;
-    maintenanceLoop(): Promise<void>;
-    processPendingFanIn(transaction?: Transaction): Promise<number>;
-    startSystemWorker(): void;
-    getBatchConsumer(size: number, cancellationSignal: CancellationSignal, options?: {
+        types?: Type[];
+    }): AsyncIterableIterator<TaskOfType<Definitions, Type>>;
+    private maintenanceLoop;
+    /**
+     * @internal for internal unit test use only
+     * @param options
+     * @returns
+     */
+    processPendingFanIn(options?: {
+        transaction?: Transaction;
+    }): Promise<number>;
+    private startSystemWorker;
+    getBatchConsumer<Type extends TaskTypes<Definitions>>(size: number, cancellationSignal: CancellationSignal, options?: {
         forceDequeue?: boolean;
-        types?: string[];
-    }): AsyncIterableIterator<Task<Data, State, Result>[]>;
+        types?: Type[];
+    }): AsyncIterableIterator<TaskOfType<Definitions, Type>[]>;
 }