@holo-js/queue 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,560 @@
+import { Job, ConnectionOptions } from 'bullmq';
+
+type QueueJsonPrimitive = string | number | boolean | null;
+type QueueJsonValue = QueueJsonPrimitive | readonly QueueJsonValue[] | {
+    readonly [key: string]: QueueJsonValue;
+};
+declare function normalizeOptionalString(value: string | undefined, label: string): string | undefined;
+declare function normalizeOptionalInteger(value: number | undefined, label: string, options?: {
+    minimum?: number;
+}): number | undefined;
+declare function normalizeBackoff(value: number | readonly number[] | undefined): number | readonly number[] | undefined;
+declare function normalizeOptionalHook<THandler extends (...args: never[]) => unknown>(value: THandler | undefined, label: string): THandler | undefined;
+interface QueueJobContext {
+    readonly jobId: string;
+    readonly jobName: string;
+    readonly connection: string;
+    readonly queue: string;
+    readonly attempt: number;
+    readonly maxAttempts: number;
+    release(delaySeconds?: number): Promise<void>;
+    fail(error: Error): Promise<void>;
+}
+interface QueueJobCompletedHook<TPayload extends QueueJsonValue = QueueJsonValue, TResult = unknown> {
+    (payload: TPayload, result: TResult, context: QueueJobContext): void | Promise<void>;
+}
+interface QueueJobFailedHook<TPayload extends QueueJsonValue = QueueJsonValue> {
+    (payload: TPayload, error: Error, context: QueueJobContext): void | Promise<void>;
+}
+interface QueueJobDefinition<TPayload extends QueueJsonValue = QueueJsonValue, TResult = unknown> {
+    readonly connection?: string;
+    readonly queue?: string;
+    readonly tries?: number;
+    readonly backoff?: number | readonly number[];
+    readonly timeout?: number;
+    readonly onCompleted?: QueueJobCompletedHook<TPayload, TResult>;
+    readonly onFailed?: QueueJobFailedHook<TPayload>;
+    handle(payload: TPayload, context: QueueJobContext): Promise<TResult> | TResult;
+}
+interface QueueJobEnvelope<TPayload extends QueueJsonValue = QueueJsonValue> {
+    readonly id: string;
+    readonly name: string;
+    readonly connection: string;
+    readonly queue: string;
+    readonly payload: TPayload;
+    readonly attempts: number;
+    readonly maxAttempts: number;
+    readonly availableAt?: number;
+    readonly createdAt: number;
+}
+type QueueDelayValue = number | Date;
+interface QueueDispatchOptions {
+    readonly connection?: string;
+    readonly queue?: string;
+    readonly delay?: QueueDelayValue;
+}
+interface QueueDispatchResult {
+    readonly jobId: string;
+    readonly connection: string;
+    readonly queue: string;
+    readonly synchronous: boolean;
+}
+interface QueueDispatchCompletedHook {
+    (result: QueueDispatchResult): void | Promise<void>;
+}
+interface QueueDispatchFailedHook {
+    (error: unknown): void | Promise<void>;
+}
+interface QueueDriverDispatchResult<TResult = unknown> {
+    readonly jobId: string;
+    readonly synchronous: boolean;
+    readonly result?: TResult;
+}
+interface QueueRegisteredJob<TPayload extends QueueJsonValue = QueueJsonValue, TResult = unknown> {
+    readonly name: string;
+    readonly sourcePath?: string;
+    readonly definition: QueueJobDefinition<TPayload, TResult>;
+}
+interface HoloQueueJobRegistry {
+}
+type KnownQueueJobName = Extract<keyof HoloQueueJobRegistry, string>;
+type ResolveRegisteredQueueJobDefinition<TJobName extends string> = TJobName extends KnownQueueJobName ? Extract<HoloQueueJobRegistry[TJobName], QueueJobDefinition> extends never ? QueueJobDefinition : Extract<HoloQueueJobRegistry[TJobName], QueueJobDefinition> : QueueJobDefinition;
+type ExportedQueueJobDefinition<TValue> = Extract<TValue, QueueJobDefinition> extends never ? QueueJobDefinition : Extract<TValue, QueueJobDefinition>;
+type QueuePayloadFor<TJobName extends string> = ResolveRegisteredQueueJobDefinition<TJobName> extends QueueJobDefinition<infer TPayload, unknown> ? TPayload : QueueJsonValue;
+type QueueResultFor<TJobName extends string> = ResolveRegisteredQueueJobDefinition<TJobName> extends QueueJobDefinition<QueueJsonValue, infer TResult> ? TResult : unknown;
+interface RegisterQueueJobOptions {
+    readonly name?: string;
+    readonly sourcePath?: string;
+    readonly replaceExisting?: boolean;
+}
+type RegisterableQueueJobDefinition<TPayload extends QueueJsonValue = QueueJsonValue, TResult = unknown> = QueueJobDefinition<TPayload, TResult>;
+interface QueuePendingDispatch<TPayload extends QueueJsonValue = QueueJsonValue> extends PromiseLike<QueueDispatchResult> {
+    onConnection(name: string): QueuePendingDispatch<TPayload>;
+    onQueue(name: string): QueuePendingDispatch<TPayload>;
+    delay(value: QueueDelayValue): QueuePendingDispatch<TPayload>;
+    onComplete(callback: QueueDispatchCompletedHook): QueuePendingDispatch<TPayload>;
+    onFailed(callback: QueueDispatchFailedHook): QueuePendingDispatch<TPayload>;
+    then<TResult1 = QueueDispatchResult, TResult2 = never>(onfulfilled?: ((value: QueueDispatchResult) => TResult1 | PromiseLike<TResult1>) | null, onrejected?: ((reason: unknown) => TResult2 | PromiseLike<TResult2>) | null): Promise<TResult1 | TResult2>;
+    catch<TResult = never>(onrejected?: ((reason: unknown) => TResult | PromiseLike<TResult>) | null): Promise<QueueDispatchResult | TResult>;
+    finally(onfinally?: (() => void) | null): Promise<QueueDispatchResult>;
+    dispatch(): Promise<QueueDispatchResult>;
+}
+interface QueueConnectionFacade {
+    readonly name: string;
+    dispatch<TJobName extends KnownQueueJobName>(jobName: TJobName, payload: QueuePayloadFor<TJobName>, options?: QueueDispatchOptions): QueuePendingDispatch<QueuePayloadFor<TJobName>>;
+    dispatch<TPayload extends QueueJsonValue = QueueJsonValue>(jobName: string, payload: TPayload, options?: QueueDispatchOptions): QueuePendingDispatch<TPayload>;
+    dispatchSync<TJobName extends KnownQueueJobName>(jobName: TJobName, payload: QueuePayloadFor<TJobName>): Promise<QueueResultFor<TJobName>>;
+    dispatchSync<TPayload extends QueueJsonValue = QueueJsonValue, TResult = unknown>(jobName: string, payload: TPayload): Promise<TResult>;
+}
+interface QueueEnqueueResult {
+    readonly jobId: string;
+}
+interface QueueReserveInput {
+    readonly queueNames: readonly string[];
+    readonly workerId: string;
+}
+interface QueueReservedJob<TPayload extends QueueJsonValue = QueueJsonValue> {
+    readonly reservationId: string;
+    readonly envelope: QueueJobEnvelope<TPayload>;
+    readonly reservedAt: number;
+}
+interface QueueReleaseOptions {
+    readonly delaySeconds?: number;
+}
+interface QueueClearInput {
+    readonly queueNames?: readonly string[];
+}
+interface QueueJobContextOverrides {
+    readonly maxAttempts?: number;
+    shouldSkipLifecycleHooks?(): boolean;
+    release?(delaySeconds?: number): Promise<void>;
+    fail?(error: Error): Promise<void>;
+}
+interface QueueDriverFactoryContext {
+    execute<TPayload extends QueueJsonValue = QueueJsonValue, TResult = unknown>(job: QueueJobEnvelope<TPayload>): Promise<TResult>;
+}
+interface QueueDriverBase {
+    readonly name: string;
+    readonly driver: NormalizedQueueConnectionConfig['driver'];
+    readonly mode: 'sync' | 'async';
+    dispatch<TPayload extends QueueJsonValue = QueueJsonValue, TResult = unknown>(job: QueueJobEnvelope<TPayload>): Promise<QueueDriverDispatchResult<TResult>>;
+    clear(input?: QueueClearInput): Promise<number>;
+    close(): Promise<void>;
+}
+interface QueueAsyncDriver extends QueueDriverBase {
+    readonly mode: 'async';
+    reserve<TPayload extends QueueJsonValue = QueueJsonValue>(input: QueueReserveInput): Promise<QueueReservedJob<TPayload> | null>;
+    acknowledge(job: QueueReservedJob): Promise<void>;
+    release(job: QueueReservedJob, options?: QueueReleaseOptions): Promise<void>;
+    delete(job: QueueReservedJob): Promise<void>;
+}
+interface QueueSyncDriver extends QueueDriverBase {
+    readonly mode: 'sync';
+}
+type QueueDriver = QueueSyncDriver | QueueAsyncDriver;
+interface QueueDriverFactory<TConfig extends NormalizedQueueConnectionConfig = NormalizedQueueConnectionConfig> {
+    readonly driver: TConfig['driver'];
+    create(connection: TConfig, context: QueueDriverFactoryContext): QueueDriver;
+}
+interface QueueRuntimeBinding {
+    readonly config: NormalizedHoloQueueConfig;
+    readonly drivers: ReadonlyMap<string, QueueDriver>;
+}
+interface QueueWorkerOptions {
+    readonly connection?: string;
+    readonly queueNames?: readonly string[];
+    readonly once?: boolean;
+    readonly stopWhenEmpty?: boolean;
+    readonly sleep?: number;
+    readonly tries?: number;
+    readonly timeout?: number;
+    readonly maxJobs?: number;
+    readonly maxTime?: number;
+    readonly workerId?: string;
+    readonly shouldStop?: () => boolean | Promise<boolean>;
+    readonly sleepFn?: (milliseconds: number) => Promise<void>;
+}
+interface QueueWorkerJobEvent {
+    readonly jobId: string;
+    readonly jobName: string;
+    readonly connection: string;
+    readonly queue: string;
+    readonly attempt: number;
+    readonly maxAttempts: number;
+}
+interface QueueWorkerHooks {
+    onJobProcessed?(event: QueueWorkerJobEvent): void | Promise<void>;
+    onJobReleased?(event: QueueWorkerJobEvent & {
+        readonly delaySeconds?: number;
+        readonly error?: Error;
+    }): void | Promise<void>;
+    onJobFailed?(event: QueueWorkerJobEvent & {
+        readonly error: Error;
+    }): void | Promise<void>;
+    onIdle?(): void | Promise<void>;
+}
+interface QueueWorkerRunOptions extends QueueWorkerOptions, QueueWorkerHooks {
+}
+interface QueueWorkerResult {
+    readonly processed: number;
+    readonly released: number;
+    readonly failed: number;
+    readonly stoppedBecause: 'once' | 'empty' | 'max-jobs' | 'max-time' | 'signal';
+}
+interface QueueFailedJobRecord<TPayload extends QueueJsonValue = QueueJsonValue> {
+    readonly id: string;
+    readonly jobId: string;
+    readonly job: QueueJobEnvelope<TPayload>;
+    readonly exception: string;
+    readonly failedAt: number;
+}
+interface QueueFailedJobStore {
+    persistFailedJob(reserved: QueueReservedJob, error: Error): Promise<QueueFailedJobRecord | null>;
+    listFailedJobs(): Promise<readonly QueueFailedJobRecord[]>;
+    retryFailedJobs(identifier: 'all' | string, retry: (record: QueueFailedJobRecord) => Promise<void>): Promise<number>;
+    forgetFailedJob(id: string): Promise<boolean>;
+    flushFailedJobs(): Promise<number>;
+}
+declare function isQueueJobDefinition(value: unknown): value is QueueJobDefinition;
+declare function normalizeQueueJobDefinition<TJob extends QueueJobDefinition>(job: TJob): TJob;
+declare function defineJob<TJob extends QueueJobDefinition>(job: TJob): TJob;
+interface QueueFailedStoreConfig {
+    readonly driver?: 'database';
+    readonly connection?: string;
+    readonly table?: string;
+}
+interface QueueRedisConnectionConfig {
+    readonly driver: 'redis';
+    readonly queue?: string;
+    readonly retryAfter?: number | string;
+    readonly blockFor?: number | string;
+    readonly redis?: {
+        readonly host?: string;
+        readonly port?: number | string;
+        readonly password?: string;
+        readonly username?: string;
+        readonly db?: number | string;
+    };
+}
+interface QueueDatabaseConnectionConfig {
+    readonly driver: 'database';
+    readonly queue?: string;
+    readonly retryAfter?: number | string;
+    readonly sleep?: number | string;
+    readonly connection?: string;
+    readonly table?: string;
+}
+interface QueueSyncConnectionConfig {
+    readonly driver: 'sync';
+    readonly queue?: string;
+}
+type QueueConnectionConfig = QueueSyncConnectionConfig | QueueRedisConnectionConfig | QueueDatabaseConnectionConfig;
+interface HoloQueueConfig {
+    readonly default?: string;
+    readonly failed?: false | QueueFailedStoreConfig;
+    readonly connections?: Readonly<Record<string, QueueConnectionConfig>>;
+}
+interface NormalizedQueueFailedStoreConfig {
+    readonly driver: 'database';
+    readonly connection: string;
+    readonly table: string;
+}
+interface NormalizedQueueSyncConnectionConfig {
+    readonly name: string;
+    readonly driver: 'sync';
+    readonly queue: string;
+}
+interface NormalizedQueueRedisConnectionConfig {
+    readonly name: string;
+    readonly driver: 'redis';
+    readonly queue: string;
+    readonly retryAfter: number;
+    readonly blockFor: number;
+    readonly redis: {
+        readonly host: string;
+        readonly port: number;
+        readonly password?: string;
+        readonly username?: string;
+        readonly db: number;
+    };
+}
+interface NormalizedQueueDatabaseConnectionConfig {
+    readonly name: string;
+    readonly driver: 'database';
+    readonly queue: string;
+    readonly retryAfter: number;
+    readonly sleep: number;
+    readonly connection: string;
+    readonly table: string;
+}
+type NormalizedQueueConnectionConfig = NormalizedQueueSyncConnectionConfig | NormalizedQueueRedisConnectionConfig | NormalizedQueueDatabaseConnectionConfig;
+interface NormalizedHoloQueueConfig {
+    readonly default: string;
+    readonly failed: false | NormalizedQueueFailedStoreConfig;
+    readonly connections: Readonly<Record<string, NormalizedQueueConnectionConfig>>;
+}
+declare const queueJobInternals: {
+    normalizeQueueJobDefinition: typeof normalizeQueueJobDefinition;
+    normalizeBackoff: typeof normalizeBackoff;
+    normalizeOptionalHook: typeof normalizeOptionalHook;
+    normalizeOptionalInteger: typeof normalizeOptionalInteger;
+    normalizeOptionalString: typeof normalizeOptionalString;
+};
+
+declare const DEFAULT_QUEUE_CONNECTION = "sync";
+declare const DEFAULT_QUEUE_NAME = "default";
+declare const DEFAULT_QUEUE_RETRY_AFTER = 90;
+declare const DEFAULT_QUEUE_BLOCK_FOR = 5;
+declare const DEFAULT_QUEUE_SLEEP = 1;
+declare const DEFAULT_FAILED_JOBS_CONNECTION = "default";
+declare const DEFAULT_FAILED_JOBS_TABLE = "failed_jobs";
+declare const DEFAULT_DATABASE_QUEUE_TABLE = "jobs";
+declare function parseInteger(value: number | string | undefined, fallback: number, label: string, options?: {
+    minimum?: number;
+}): number;
+declare function normalizeQueueConfig(config?: HoloQueueConfig): NormalizedHoloQueueConfig;
+declare const holoQueueDefaults: Readonly<NormalizedHoloQueueConfig>;
+declare const queueInternals: {
+    parseInteger: typeof parseInteger;
+};
+
+declare function deriveJobNameFromSourcePath(sourcePath: string): string;
+declare function registerQueueJob<TPayload extends QueueJsonValue, TResult>(definition: RegisterableQueueJobDefinition<TPayload, TResult>, options?: RegisterQueueJobOptions): QueueRegisteredJob<TPayload, TResult>;
+declare function registerQueueJobs(definitions: ReadonlyArray<{
+    readonly definition: RegisterableQueueJobDefinition;
+    readonly options?: RegisterQueueJobOptions;
+}>): ReadonlyArray<QueueRegisteredJob>;
+declare function getRegisteredQueueJob(name: string): QueueRegisteredJob | undefined;
+declare function listRegisteredQueueJobs(): readonly QueueRegisteredJob[];
+declare function unregisterQueueJob(name: string): boolean;
+declare function resetQueueRegistry(): void;
+declare const queueRegistryInternals: {
+    deriveJobNameFromSourcePath: typeof deriveJobNameFromSourcePath;
+};
+
+type RedisQueuedEnvelope = QueueJobEnvelope<QueueJsonValue>;
+type BullJobInstance = Job<RedisQueuedEnvelope, unknown, string>;
+declare function normalizeRedisErrorMessage(error: unknown): string;
+declare function isQueueEnvelope(value: unknown): value is QueueJobEnvelope<QueueJsonValue>;
+declare function resolveBullConnectionOptions(connection: NormalizedQueueRedisConnectionConfig): ConnectionOptions;
+declare class RedisQueueDriverError extends Error {
+    constructor(connectionName: string, action: string, cause: unknown);
+}
+declare function wrapRedisError(connectionName: string, action: string, error: unknown): RedisQueueDriverError;
+declare function resolveAttempts(job: BullJobInstance): number;
+declare class RedisQueueDriver implements QueueAsyncDriver {
+    private readonly context;
+    readonly name: string;
+    readonly driver: "redis";
+    readonly mode: "async";
+    private readonly connection;
+    private readonly bullConnection;
+    private readonly queues;
+    private readonly workers;
+    private readonly reservations;
+    private queueCursor;
+    constructor(connection: NormalizedQueueRedisConnectionConfig, context: QueueDriverFactoryContext);
+    private getQueue;
+    private getWorker;
+    private normalizeQueueNames;
+    private rotateQueueNames;
+    private createReservedJob;
+    private getReservation;
+    private settleReservation;
+    dispatch<TPayload extends QueueJsonValue = QueueJsonValue, TResult = unknown>(job: QueueJobEnvelope<TPayload>): Promise<QueueDriverDispatchResult<TResult>>;
+    reserve<TPayload extends QueueJsonValue = QueueJsonValue>(input: {
+        readonly queueNames: readonly string[];
+        readonly workerId: string;
+    }): Promise<QueueReservedJob<TPayload> | null>;
+    acknowledge(job: QueueReservedJob): Promise<void>;
+    release(job: QueueReservedJob, options?: QueueReleaseOptions): Promise<void>;
+    delete(job: QueueReservedJob): Promise<void>;
+    clear(input?: {
+        readonly queueNames?: readonly string[];
+    }): Promise<number>;
+    close(): Promise<void>;
+}
+declare const redisQueueDriverFactory: QueueDriverFactory<NormalizedQueueRedisConnectionConfig>;
+declare const redisQueueDriverInternals: {
+    isQueueEnvelope: typeof isQueueEnvelope;
+    normalizeRedisErrorMessage: typeof normalizeRedisErrorMessage;
+    resolveAttempts: typeof resolveAttempts;
+    resolveBullConnectionOptions: typeof resolveBullConnectionOptions;
+    wrapRedisError: typeof wrapRedisError;
+};
+
+declare class SyncQueueDriver implements QueueSyncDriver {
+    readonly name: string;
+    readonly driver: "sync";
+    readonly mode: "sync";
+    private readonly context;
+    constructor(connection: NormalizedQueueSyncConnectionConfig, context: QueueDriverFactoryContext);
+    dispatch<TPayload extends QueueJsonValue = QueueJsonValue, TResult = unknown>(job: QueueJobEnvelope<TPayload>): Promise<QueueDriverDispatchResult<TResult>>;
+    clear(): Promise<number>;
+    close(): Promise<void>;
+}
+declare const syncQueueDriverFactory: QueueDriverFactory<NormalizedQueueSyncConnectionConfig>;
+declare const syncQueueDriverInternals: {
+    SyncQueueDriver: typeof SyncQueueDriver;
+};
+
+type RuntimeQueueState = {
+    config: NormalizedHoloQueueConfig;
+    driverFactories: Map<string, QueueDriverFactory>;
+    drivers: Map<string, QueueDriver>;
+    failedJobStore?: QueueFailedJobStore;
+};
+type QueuePayloadValidationState = {
+    readonly seen: Set<unknown>;
+};
+type ConfigureQueueRuntimeOptions = {
+    readonly config?: HoloQueueConfig | NormalizedHoloQueueConfig;
+    readonly driverFactories?: ReadonlyArray<QueueDriverFactory> | ReadonlyMap<string, QueueDriverFactory>;
+    readonly failedJobStore?: QueueFailedJobStore;
+};
+declare class QueueReleaseUnsupportedError extends Error {
+    constructor();
+}
+declare function isPlainObject(value: unknown): value is Record<string, unknown>;
+declare function assertQueueJsonValue(value: unknown, path: string, state: QueuePayloadValidationState): asserts value is QueueJsonValue;
+declare function validateQueuePayload<TPayload>(payload: TPayload): asserts payload is TPayload & QueueJsonValue;
+declare function normalizeConnectionName(name: string): string;
+declare function normalizeQueueName(name: string): string;
+declare function normalizeDelay(delay: QueueDelayValue | undefined): number | undefined;
+declare function createDefaultDriverFactories(): Map<string, QueueDriverFactory>;
+declare function createQueueDriverFactoryMap(factories?: ReadonlyArray<QueueDriverFactory> | ReadonlyMap<string, QueueDriverFactory>): Map<string, QueueDriverFactory>;
+declare function getQueueRuntimeState(): RuntimeQueueState;
+declare function createQueueRuntimeBinding(state: RuntimeQueueState): QueueRuntimeBinding;
+declare function resolveConnectionConfig(config: NormalizedHoloQueueConfig, requestedConnection: string | undefined): NormalizedQueueConnectionConfig;
+declare function createJobContext<TPayload extends QueueJsonValue>(envelope: QueueJobEnvelope<TPayload>, overrides?: QueueJobContextOverrides): QueueJobContext;
+declare function executeRegisteredQueueJob<TPayload extends QueueJsonValue, TResult>(envelope: QueueJobEnvelope<TPayload>, contextOverrides?: QueueJobContextOverrides): Promise<TResult>;
+declare function executeRegisteredQueueJobCompletedHook<TPayload extends QueueJsonValue, TResult>(envelope: QueueJobEnvelope<TPayload>, result: TResult, contextOverrides?: QueueJobContextOverrides): Promise<void>;
+declare function executeRegisteredQueueJobFailedHook<TPayload extends QueueJsonValue>(envelope: QueueJobEnvelope<TPayload>, error: Error, contextOverrides?: QueueJobContextOverrides): Promise<void>;
+declare function dispatchThroughDriver(driver: QueueDriver, envelope: QueueJobEnvelope): Promise<Awaited<ReturnType<QueueDriver['dispatch']>>>;
+declare function createQueueDriverFactoryContext(): QueueDriverFactoryContext;
+declare function resolveDriverFactory(state: RuntimeQueueState, connection: NormalizedQueueConnectionConfig): QueueDriverFactory;
+declare function resolveConnectionDriver(connectionName?: string): QueueDriver;
+declare function resolveSyncExecutionDriver(): QueueDriver;
+declare function createJobEnvelope<TPayload extends QueueJsonValue>(jobName: string, payload: TPayload, options: QueueDispatchOptions): QueueJobEnvelope<TPayload>;
+declare function createDispatchEnvelope<TPayload extends QueueJsonValue>(jobName: string, payload: TPayload, options?: QueueDispatchOptions): QueueJobEnvelope<TPayload>;
+declare function dispatchRecord(envelope: QueueJobEnvelope): Promise<QueueDispatchResult>;
+declare function createQueueConnection(name?: string): QueueConnectionFacade;
+declare function configureQueueRuntime(options?: ConfigureQueueRuntimeOptions): void;
+declare function resetQueueRuntimeState(state: RuntimeQueueState): void;
+declare function shutdownQueueRuntime(): Promise<void>;
+declare function resetQueueRuntime(): void;
+declare function getQueueRuntime(): QueueRuntimeBinding;
+declare function useQueueConnection(name?: string): QueueConnectionFacade;
+declare function dispatchSync<TJobName extends Extract<keyof HoloQueueJobRegistry, string>>(jobName: TJobName, payload: QueuePayloadFor<TJobName>, options?: QueueDispatchOptions): Promise<QueueResultFor<TJobName>>;
+declare function dispatch<TJobName extends Extract<keyof HoloQueueJobRegistry, string>>(jobName: TJobName, payload: QueuePayloadFor<TJobName>, options?: QueueDispatchOptions): QueuePendingDispatch<QueuePayloadFor<TJobName>>;
+declare const Queue: {
+    connection(name?: string): QueueConnectionFacade;
+    dispatch: typeof dispatch;
+    dispatchSync: typeof dispatchSync;
+};
+declare const queueRuntimeInternals: {
+    assertQueueJsonValue: typeof assertQueueJsonValue;
+    createQueueRuntimeBinding: typeof createQueueRuntimeBinding;
+    createDefaultDriverFactories: typeof createDefaultDriverFactories;
+    createDispatchEnvelope: typeof createDispatchEnvelope;
+    createJobContext: typeof createJobContext;
+    createJobEnvelope: typeof createJobEnvelope;
+    createQueueConnection: typeof createQueueConnection;
+    createQueueDriverFactoryContext: typeof createQueueDriverFactoryContext;
+    createQueueDriverFactoryMap: typeof createQueueDriverFactoryMap;
+    closeQueueDrivers: typeof closeQueueDrivers;
+    dispatchRecord: typeof dispatchRecord;
+    dispatchThroughDriver: typeof dispatchThroughDriver;
+    executeRegisteredQueueJob: typeof executeRegisteredQueueJob;
+    executeRegisteredQueueJobCompletedHook: typeof executeRegisteredQueueJobCompletedHook;
+    executeRegisteredQueueJobFailedHook: typeof executeRegisteredQueueJobFailedHook;
+    getQueueRuntimeState: typeof getQueueRuntimeState;
+    isPlainObject: typeof isPlainObject;
+    normalizeConnectionName: typeof normalizeConnectionName;
+    normalizeDelay: typeof normalizeDelay;
+    normalizeQueueName: typeof normalizeQueueName;
+    resolveConnectionConfig: typeof resolveConnectionConfig;
+    resolveConnectionDriver: typeof resolveConnectionDriver;
+    resolveDriverFactory: typeof resolveDriverFactory;
+    resolveSyncExecutionDriver: typeof resolveSyncExecutionDriver;
+    resetQueueRuntimeState: typeof resetQueueRuntimeState;
+    validateQueuePayload: typeof validateQueuePayload;
+};
+declare function closeQueueDrivers(drivers: Iterable<QueueDriver>): Promise<void>;
+
+declare function normalizeFailedStoreErrorMessage(error: unknown): string;
+declare class QueueFailedStoreError extends Error {
+    constructor(action: string, cause: unknown);
+}
+declare function wrapFailedStoreError(action: string, error: unknown): QueueFailedStoreError;
+declare function getFailedJobStore(): QueueFailedJobStore | undefined;
+declare function createRetriedEnvelope(record: QueueFailedJobRecord): Readonly<{
+    attempts: 0;
+    createdAt: number;
+    availableAt: undefined;
+    id: string;
+    name: string;
+    connection: string;
+    queue: string;
+    payload: QueueJsonValue;
+    maxAttempts: number;
+}>;
+declare function persistFailedQueueJob(reserved: QueueReservedJob, error: Error): Promise<QueueFailedJobRecord | null>;
+declare function listFailedQueueJobs(): Promise<readonly QueueFailedJobRecord[]>;
+declare function retryFailedQueueJobs(identifier: 'all' | string): Promise<number>;
+declare function forgetFailedQueueJob(id: string): Promise<boolean>;
+declare function flushFailedQueueJobs(): Promise<number>;
+declare const queueFailedInternals: {
+    createRetriedEnvelope: typeof createRetriedEnvelope;
+    getFailedJobStore: typeof getFailedJobStore;
+    normalizeFailedStoreErrorMessage: typeof normalizeFailedStoreErrorMessage;
+    wrapFailedStoreError: typeof wrapFailedStoreError;
+};
+
+declare class QueueWorkerUnsupportedDriverError extends Error {
+    constructor(connectionName: string, driverName: string);
+}
+declare class QueueWorkerTimeoutError extends Error {
+    constructor(jobName: string, timeoutSeconds: number);
+}
+type QueueWorkerProcessingOutcome = {
+    readonly kind: 'processed';
+} | {
+    readonly kind: 'released';
+    readonly delaySeconds?: number;
+    readonly error?: Error;
+} | {
+    readonly kind: 'failed';
+    readonly error: Error;
+};
+declare function sleep(milliseconds: number): Promise<void>;
+declare function requireAsyncDriver(driver: QueueDriver, connectionName: string): QueueAsyncDriver;
+declare function requireRegisteredDefinition(jobName: string): QueueJobDefinition;
+declare function normalizeQueueNames(queueNames: readonly string[] | undefined, fallbackQueueName: string | undefined): readonly string[];
+declare function normalizeNonNegativeInteger(value: number | undefined, label: string): number | undefined;
+declare function normalizePositiveInteger(value: number | undefined, label: string): number | undefined;
+declare function createWorkerEvent(envelope: QueueJobEnvelope, maxAttempts: number): QueueWorkerJobEvent;
+declare function resolveRetryDelaySeconds(definition: QueueJobDefinition, attempt: number): number | undefined;
+declare function runWithTimeout<TResult>(callback: Promise<TResult>, jobName: string, timeoutSeconds: number | undefined, onTimeout?: () => void): Promise<TResult>;
+declare function processReservedJob(driver: QueueAsyncDriver, reserved: QueueReservedJob<QueueJsonValue>, options: Pick<QueueWorkerRunOptions, 'timeout' | 'tries' | 'onJobFailed' | 'onJobProcessed' | 'onJobReleased'>): Promise<QueueWorkerProcessingOutcome>;
+declare function resolveWorkerStopReason(options: QueueWorkerOptions, state: {
+    readonly processed: number;
+    readonly startedAt: number;
+}): QueueWorkerResult['stoppedBecause'] | undefined;
+declare function runQueueWorker(options?: QueueWorkerRunOptions): Promise<QueueWorkerResult>;
+declare function clearQueueConnection(connectionName?: string, input?: QueueClearInput): Promise<number>;
+declare const queueWorkerInternals: {
+    createWorkerEvent: typeof createWorkerEvent;
+    normalizeNonNegativeInteger: typeof normalizeNonNegativeInteger;
+    normalizePositiveInteger: typeof normalizePositiveInteger;
+    normalizeQueueNames: typeof normalizeQueueNames;
+    processReservedJob: typeof processReservedJob;
+    requireAsyncDriver: typeof requireAsyncDriver;
+    requireRegisteredDefinition: typeof requireRegisteredDefinition;
+    resolveRetryDelaySeconds: typeof resolveRetryDelaySeconds;
+    resolveWorkerStopReason: typeof resolveWorkerStopReason;
+    runWithTimeout: typeof runWithTimeout;
+    sleep: typeof sleep;
+};
+
+export { DEFAULT_DATABASE_QUEUE_TABLE, DEFAULT_FAILED_JOBS_CONNECTION, DEFAULT_FAILED_JOBS_TABLE, DEFAULT_QUEUE_BLOCK_FOR, DEFAULT_QUEUE_CONNECTION, DEFAULT_QUEUE_NAME, DEFAULT_QUEUE_RETRY_AFTER, DEFAULT_QUEUE_SLEEP, type ExportedQueueJobDefinition, type HoloQueueConfig, type HoloQueueJobRegistry, type NormalizedHoloQueueConfig, type NormalizedQueueConnectionConfig, type NormalizedQueueDatabaseConnectionConfig, type NormalizedQueueFailedStoreConfig, type NormalizedQueueRedisConnectionConfig, type NormalizedQueueSyncConnectionConfig, Queue, type QueueAsyncDriver, type QueueClearInput, type QueueConnectionConfig, type QueueConnectionFacade, type QueueDatabaseConnectionConfig, type QueueDelayValue, type QueueDispatchCompletedHook, type QueueDispatchFailedHook, type QueueDispatchOptions, type QueueDispatchResult, type QueueDriver, type QueueDriverDispatchResult, type QueueDriverFactory, type QueueDriverFactoryContext, type QueueEnqueueResult, type QueueFailedJobRecord, type QueueFailedJobStore, type QueueFailedStoreConfig, QueueFailedStoreError, type QueueJobContext, type QueueJobContextOverrides, type QueueJobDefinition, type QueueJobEnvelope, type QueueJsonValue, type QueuePayloadFor, type QueuePendingDispatch, type QueueRedisConnectionConfig, type QueueRegisteredJob, type QueueReleaseOptions, QueueReleaseUnsupportedError, type QueueReserveInput, type QueueReservedJob, type QueueResultFor, type QueueRuntimeBinding, type QueueSyncConnectionConfig, type QueueSyncDriver, type QueueWorkerHooks, type QueueWorkerJobEvent, type QueueWorkerOptions, type QueueWorkerResult, type QueueWorkerRunOptions, QueueWorkerTimeoutError, QueueWorkerUnsupportedDriverError, RedisQueueDriver, RedisQueueDriverError, type RegisterQueueJobOptions, type RegisterableQueueJobDefinition, clearQueueConnection, configureQueueRuntime, defineJob, dispatch, dispatchSync, flushFailedQueueJobs, forgetFailedQueueJob, getQueueRuntime, getRegisteredQueueJob, holoQueueDefaults, isQueueJobDefinition, listFailedQueueJobs, listRegisteredQueueJobs, normalizeQueueConfig, normalizeQueueJobDefinition, persistFailedQueueJob, queueFailedInternals, queueInternals, queueJobInternals, queueRegistryInternals, queueRuntimeInternals, queueWorkerInternals, redisQueueDriverFactory, redisQueueDriverInternals, registerQueueJob, registerQueueJobs, resetQueueRegistry, resetQueueRuntime, retryFailedQueueJobs, runQueueWorker, shutdownQueueRuntime, syncQueueDriverFactory, syncQueueDriverInternals, unregisterQueueJob, useQueueConnection };