bunqueue-client 0.1.9 → 0.2.0

package/dist/types/src/domain/queue/shard/dlq.d.ts

@@ -0,0 +1,26 @@
+import type { DlqConfig, DlqEntry, DlqFilter } from "../../types/dlq.js";
+import { FailureReason } from "../../types/dlq.js";
+import type { Job, JobId } from "../../types/job.js";
+import type { StallConfig } from "../../types/stall.js";
+import { ShardDependencies } from "./dependencies.js";
+/** Dead-letter and stall configuration operations. */
+export declare class ShardDlq extends ShardDependencies {
+    get dlq(): Map<string, DlqEntry[]>;
+    get dlqConfig(): Map<string, DlqConfig>;
+    get stallConfig(): Map<string, StallConfig>;
+    getDlqConfig(queue: string): DlqConfig;
+    setDlqConfig(queue: string, config: Partial<DlqConfig>): void;
+    getStallConfig(queue: string): StallConfig;
+    setStallConfig(queue: string, config: Partial<StallConfig>): void;
+    addToDlq(job: Job, reason?: FailureReason, error?: string | null): DlqEntry;
+    restoreDlqEntry(queue: string, entry: DlqEntry): void;
+    getDlqEntries(queue: string): DlqEntry[];
+    getDlq(queue: string, count?: number): Job[];
+    getDlqFiltered(queue: string, filter: DlqFilter): DlqEntry[];
+    removeFromDlq(queue: string, jobId: JobId): DlqEntry | null;
+    removeAllFromDlq(queue: string, jobId: JobId): DlqEntry[];
+    getAutoRetryEntries(queue: string, now?: number): DlqEntry[];
+    getExpiredEntries(queue: string, now?: number): DlqEntry[];
+    purgeExpired(queue: string, now?: number): number;
+    clearDlq(queue: string): number;
+}

package/dist/types/src/domain/queue/shard/keys.d.ts

@@ -0,0 +1,19 @@
+import type { UniqueKeyEntry } from "../../types/deduplication.js";
+import type { JobId } from "../../types/job.js";
+import { ShardState } from "./state.js";
+/** Deduplication keys and FIFO group ownership. */
+export declare class ShardKeys extends ShardState {
+    isUniqueAvailable(queue: string, key: string): boolean;
+    getUniqueKeyEntry(queue: string, key: string): UniqueKeyEntry | null;
+    registerUniqueKey(queue: string, key: string, jobId: JobId): void;
+    registerUniqueKeyWithTtl(queue: string, key: string, jobId: JobId, ttl?: number): void;
+    extendUniqueKeyTtl(queue: string, key: string, ttl: number): boolean;
+    releaseUniqueKey(queue: string, key: string): boolean;
+    releaseUniqueKeyIfOwned(queue: string, key: string, ownerId: JobId): boolean;
+    cleanExpiredUniqueKeys(): number;
+    get uniqueKeys(): Map<string, Map<string, UniqueKeyEntry>>;
+    isGroupActive(queue: string, groupId: string): boolean;
+    activateGroup(queue: string, groupId: string): void;
+    releaseGroup(queue: string, groupId: string): void;
+    getGroupActiveCount(queue: string, groupId: string): number;
+}

package/dist/types/src/domain/queue/shard/lifecycle.d.ts

@@ -0,0 +1,10 @@
+import type { JobId } from "../../types/job.js";
+import { ShardMetrics } from "./metrics.js";
+/** Drain and obliterate transitions across all shard collaborators. */
+export declare class ShardLifecycle extends ShardMetrics {
+    drain(queue: string): {
+        count: number;
+        jobIds: JobId[];
+    };
+    obliterate(queue: string): JobId[];
+}

package/dist/types/src/domain/queue/shard/limits.d.ts

@@ -0,0 +1,47 @@
+import type { Job, JobId } from "../../types/job.js";
+import type { GroupPullOptions, GroupRateLimitOverride } from "../../types/group.js";
+import type { GroupCandidate } from "../groupScheduler.js";
+import type { QueueState } from "../../types/queue.js";
+import { ShardKeys } from "./keys.js";
+/** Queue rate, concurrency, and resource ownership operations. */
+export declare class ShardLimits extends ShardKeys {
+    hasGroupScheduler(queue: string): boolean;
+    assignGroupFifoOrder(job: Job): void;
+    observeGroupFifoOrder(job: Job): void;
+    peekGroupCandidate(queue: string, now: number, options?: GroupPullOptions): GroupCandidate;
+    acquireGroup(queue: string, groupId: string, options?: GroupPullOptions, now?: number): boolean;
+    advanceGroup(queue: string, groupId: string): void;
+    getGroupJobsCount(queue: string, groupId: string): number;
+    getGroupsJobsCount(queue: string): number;
+    cleanExpiredGroupWindows(now: number): void;
+    clearEmptyGroupRuntime(queue: string): void;
+    setGroupRateLimit(queue: string, groupId: string, max: number, duration: number): void;
+    getGroupRateLimit(queue: string, groupId: string): GroupRateLimitOverride | null;
+    removeGroupRateLimit(queue: string, groupId: string): number;
+    getGroupRateLimitTtl(queue: string, groupId: string, maxJobs?: number): number;
+    setGroupConcurrency(queue: string, groupId: string, concurrency: number): void;
+    getGroupConcurrency(queue: string, groupId: string): number | null;
+    removeGroupConcurrency(queue: string, groupId: string): number;
+    pauseGroup(queue: string, groupId: string): boolean;
+    resumeGroup(queue: string, groupId: string): boolean;
+    isGroupPaused(queue: string, groupId: string): boolean;
+    rateLimitGroup(queue: string, groupId: string, duration: number): void;
+    setRateLimit(queue: string, limit: number, durationMs?: number, ttlMs?: number): void;
+    clearRateLimit(queue: string): void;
+    expireRateLimitIfNeeded(queue: string): void;
+    tryAcquireRateLimit(queue: string): boolean;
+    getRateLimit(queue: string): {
+        max: number;
+        duration: number;
+    } | null;
+    getRateLimitTtl(queue: string, maxJobs?: number): number;
+    setConcurrency(queue: string, limit: number): void;
+    clearConcurrency(queue: string): void;
+    tryAcquireConcurrency(queue: string): boolean;
+    releaseConcurrency(queue: string): void;
+    getConcurrency(queue: string): number | null;
+    isConcurrencyMaxed(queue: string): boolean;
+    get queueState(): Map<string, QueueState>;
+    clearQueueLimiters(queue: string): void;
+    releaseJobResources(queue: string, uniqueKey: string | null, groupId: string | null, ownerId?: JobId): void;
+}

package/dist/types/src/domain/queue/shard/metrics.d.ts

@@ -0,0 +1,32 @@
+import type { JobId } from "../../types/job.js";
+import type { ShardStats } from "../shardCounters.js";
+import { ShardDlq } from "./dlq.js";
+/** Queue counts, running counters, and temporal-index operations. */
+export declare class ShardMetrics extends ShardDlq {
+    getWaitingCount(queue: string): number;
+    getDlqCount(queue: string): number;
+    getCountsPerPriority(queue: string): Map<number, number>;
+    getStats(): ShardStats;
+    getInternalSizes(): {
+        delayedJobIds: number;
+        delayedHeap: number;
+        delayedRunAt: number;
+        temporalIndex: number;
+        waiters: number;
+    };
+    incrementQueued(jobId: JobId, isDelayed: boolean, createdAt?: number, queue?: string, runAt?: number): void;
+    decrementQueued(jobId: JobId): void;
+    promoteDelayed(jobId: JobId): void;
+    incrementDlq(): void;
+    decrementDlq(count?: number): void;
+    refreshDelayedCount(now: number): void;
+    resetQueuedCounters(): void;
+    resetDlqCounter(): void;
+    getOldJobs(queue: string, thresholdMs: number, limit: number): Array<{
+        jobId: JobId;
+        createdAt: number;
+    }>;
+    removeFromTemporalIndex(jobId: JobId): void;
+    clearTemporalIndexForQueue(queue: string): void;
+    cleanOrphanedTemporalEntries(): number;
+}

package/dist/types/src/domain/queue/shard/state.d.ts

@@ -0,0 +1,40 @@
+import type { QueueState } from "../../types/queue.js";
+import type { ShardOptions } from "../../types/shard.js";
+import { DependencyTracker } from "../dependencyTracker.js";
+import { DlqShard } from "../dlqShard.js";
+import { LimiterManager } from "../limiterManager.js";
+import { IndexedPriorityQueue } from "../priorityQueue.js";
+import { GroupLimiterManager } from "../groupLimiterManager.js";
+import { GroupScheduler } from "../groupScheduler.js";
+import { ShardCounters } from "../shardCounters.js";
+import { TemporalManager } from "../temporalManager.js";
+import { UniqueKeyManager } from "../uniqueKeyManager.js";
+import { WaiterManager } from "../waiterManager.js";
+/** Owns the collaborating shard managers and basic queue/waiter operations. */
+export declare class ShardState {
+    readonly queues: Map<string, IndexedPriorityQueue>;
+    readonly activeGroups: Map<string, Set<string>>;
+    readonly activeGroupCounts: Map<string, Map<string, number>>;
+    protected readonly uniqueKeyManager: UniqueKeyManager;
+    protected readonly dlqManager: DlqShard;
+    protected readonly limiterManager: LimiterManager;
+    protected readonly groupLimiterManager: GroupLimiterManager;
+    protected readonly groupScheduler: GroupScheduler;
+    protected readonly dependencyTracker: DependencyTracker;
+    protected readonly temporalManager: TemporalManager;
+    protected readonly waiterManager: WaiterManager;
+    protected readonly counters: ShardCounters;
+    constructor(options?: ShardOptions);
+    notify(queue?: string): void;
+    notifyBatch(count: number): void;
+    notifyBatch(queue: string, count: number): void;
+    waitForJob(timeoutMs: number, signal?: AbortSignal): Promise<void>;
+    waitForJob(queue: string, timeoutMs: number, signal?: AbortSignal): Promise<void>;
+    getQueue(name: string): IndexedPriorityQueue;
+    getState(name: string): QueueState;
+    isPaused(name: string): boolean;
+    pause(name: string): void;
+    resume(name: string): void;
+    getQueueNames(): string[];
+    getConfiguredQueueNames(): string[];
+}

package/dist/types/src/domain/queue/shard.d.ts

@@ -0,0 +1,7 @@
+/** Public Shard façade. */
+import { ShardLifecycle } from "./shard/lifecycle.js";
+export type { ShardStats } from "./shardCounters.js";
+export type { ShardOptions } from "../types/shard.js";
+/** Shard behavior is composed from focused manager-delegation layers. */
+export declare class Shard extends ShardLifecycle {
+}

package/dist/types/src/domain/queue/shardCounters.d.ts

@@ -0,0 +1,35 @@
+/**
+ * ShardCounters - Running counters for O(1) stats retrieval
+ * Tracks queued, delayed, and DLQ job counts
+ */
+import type { JobId } from "../types/job.js";
+import type { TemporalManager } from "./temporalManager.js";
+/** Shard statistics counters for O(1) stats retrieval */
+export interface ShardStats {
+    /** Total jobs in all queues (waiting + delayed) */
+    queuedJobs: number;
+    /** Jobs with runAt > now at time of push */
+    delayedJobs: number;
+    /** Total jobs in DLQ */
+    dlqJobs: number;
+}
+export declare class ShardCounters {
+    private readonly temporalManager;
+    /** Running counters for O(1) stats */
+    private readonly stats;
+    constructor(temporalManager: TemporalManager);
+    getStats(): ShardStats;
+    incrementQueued(jobId: JobId, isDelayed: boolean, createdAt?: number, queue?: string, runAt?: number): void;
+    decrementQueued(jobId: JobId): void;
+    incrementDlq(): void;
+    decrementDlq(count?: number): void;
+    refreshDelayedCount(now: number): void;
+    resetQueuedCounters(): void;
+    resetDlqCounter(): void;
+    /** Adjust queuedJobs counter directly (for drain/obliterate) */
+    adjustQueued(delta: number): void;
+    /** Adjust dlqJobs counter directly (for obliterate) */
+    adjustDlq(delta: number): void;
+    /** Sync delayedJobs to the temporal manager's actual count */
+    syncDelayedCount(): void;
+}

package/dist/types/src/domain/queue/temporalIndex.d.ts

@@ -0,0 +1,24 @@
+import type { JobId } from "../types/job.js";
+export interface TemporalEntry {
+    createdAt: number;
+    jobId: JobId;
+    queue: string;
+}
+/** Queue-local temporal indexes with direct lookup by job ID. */
+export declare class TemporalIndex {
+    private readonly indexesByQueue;
+    private readonly entriesByJobId;
+    private entryCount;
+    get size(): number;
+    add(createdAt: number, jobId: JobId, queue: string): void;
+    getOldJobs(queue: string, threshold: number, limit: number): Array<{
+        jobId: JobId;
+        createdAt: number;
+    }>;
+    remove(jobId: JobId): void;
+    clearQueue(queue: string): void;
+    cleanOrphaned(validJobIds: Set<JobId>): number;
+    clear(): void;
+    private removeFromQueueIndex;
+    private detachJobEntry;
+}

package/dist/types/src/domain/queue/temporalManager.d.ts

@@ -0,0 +1,72 @@
+/**
+ * TemporalManager - Manages temporal index and delayed job tracking
+ *
+ * Provides:
+ * - Temporal index (SkipList) for efficient cleanQueue range queries
+ * - Delayed heap (MinHeap) for O(k) delayed job refresh
+ */
+import type { JobId } from "../types/job.js";
+export type { TemporalEntry } from "./temporalIndex.js";
+/**
+ * Manages temporal indexing for efficient job cleanup
+ * and delayed job tracking for O(k) refresh
+ */
+export declare class TemporalManager {
+    private readonly temporalIndex;
+    /** Set of delayed job IDs for tracking when they become ready */
+    private readonly delayedJobIds;
+    /**
+     * Min-heap of delayed jobs ordered by runAt for O(k) refresh
+     * Instead of O(n × queues) iteration
+     */
+    private readonly delayedHeap;
+    /** Map from jobId to current runAt for stale detection in delayedHeap */
+    private readonly delayedRunAt;
+    /** Add job to temporal index - O(log n) */
+    addToIndex(createdAt: number, jobId: JobId, queue: string): void;
+    /**
+     * Get old jobs from temporal index - O(log n + k)
+     * Returns jobs older than threshold, up to limit
+     */
+    getOldJobs(queue: string, thresholdMs: number, limit: number): Array<{
+        jobId: JobId;
+        createdAt: number;
+    }>;
+    /** Remove job from temporal index */
+    removeFromIndex(jobId: JobId): void;
+    /** Clear temporal index for a queue */
+    clearIndexForQueue(queue: string): void;
+    /**
+     * Clean orphaned temporal index entries.
+     * Removes entries for jobs that no longer exist.
+     */
+    cleanOrphaned(validJobIds: Set<JobId>): number;
+    /** Get temporal index size */
+    get indexSize(): number;
+    /** Check if job is delayed */
+    isDelayed(jobId: JobId): boolean;
+    /** Add a delayed job */
+    addDelayed(jobId: JobId, runAt: number): void;
+    /** Remove a delayed job (lazy removal from heap) */
+    removeDelayed(jobId: JobId): boolean;
+    /**
+     * Refresh delayed jobs that have become ready
+     * O(k) where k = jobs that became ready
+     * Returns number of jobs that became ready
+     */
+    refreshDelayed(now: number): number;
+    private maybeCompactDelayedHeap;
+    /** Get delayed job count */
+    get delayedCount(): number;
+    /** Clear all delayed tracking */
+    clearDelayed(): void;
+    /** Clear all data */
+    clear(): void;
+    /** Get internal structure sizes for memory debugging */
+    getSizes(): {
+        delayedJobIds: number;
+        delayedHeap: number;
+        delayedRunAt: number;
+        temporalIndex: number;
+    };
+}

package/dist/types/src/domain/queue/uniqueKeyManager.d.ts

@@ -0,0 +1,33 @@
+/**
+ * UniqueKeyManager - Handles job deduplication with TTL support
+ */
+import type { JobId } from "../types/job.js";
+import type { UniqueKeyEntry } from "../types/deduplication.js";
+/**
+ * Manages unique keys per queue for job deduplication
+ * Supports TTL-based expiration
+ */
+export declare class UniqueKeyManager {
+    /** Unique keys per queue (queue -> key -> entry) */
+    private readonly keys;
+    /** Check if unique key is available (not registered or expired) */
+    isAvailable(queue: string, key: string): boolean;
+    /** Get unique key entry (returns null if not found or expired) */
+    getEntry(queue: string, key: string): UniqueKeyEntry | null;
+    /** Register unique key (legacy method without TTL) */
+    register(queue: string, key: string, jobId: JobId): void;
+    /** Register unique key with TTL support */
+    registerWithTtl(queue: string, key: string, jobId: JobId, ttl?: number): void;
+    /** Extend TTL for an existing unique key */
+    extendTtl(queue: string, key: string, ttl: number): boolean;
+    /** Release unique key */
+    release(queue: string, key: string): boolean;
+    /** Release a key only when it is still owned by the given job. */
+    releaseIfOwned(queue: string, key: string, ownerId: JobId): boolean;
+    /** Clean expired unique keys (call periodically) */
+    cleanExpired(): number;
+    /** Clear all keys for a queue */
+    clearQueue(queue: string): void;
+    /** Get the underlying map (for backward compatibility) */
+    getMap(): Map<string, Map<string, UniqueKeyEntry>>;
+}

package/dist/types/src/domain/queue/waiterManager.d.ts

@@ -0,0 +1,18 @@
+/**
+ * WaiterManager - Manages queue-scoped job availability notifications.
+ * Handles worker polling with timeout-based waiting.
+ */
+export declare class WaiterManager {
+    private readonly queues;
+    private activeWaiters;
+    notify(queue?: string): void;
+    notifyBatch(count: number): void;
+    notifyBatch(queue: string, count: number): void;
+    waitForJob(timeoutMs: number, signal?: AbortSignal): Promise<void>;
+    waitForJob(queue: string, timeoutMs: number, signal?: AbortSignal): Promise<void>;
+    private notifyQueue;
+    private createQueue;
+    private compact;
+    private deleteIdleQueue;
+    get length(): number;
+}

package/dist/types/src/domain/response/builders.d.ts

@@ -0,0 +1,15 @@
+import type { Job } from "../types/job.js";
+import type { BatchResponse, DataResponse, ErrorResponse, HelloResponse, JobCounts, JobCountsResponse, JobResponse, JobsResponse, MetricsData, MetricsResponse, NullableJobResponse, OkResponse, ProtocolCapability, PulledJobResponse, PulledJobsResponse, StatsData, StatsResponse } from "../types/responses/model.js";
+export declare function ok(id?: string, reqId?: string): OkResponse;
+export declare function batch(ids: string[], reqId?: string): BatchResponse;
+export declare function job(value: Job, reqId?: string): JobResponse;
+export declare function nullableJob(value: Job | null, reqId?: string): NullableJobResponse;
+export declare function pulledJob(value: Job | null, token: string | null, reqId?: string): PulledJobResponse;
+export declare function pulledJobs(list: Job[], tokens: string[], reqId?: string): PulledJobsResponse;
+export declare function jobs(list: Job[], reqId?: string): JobsResponse;
+export declare function error(message: string, reqId?: string): ErrorResponse;
+export declare function hello(protocolVersion: number, capabilities: ProtocolCapability[], server: string, version: string, reqId?: string): HelloResponse;
+export declare function data<T>(payload: T, reqId?: string): DataResponse<T>;
+export declare function counts(value: JobCounts, reqId?: string): JobCountsResponse;
+export declare function stats(value: StatsData, reqId?: string): StatsResponse;
+export declare function metrics(value: MetricsData, reqId?: string): MetricsResponse;

package/dist/types/src/domain/types/command.d.ts

@@ -0,0 +1,2 @@
+/** Backwards-compatible barrel for protocol command types. */
+export * from "./commands/index.js";

package/dist/types/src/domain/types/commands/base.d.ts

@@ -0,0 +1,5 @@
+/** Shared request metadata for every protocol command. */
+export interface BaseCommand {
+    readonly cmd: string;
+    readonly reqId?: string;
+}

package/dist/types/src/domain/types/commands/core.d.ts

@@ -0,0 +1,110 @@
+import type { AtomicFlowJobInput } from "../flow.js";
+import type { JobInput } from "../job.js";
+import type { GroupPullOptions } from "../group.js";
+import type { BaseCommand } from "./base.js";
+export interface PushCommand extends BaseCommand {
+    readonly cmd: 'PUSH';
+    readonly queue: string;
+    readonly name?: string;
+    readonly data: unknown;
+    readonly priority?: number;
+    readonly delay?: number;
+    readonly maxAttempts?: number;
+    readonly backoff?: number | {
+        type: 'fixed' | 'exponential';
+        delay: number;
+    };
+    readonly ttl?: number;
+    readonly timeout?: number;
+    readonly uniqueKey?: string;
+    readonly jobId?: string;
+    readonly dependsOn?: string[];
+    readonly childrenIds?: string[];
+    readonly parentId?: string;
+    readonly tags?: string[];
+    readonly groupId?: string;
+    readonly groupMaxSize?: number;
+    readonly lifo?: boolean;
+    readonly removeOnComplete?: boolean;
+    readonly removeOnFail?: boolean;
+    readonly durable?: boolean;
+    readonly repeat?: {
+        every?: number;
+        limit?: number;
+        pattern?: string;
+        count?: number;
+        startDate?: number;
+        endDate?: number;
+        tz?: string;
+        immediately?: boolean;
+        prevMillis?: number;
+        offset?: number;
+        jobId?: string;
+    };
+    readonly failParentOnFailure?: boolean;
+    readonly removeDependencyOnFailure?: boolean;
+    readonly ignoreDependencyOnFailure?: boolean;
+    readonly continueParentOnFailure?: boolean;
+    readonly stallTimeout?: number;
+    readonly stackTraceLimit?: number;
+    readonly keepLogs?: number;
+    readonly sizeLimit?: number;
+    readonly dedup?: {
+        ttl?: number;
+        extend?: boolean;
+        replace?: boolean;
+    };
+    readonly debounceId?: string;
+    readonly debounceTtl?: number;
+    readonly timestamp?: number;
+}
+export interface PushBatchCommand extends BaseCommand {
+    readonly cmd: 'PUSHB';
+    readonly queue: string;
+    readonly jobs: JobInput[];
+}
+export interface PushFlowCommand extends BaseCommand {
+    readonly cmd: 'PUSHF';
+    readonly jobs: AtomicFlowJobInput[];
+}
+export interface PullCommand extends BaseCommand {
+    readonly cmd: 'PULL';
+    readonly queue: string;
+    readonly timeout?: number;
+    readonly owner?: string;
+    readonly lockTtl?: number;
+    readonly detach?: boolean;
+    readonly group?: GroupPullOptions;
+}
+export interface PullBatchCommand extends BaseCommand {
+    readonly cmd: 'PULLB';
+    readonly queue: string;
+    readonly count: number;
+    readonly timeout?: number;
+    readonly owner?: string;
+    readonly lockTtl?: number;
+    readonly group?: GroupPullOptions;
+}
+export interface AckCommand extends BaseCommand {
+    readonly cmd: 'ACK';
+    readonly id: string;
+    readonly result?: unknown;
+    readonly token?: string;
+    readonly removeOnComplete?: boolean;
+}
+export interface AckBatchCommand extends BaseCommand {
+    readonly cmd: 'ACKB';
+    readonly ids: string[];
+    readonly results?: unknown[];
+    readonly tokens?: string[];
+    readonly removeOnCompletes?: Array<boolean | null>;
+}
+export interface FailCommand extends BaseCommand {
+    readonly cmd: 'FAIL';
+    readonly id: string;
+    readonly error?: string;
+    readonly token?: string;
+    readonly unrecoverable?: boolean;
+    readonly stack?: string[];
+    readonly removeOnFail?: boolean;
+}

package/dist/types/src/domain/types/commands/cron.d.ts

@@ -0,0 +1,36 @@
+import type { CronJobOptions } from "../cron.js";
+import type { BaseCommand } from "./base.js";
+export interface CronCommand extends BaseCommand {
+    readonly cmd: 'Cron';
+    readonly name: string;
+    readonly jobName?: string;
+    readonly queue: string;
+    readonly data: unknown;
+    readonly schedule?: string;
+    readonly repeatEvery?: number;
+    readonly priority?: number;
+    readonly maxLimit?: number;
+    readonly timezone?: string;
+    readonly uniqueKey?: string;
+    readonly dedup?: {
+        ttl?: number;
+        extend?: boolean;
+        replace?: boolean;
+    };
+    readonly skipMissedOnRestart?: boolean;
+    readonly immediately?: boolean;
+    readonly skipIfNoWorker?: boolean;
+    readonly preventOverlap?: boolean;
+    readonly jobOptions?: CronJobOptions;
+}
+export interface CronDeleteCommand extends BaseCommand {
+    readonly cmd: 'CronDelete';
+    readonly name: string;
+}
+export interface CronListCommand extends BaseCommand {
+    readonly cmd: 'CronList';
+}
+export interface CronGetCommand extends BaseCommand {
+    readonly cmd: 'CronGet';
+    readonly name: string;
+}

package/dist/types/src/domain/types/commands/dashboard.d.ts

@@ -0,0 +1,13 @@
+import type { BaseCommand } from "./base.js";
+export interface DashboardOverviewCommand extends BaseCommand {
+    readonly cmd: 'DashboardOverview';
+}
+export interface DashboardQueuesCommand extends BaseCommand {
+    readonly cmd: 'DashboardQueues';
+}
+export interface DashboardQueueCommand extends BaseCommand {
+    readonly cmd: 'DashboardQueue';
+    readonly queue: string;
+    readonly includeJobs?: boolean;
+    readonly jobsLimit?: number;
+}

package/dist/types/src/domain/types/commands/dlq.d.ts

@@ -0,0 +1,44 @@
+import type { DlqFilter } from "../dlq.js";
+import type { BaseCommand } from "./base.js";
+export interface DlqCommand extends BaseCommand {
+    readonly cmd: 'Dlq';
+    readonly queue: string;
+    readonly count?: number;
+    readonly filter?: DlqFilter;
+}
+export interface GetDlqStatsCommand extends BaseCommand {
+    readonly cmd: 'GetDlqStats';
+    readonly queue: string;
+}
+export interface RetryDlqCommand extends BaseCommand {
+    readonly cmd: 'RetryDlq';
+    readonly queue: string;
+    readonly jobId?: string;
+    readonly count?: number;
+    readonly filter?: DlqFilter;
+}
+export interface PurgeDlqCommand extends BaseCommand {
+    readonly cmd: 'PurgeDlq';
+    readonly queue: string;
+}
+export interface RemoveDlqJobCommand extends BaseCommand {
+    readonly cmd: 'RemoveDlqJob';
+    readonly queue: string;
+    readonly jobId: string;
+}
+export interface RetryCompletedCommand extends BaseCommand {
+    readonly cmd: 'RetryCompleted';
+    readonly queue: string;
+    readonly id?: string;
+    readonly count?: number;
+    readonly timestamp?: number;
+}
+export interface SetDlqConfigCommand extends BaseCommand {
+    readonly cmd: 'SetDlqConfig';
+    readonly queue: string;
+    readonly config: Record<string, unknown>;
+}
+export interface GetDlqConfigCommand extends BaseCommand {
+    readonly cmd: 'GetDlqConfig';
+    readonly queue: string;
+}