@objectstack/spec 0.7.1 → 0.7.2

package/dist/system/worker.zod.d.ts

@@ -0,0 +1,1458 @@
+import { z } from 'zod';
+/**
+ * Worker System Protocol
+ *
+ * Background task processing system with queues, priorities, and retry logic.
+ * Provides a robust foundation for async task execution similar to:
+ * - Sidekiq (Ruby)
+ * - Celery (Python)
+ * - Bull/BullMQ (Node.js)
+ * - AWS SQS/Lambda
+ *
+ * Features:
+ * - Task queues with priorities
+ * - Task scheduling and retry logic
+ * - Batch processing
+ * - Dead letter queues
+ * - Task monitoring and logging
+ *
+ * @example Basic task
+ * ```typescript
+ * const task: Task = {
+ *   id: 'task-123',
+ *   type: 'send_email',
+ *   payload: { to: 'user@example.com', subject: 'Welcome' },
+ *   queue: 'notifications',
+ *   priority: 5
+ * };
+ * ```
+ */
+/**
+ * Task Priority Enum
+ * Lower numbers = higher priority
+ */
+export declare const TaskPriority: z.ZodEnum<["critical", "high", "normal", "low", "background"]>;
+export type TaskPriority = z.infer<typeof TaskPriority>;
+/**
+ * Task Priority Mapping
+ * Maps priority names to numeric values for sorting
+ */
+export declare const TASK_PRIORITY_VALUES: Record<TaskPriority, number>;
+/**
+ * Task Status Enum
+ * Lifecycle states of a task
+ */
+export declare const TaskStatus: z.ZodEnum<["pending", "queued", "processing", "completed", "failed", "cancelled", "timeout", "dead"]>;
+export type TaskStatus = z.infer<typeof TaskStatus>;
+/**
+ * Task Retry Policy Schema
+ * Configuration for task retry behavior
+ */
+export declare const TaskRetryPolicySchema: z.ZodObject<{
+    maxRetries: z.ZodDefault<z.ZodNumber>;
+    backoffStrategy: z.ZodDefault<z.ZodEnum<["fixed", "linear", "exponential"]>>;
+    initialDelayMs: z.ZodDefault<z.ZodNumber>;
+    maxDelayMs: z.ZodDefault<z.ZodNumber>;
+    backoffMultiplier: z.ZodDefault<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    maxRetries: number;
+    backoffMultiplier: number;
+    backoffStrategy: "fixed" | "linear" | "exponential";
+    initialDelayMs: number;
+    maxDelayMs: number;
+}, {
+    maxRetries?: number | undefined;
+    backoffMultiplier?: number | undefined;
+    backoffStrategy?: "fixed" | "linear" | "exponential" | undefined;
+    initialDelayMs?: number | undefined;
+    maxDelayMs?: number | undefined;
+}>;
+export type TaskRetryPolicy = z.infer<typeof TaskRetryPolicySchema>;
+/**
+ * Task Schema
+ * Represents a background task to be executed
+ *
+ * @example
+ * {
+ *   "id": "task-abc123",
+ *   "type": "send_email",
+ *   "payload": { "to": "user@example.com", "template": "welcome" },
+ *   "queue": "notifications",
+ *   "priority": "high",
+ *   "retryPolicy": {
+ *     "maxRetries": 3,
+ *     "backoffStrategy": "exponential"
+ *   }
+ * }
+ */
+export declare const TaskSchema: z.ZodObject<{
+    /**
+     * Unique task identifier
+     */
+    id: z.ZodString;
+    /**
+     * Task type (handler identifier)
+     */
+    type: z.ZodString;
+    /**
+     * Task payload data
+     */
+    payload: z.ZodAny;
+    /**
+     * Queue name
+     */
+    queue: z.ZodDefault<z.ZodString>;
+    /**
+     * Task priority
+     */
+    priority: z.ZodDefault<z.ZodEnum<["critical", "high", "normal", "low", "background"]>>;
+    /**
+     * Retry policy
+     */
+    retryPolicy: z.ZodOptional<z.ZodObject<{
+        maxRetries: z.ZodDefault<z.ZodNumber>;
+        backoffStrategy: z.ZodDefault<z.ZodEnum<["fixed", "linear", "exponential"]>>;
+        initialDelayMs: z.ZodDefault<z.ZodNumber>;
+        maxDelayMs: z.ZodDefault<z.ZodNumber>;
+        backoffMultiplier: z.ZodDefault<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        maxRetries: number;
+        backoffMultiplier: number;
+        backoffStrategy: "fixed" | "linear" | "exponential";
+        initialDelayMs: number;
+        maxDelayMs: number;
+    }, {
+        maxRetries?: number | undefined;
+        backoffMultiplier?: number | undefined;
+        backoffStrategy?: "fixed" | "linear" | "exponential" | undefined;
+        initialDelayMs?: number | undefined;
+        maxDelayMs?: number | undefined;
+    }>>;
+    /**
+     * Execution timeout in milliseconds
+     */
+    timeoutMs: z.ZodOptional<z.ZodNumber>;
+    /**
+     * Scheduled execution time
+     */
+    scheduledAt: z.ZodOptional<z.ZodString>;
+    /**
+     * Maximum execution attempts
+     */
+    attempts: z.ZodDefault<z.ZodNumber>;
+    /**
+     * Task status
+     */
+    status: z.ZodDefault<z.ZodEnum<["pending", "queued", "processing", "completed", "failed", "cancelled", "timeout", "dead"]>>;
+    /**
+     * Task metadata
+     */
+    metadata: z.ZodOptional<z.ZodObject<{
+        createdAt: z.ZodOptional<z.ZodString>;
+        updatedAt: z.ZodOptional<z.ZodString>;
+        createdBy: z.ZodOptional<z.ZodString>;
+        tags: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        tags?: string[] | undefined;
+        createdAt?: string | undefined;
+        createdBy?: string | undefined;
+        updatedAt?: string | undefined;
+    }, {
+        tags?: string[] | undefined;
+        createdAt?: string | undefined;
+        createdBy?: string | undefined;
+        updatedAt?: string | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    type: string;
+    status: "timeout" | "pending" | "processing" | "completed" | "failed" | "queued" | "cancelled" | "dead";
+    priority: "background" | "normal" | "critical" | "high" | "low";
+    id: string;
+    queue: string;
+    attempts: number;
+    metadata?: {
+        tags?: string[] | undefined;
+        createdAt?: string | undefined;
+        createdBy?: string | undefined;
+        updatedAt?: string | undefined;
+    } | undefined;
+    payload?: any;
+    timeoutMs?: number | undefined;
+    retryPolicy?: {
+        maxRetries: number;
+        backoffMultiplier: number;
+        backoffStrategy: "fixed" | "linear" | "exponential";
+        initialDelayMs: number;
+        maxDelayMs: number;
+    } | undefined;
+    scheduledAt?: string | undefined;
+}, {
+    type: string;
+    id: string;
+    status?: "timeout" | "pending" | "processing" | "completed" | "failed" | "queued" | "cancelled" | "dead" | undefined;
+    priority?: "background" | "normal" | "critical" | "high" | "low" | undefined;
+    metadata?: {
+        tags?: string[] | undefined;
+        createdAt?: string | undefined;
+        createdBy?: string | undefined;
+        updatedAt?: string | undefined;
+    } | undefined;
+    payload?: any;
+    timeoutMs?: number | undefined;
+    retryPolicy?: {
+        maxRetries?: number | undefined;
+        backoffMultiplier?: number | undefined;
+        backoffStrategy?: "fixed" | "linear" | "exponential" | undefined;
+        initialDelayMs?: number | undefined;
+        maxDelayMs?: number | undefined;
+    } | undefined;
+    queue?: string | undefined;
+    scheduledAt?: string | undefined;
+    attempts?: number | undefined;
+}>;
+export type Task = z.infer<typeof TaskSchema>;
+/**
+ * Task Execution Result Schema
+ * Result of a task execution attempt
+ */
+export declare const TaskExecutionResultSchema: z.ZodObject<{
+    /**
+     * Task identifier
+     */
+    taskId: z.ZodString;
+    /**
+     * Execution status
+     */
+    status: z.ZodEnum<["pending", "queued", "processing", "completed", "failed", "cancelled", "timeout", "dead"]>;
+    /**
+     * Execution result data
+     */
+    result: z.ZodOptional<z.ZodAny>;
+    /**
+     * Error information
+     */
+    error: z.ZodOptional<z.ZodObject<{
+        message: z.ZodString;
+        stack: z.ZodOptional<z.ZodString>;
+        code: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        message: string;
+        code?: string | undefined;
+        stack?: string | undefined;
+    }, {
+        message: string;
+        code?: string | undefined;
+        stack?: string | undefined;
+    }>>;
+    /**
+     * Execution duration
+     */
+    durationMs: z.ZodOptional<z.ZodNumber>;
+    /**
+     * Execution timestamps
+     */
+    startedAt: z.ZodString;
+    completedAt: z.ZodOptional<z.ZodString>;
+    /**
+     * Retry information
+     */
+    attempt: z.ZodNumber;
+    willRetry: z.ZodBoolean;
+}, "strip", z.ZodTypeAny, {
+    status: "timeout" | "pending" | "processing" | "completed" | "failed" | "queued" | "cancelled" | "dead";
+    startedAt: string;
+    taskId: string;
+    attempt: number;
+    willRetry: boolean;
+    error?: {
+        message: string;
+        code?: string | undefined;
+        stack?: string | undefined;
+    } | undefined;
+    result?: any;
+    durationMs?: number | undefined;
+    completedAt?: string | undefined;
+}, {
+    status: "timeout" | "pending" | "processing" | "completed" | "failed" | "queued" | "cancelled" | "dead";
+    startedAt: string;
+    taskId: string;
+    attempt: number;
+    willRetry: boolean;
+    error?: {
+        message: string;
+        code?: string | undefined;
+        stack?: string | undefined;
+    } | undefined;
+    result?: any;
+    durationMs?: number | undefined;
+    completedAt?: string | undefined;
+}>;
+export type TaskExecutionResult = z.infer<typeof TaskExecutionResultSchema>;
+/**
+ * Queue Configuration Schema
+ * Configuration for a task queue
+ *
+ * @example
+ * {
+ *   "name": "notifications",
+ *   "concurrency": 10,
+ *   "rateLimit": {
+ *     "max": 100,
+ *     "duration": 60000
+ *   }
+ * }
+ */
+export declare const QueueConfigSchema: z.ZodObject<{
+    /**
+     * Queue name
+     */
+    name: z.ZodString;
+    /**
+     * Maximum concurrent workers
+     */
+    concurrency: z.ZodDefault<z.ZodNumber>;
+    /**
+     * Rate limiting
+     */
+    rateLimit: z.ZodOptional<z.ZodObject<{
+        max: z.ZodNumber;
+        duration: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        max: number;
+        duration: number;
+    }, {
+        max: number;
+        duration: number;
+    }>>;
+    /**
+     * Default retry policy
+     */
+    defaultRetryPolicy: z.ZodOptional<z.ZodObject<{
+        maxRetries: z.ZodDefault<z.ZodNumber>;
+        backoffStrategy: z.ZodDefault<z.ZodEnum<["fixed", "linear", "exponential"]>>;
+        initialDelayMs: z.ZodDefault<z.ZodNumber>;
+        maxDelayMs: z.ZodDefault<z.ZodNumber>;
+        backoffMultiplier: z.ZodDefault<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        maxRetries: number;
+        backoffMultiplier: number;
+        backoffStrategy: "fixed" | "linear" | "exponential";
+        initialDelayMs: number;
+        maxDelayMs: number;
+    }, {
+        maxRetries?: number | undefined;
+        backoffMultiplier?: number | undefined;
+        backoffStrategy?: "fixed" | "linear" | "exponential" | undefined;
+        initialDelayMs?: number | undefined;
+        maxDelayMs?: number | undefined;
+    }>>;
+    /**
+     * Dead letter queue
+     */
+    deadLetterQueue: z.ZodOptional<z.ZodString>;
+    /**
+     * Queue priority
+     */
+    priority: z.ZodDefault<z.ZodNumber>;
+    /**
+     * Auto-scaling configuration
+     */
+    autoScale: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        minWorkers: z.ZodDefault<z.ZodNumber>;
+        maxWorkers: z.ZodDefault<z.ZodNumber>;
+        scaleUpThreshold: z.ZodDefault<z.ZodNumber>;
+        scaleDownThreshold: z.ZodDefault<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        enabled: boolean;
+        minWorkers: number;
+        maxWorkers: number;
+        scaleUpThreshold: number;
+        scaleDownThreshold: number;
+    }, {
+        enabled?: boolean | undefined;
+        minWorkers?: number | undefined;
+        maxWorkers?: number | undefined;
+        scaleUpThreshold?: number | undefined;
+        scaleDownThreshold?: number | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    priority: number;
+    concurrency: number;
+    rateLimit?: {
+        max: number;
+        duration: number;
+    } | undefined;
+    deadLetterQueue?: string | undefined;
+    defaultRetryPolicy?: {
+        maxRetries: number;
+        backoffMultiplier: number;
+        backoffStrategy: "fixed" | "linear" | "exponential";
+        initialDelayMs: number;
+        maxDelayMs: number;
+    } | undefined;
+    autoScale?: {
+        enabled: boolean;
+        minWorkers: number;
+        maxWorkers: number;
+        scaleUpThreshold: number;
+        scaleDownThreshold: number;
+    } | undefined;
+}, {
+    name: string;
+    priority?: number | undefined;
+    rateLimit?: {
+        max: number;
+        duration: number;
+    } | undefined;
+    concurrency?: number | undefined;
+    deadLetterQueue?: string | undefined;
+    defaultRetryPolicy?: {
+        maxRetries?: number | undefined;
+        backoffMultiplier?: number | undefined;
+        backoffStrategy?: "fixed" | "linear" | "exponential" | undefined;
+        initialDelayMs?: number | undefined;
+        maxDelayMs?: number | undefined;
+    } | undefined;
+    autoScale?: {
+        enabled?: boolean | undefined;
+        minWorkers?: number | undefined;
+        maxWorkers?: number | undefined;
+        scaleUpThreshold?: number | undefined;
+        scaleDownThreshold?: number | undefined;
+    } | undefined;
+}>;
+export type QueueConfig = z.infer<typeof QueueConfigSchema>;
+/**
+ * Batch Task Schema
+ * Configuration for batch processing multiple items
+ *
+ * @example
+ * {
+ *   "id": "batch-import-123",
+ *   "type": "import_records",
+ *   "items": [{ "name": "Item 1" }, { "name": "Item 2" }],
+ *   "batchSize": 100,
+ *   "queue": "batch_processing"
+ * }
+ */
+export declare const BatchTaskSchema: z.ZodObject<{
+    /**
+     * Batch job identifier
+     */
+    id: z.ZodString;
+    /**
+     * Task type for processing each item
+     */
+    type: z.ZodString;
+    /**
+     * Items to process
+     */
+    items: z.ZodArray<z.ZodAny, "many">;
+    /**
+     * Batch size (items per task)
+     */
+    batchSize: z.ZodDefault<z.ZodNumber>;
+    /**
+     * Queue name
+     */
+    queue: z.ZodDefault<z.ZodString>;
+    /**
+     * Priority
+     */
+    priority: z.ZodDefault<z.ZodEnum<["critical", "high", "normal", "low", "background"]>>;
+    /**
+     * Parallel processing
+     */
+    parallel: z.ZodDefault<z.ZodBoolean>;
+    /**
+     * Stop on error
+     */
+    stopOnError: z.ZodDefault<z.ZodBoolean>;
+    /**
+     * Progress callback
+     *
+     * Called after each batch completes to report progress.
+     * Invoked asynchronously and should not throw errors.
+     * If the callback throws, the error is logged but batch processing continues.
+     *
+     * @param progress - Object containing processed count, total count, and failed count
+     */
+    onProgress: z.ZodOptional<z.ZodFunction<z.ZodTuple<[z.ZodObject<{
+        processed: z.ZodNumber;
+        total: z.ZodNumber;
+        failed: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        total: number;
+        failed: number;
+        processed: number;
+    }, {
+        total: number;
+        failed: number;
+        processed: number;
+    }>], z.ZodUnknown>, z.ZodVoid>>;
+}, "strip", z.ZodTypeAny, {
+    type: string;
+    priority: "background" | "normal" | "critical" | "high" | "low";
+    id: string;
+    batchSize: number;
+    items: any[];
+    queue: string;
+    parallel: boolean;
+    stopOnError: boolean;
+    onProgress?: ((args_0: {
+        total: number;
+        failed: number;
+        processed: number;
+    }, ...args: unknown[]) => void) | undefined;
+}, {
+    type: string;
+    id: string;
+    items: any[];
+    priority?: "background" | "normal" | "critical" | "high" | "low" | undefined;
+    batchSize?: number | undefined;
+    queue?: string | undefined;
+    parallel?: boolean | undefined;
+    stopOnError?: boolean | undefined;
+    onProgress?: ((args_0: {
+        total: number;
+        failed: number;
+        processed: number;
+    }, ...args: unknown[]) => void) | undefined;
+}>;
+export type BatchTask = z.infer<typeof BatchTaskSchema>;
+/**
+ * Batch Progress Schema
+ * Tracks progress of a batch job
+ */
+export declare const BatchProgressSchema: z.ZodObject<{
+    /**
+     * Batch job identifier
+     */
+    batchId: z.ZodString;
+    /**
+     * Total items
+     */
+    total: z.ZodNumber;
+    /**
+     * Processed items
+     */
+    processed: z.ZodDefault<z.ZodNumber>;
+    /**
+     * Successful items
+     */
+    succeeded: z.ZodDefault<z.ZodNumber>;
+    /**
+     * Failed items
+     */
+    failed: z.ZodDefault<z.ZodNumber>;
+    /**
+     * Progress percentage
+     */
+    percentage: z.ZodNumber;
+    /**
+     * Status
+     */
+    status: z.ZodEnum<["pending", "running", "completed", "failed", "cancelled"]>;
+    /**
+     * Timestamps
+     */
+    startedAt: z.ZodOptional<z.ZodString>;
+    completedAt: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    status: "pending" | "completed" | "failed" | "running" | "cancelled";
+    total: number;
+    failed: number;
+    processed: number;
+    batchId: string;
+    succeeded: number;
+    percentage: number;
+    startedAt?: string | undefined;
+    completedAt?: string | undefined;
+}, {
+    status: "pending" | "completed" | "failed" | "running" | "cancelled";
+    total: number;
+    batchId: string;
+    percentage: number;
+    failed?: number | undefined;
+    startedAt?: string | undefined;
+    completedAt?: string | undefined;
+    processed?: number | undefined;
+    succeeded?: number | undefined;
+}>;
+export type BatchProgress = z.infer<typeof BatchProgressSchema>;
+/**
+ * Worker Configuration Schema
+ * Configuration for a worker instance
+ */
+export declare const WorkerConfigSchema: z.ZodObject<{
+    /**
+     * Worker name
+     */
+    name: z.ZodString;
+    /**
+     * Queues to process
+     */
+    queues: z.ZodArray<z.ZodString, "many">;
+    /**
+     * Queue configurations
+     */
+    queueConfigs: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        /**
+         * Queue name
+         */
+        name: z.ZodString;
+        /**
+         * Maximum concurrent workers
+         */
+        concurrency: z.ZodDefault<z.ZodNumber>;
+        /**
+         * Rate limiting
+         */
+        rateLimit: z.ZodOptional<z.ZodObject<{
+            max: z.ZodNumber;
+            duration: z.ZodNumber;
+        }, "strip", z.ZodTypeAny, {
+            max: number;
+            duration: number;
+        }, {
+            max: number;
+            duration: number;
+        }>>;
+        /**
+         * Default retry policy
+         */
+        defaultRetryPolicy: z.ZodOptional<z.ZodObject<{
+            maxRetries: z.ZodDefault<z.ZodNumber>;
+            backoffStrategy: z.ZodDefault<z.ZodEnum<["fixed", "linear", "exponential"]>>;
+            initialDelayMs: z.ZodDefault<z.ZodNumber>;
+            maxDelayMs: z.ZodDefault<z.ZodNumber>;
+            backoffMultiplier: z.ZodDefault<z.ZodNumber>;
+        }, "strip", z.ZodTypeAny, {
+            maxRetries: number;
+            backoffMultiplier: number;
+            backoffStrategy: "fixed" | "linear" | "exponential";
+            initialDelayMs: number;
+            maxDelayMs: number;
+        }, {
+            maxRetries?: number | undefined;
+            backoffMultiplier?: number | undefined;
+            backoffStrategy?: "fixed" | "linear" | "exponential" | undefined;
+            initialDelayMs?: number | undefined;
+            maxDelayMs?: number | undefined;
+        }>>;
+        /**
+         * Dead letter queue
+         */
+        deadLetterQueue: z.ZodOptional<z.ZodString>;
+        /**
+         * Queue priority
+         */
+        priority: z.ZodDefault<z.ZodNumber>;
+        /**
+         * Auto-scaling configuration
+         */
+        autoScale: z.ZodOptional<z.ZodObject<{
+            enabled: z.ZodDefault<z.ZodBoolean>;
+            minWorkers: z.ZodDefault<z.ZodNumber>;
+            maxWorkers: z.ZodDefault<z.ZodNumber>;
+            scaleUpThreshold: z.ZodDefault<z.ZodNumber>;
+            scaleDownThreshold: z.ZodDefault<z.ZodNumber>;
+        }, "strip", z.ZodTypeAny, {
+            enabled: boolean;
+            minWorkers: number;
+            maxWorkers: number;
+            scaleUpThreshold: number;
+            scaleDownThreshold: number;
+        }, {
+            enabled?: boolean | undefined;
+            minWorkers?: number | undefined;
+            maxWorkers?: number | undefined;
+            scaleUpThreshold?: number | undefined;
+            scaleDownThreshold?: number | undefined;
+        }>>;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+        priority: number;
+        concurrency: number;
+        rateLimit?: {
+            max: number;
+            duration: number;
+        } | undefined;
+        deadLetterQueue?: string | undefined;
+        defaultRetryPolicy?: {
+            maxRetries: number;
+            backoffMultiplier: number;
+            backoffStrategy: "fixed" | "linear" | "exponential";
+            initialDelayMs: number;
+            maxDelayMs: number;
+        } | undefined;
+        autoScale?: {
+            enabled: boolean;
+            minWorkers: number;
+            maxWorkers: number;
+            scaleUpThreshold: number;
+            scaleDownThreshold: number;
+        } | undefined;
+    }, {
+        name: string;
+        priority?: number | undefined;
+        rateLimit?: {
+            max: number;
+            duration: number;
+        } | undefined;
+        concurrency?: number | undefined;
+        deadLetterQueue?: string | undefined;
+        defaultRetryPolicy?: {
+            maxRetries?: number | undefined;
+            backoffMultiplier?: number | undefined;
+            backoffStrategy?: "fixed" | "linear" | "exponential" | undefined;
+            initialDelayMs?: number | undefined;
+            maxDelayMs?: number | undefined;
+        } | undefined;
+        autoScale?: {
+            enabled?: boolean | undefined;
+            minWorkers?: number | undefined;
+            maxWorkers?: number | undefined;
+            scaleUpThreshold?: number | undefined;
+            scaleDownThreshold?: number | undefined;
+        } | undefined;
+    }>, "many">>;
+    /**
+     * Polling interval
+     */
+    pollIntervalMs: z.ZodDefault<z.ZodNumber>;
+    /**
+     * Visibility timeout
+     */
+    visibilityTimeoutMs: z.ZodDefault<z.ZodNumber>;
+    /**
+     * Task timeout
+     */
+    defaultTimeoutMs: z.ZodDefault<z.ZodNumber>;
+    /**
+     * Graceful shutdown timeout
+     */
+    shutdownTimeoutMs: z.ZodDefault<z.ZodNumber>;
+    /**
+     * Task handlers
+     */
+    handlers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodFunction<z.ZodTuple<[], z.ZodUnknown>, z.ZodUnknown>>>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    queues: string[];
+    pollIntervalMs: number;
+    visibilityTimeoutMs: number;
+    defaultTimeoutMs: number;
+    shutdownTimeoutMs: number;
+    handlers?: Record<string, (...args: unknown[]) => unknown> | undefined;
+    queueConfigs?: {
+        name: string;
+        priority: number;
+        concurrency: number;
+        rateLimit?: {
+            max: number;
+            duration: number;
+        } | undefined;
+        deadLetterQueue?: string | undefined;
+        defaultRetryPolicy?: {
+            maxRetries: number;
+            backoffMultiplier: number;
+            backoffStrategy: "fixed" | "linear" | "exponential";
+            initialDelayMs: number;
+            maxDelayMs: number;
+        } | undefined;
+        autoScale?: {
+            enabled: boolean;
+            minWorkers: number;
+            maxWorkers: number;
+            scaleUpThreshold: number;
+            scaleDownThreshold: number;
+        } | undefined;
+    }[] | undefined;
+}, {
+    name: string;
+    queues: string[];
+    handlers?: Record<string, (...args: unknown[]) => unknown> | undefined;
+    queueConfigs?: {
+        name: string;
+        priority?: number | undefined;
+        rateLimit?: {
+            max: number;
+            duration: number;
+        } | undefined;
+        concurrency?: number | undefined;
+        deadLetterQueue?: string | undefined;
+        defaultRetryPolicy?: {
+            maxRetries?: number | undefined;
+            backoffMultiplier?: number | undefined;
+            backoffStrategy?: "fixed" | "linear" | "exponential" | undefined;
+            initialDelayMs?: number | undefined;
+            maxDelayMs?: number | undefined;
+        } | undefined;
+        autoScale?: {
+            enabled?: boolean | undefined;
+            minWorkers?: number | undefined;
+            maxWorkers?: number | undefined;
+            scaleUpThreshold?: number | undefined;
+            scaleDownThreshold?: number | undefined;
+        } | undefined;
+    }[] | undefined;
+    pollIntervalMs?: number | undefined;
+    visibilityTimeoutMs?: number | undefined;
+    defaultTimeoutMs?: number | undefined;
+    shutdownTimeoutMs?: number | undefined;
+}>;
+export type WorkerConfig = z.infer<typeof WorkerConfigSchema>;
+/**
+ * Worker Stats Schema
+ * Runtime statistics for a worker
+ */
+export declare const WorkerStatsSchema: z.ZodObject<{
+    /**
+     * Worker name
+     */
+    workerName: z.ZodString;
+    /**
+     * Total tasks processed
+     */
+    totalProcessed: z.ZodNumber;
+    /**
+     * Successful tasks
+     */
+    succeeded: z.ZodNumber;
+    /**
+     * Failed tasks
+     */
+    failed: z.ZodNumber;
+    /**
+     * Active tasks
+     */
+    active: z.ZodNumber;
+    /**
+     * Average execution time
+     */
+    avgExecutionMs: z.ZodOptional<z.ZodNumber>;
+    /**
+     * Uptime
+     */
+    uptimeMs: z.ZodNumber;
+    /**
+     * Queue stats
+     */
+    queues: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        pending: z.ZodNumber;
+        active: z.ZodNumber;
+        completed: z.ZodNumber;
+        failed: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        active: number;
+        pending: number;
+        completed: number;
+        failed: number;
+    }, {
+        active: number;
+        pending: number;
+        completed: number;
+        failed: number;
+    }>>>;
+}, "strip", z.ZodTypeAny, {
+    active: number;
+    failed: number;
+    succeeded: number;
+    workerName: string;
+    totalProcessed: number;
+    uptimeMs: number;
+    queues?: Record<string, {
+        active: number;
+        pending: number;
+        completed: number;
+        failed: number;
+    }> | undefined;
+    avgExecutionMs?: number | undefined;
+}, {
+    active: number;
+    failed: number;
+    succeeded: number;
+    workerName: string;
+    totalProcessed: number;
+    uptimeMs: number;
+    queues?: Record<string, {
+        active: number;
+        pending: number;
+        completed: number;
+        failed: number;
+    }> | undefined;
+    avgExecutionMs?: number | undefined;
+}>;
+export type WorkerStats = z.infer<typeof WorkerStatsSchema>;
+/**
+ * Helper to create a task
+ */
+export declare const Task: z.ZodObject<{
+    /**
+     * Unique task identifier
+     */
+    id: z.ZodString;
+    /**
+     * Task type (handler identifier)
+     */
+    type: z.ZodString;
+    /**
+     * Task payload data
+     */
+    payload: z.ZodAny;
+    /**
+     * Queue name
+     */
+    queue: z.ZodDefault<z.ZodString>;
+    /**
+     * Task priority
+     */
+    priority: z.ZodDefault<z.ZodEnum<["critical", "high", "normal", "low", "background"]>>;
+    /**
+     * Retry policy
+     */
+    retryPolicy: z.ZodOptional<z.ZodObject<{
+        maxRetries: z.ZodDefault<z.ZodNumber>;
+        backoffStrategy: z.ZodDefault<z.ZodEnum<["fixed", "linear", "exponential"]>>;
+        initialDelayMs: z.ZodDefault<z.ZodNumber>;
+        maxDelayMs: z.ZodDefault<z.ZodNumber>;
+        backoffMultiplier: z.ZodDefault<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        maxRetries: number;
+        backoffMultiplier: number;
+        backoffStrategy: "fixed" | "linear" | "exponential";
+        initialDelayMs: number;
+        maxDelayMs: number;
+    }, {
+        maxRetries?: number | undefined;
+        backoffMultiplier?: number | undefined;
+        backoffStrategy?: "fixed" | "linear" | "exponential" | undefined;
+        initialDelayMs?: number | undefined;
+        maxDelayMs?: number | undefined;
+    }>>;
+    /**
+     * Execution timeout in milliseconds
+     */
+    timeoutMs: z.ZodOptional<z.ZodNumber>;
+    /**
+     * Scheduled execution time
+     */
+    scheduledAt: z.ZodOptional<z.ZodString>;
+    /**
+     * Maximum execution attempts
+     */
+    attempts: z.ZodDefault<z.ZodNumber>;
+    /**
+     * Task status
+     */
+    status: z.ZodDefault<z.ZodEnum<["pending", "queued", "processing", "completed", "failed", "cancelled", "timeout", "dead"]>>;
+    /**
+     * Task metadata
+     */
+    metadata: z.ZodOptional<z.ZodObject<{
+        createdAt: z.ZodOptional<z.ZodString>;
+        updatedAt: z.ZodOptional<z.ZodString>;
+        createdBy: z.ZodOptional<z.ZodString>;
+        tags: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        tags?: string[] | undefined;
+        createdAt?: string | undefined;
+        createdBy?: string | undefined;
+        updatedAt?: string | undefined;
+    }, {
+        tags?: string[] | undefined;
+        createdAt?: string | undefined;
+        createdBy?: string | undefined;
+        updatedAt?: string | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    type: string;
+    status: "timeout" | "pending" | "processing" | "completed" | "failed" | "queued" | "cancelled" | "dead";
+    priority: "background" | "normal" | "critical" | "high" | "low";
+    id: string;
+    queue: string;
+    attempts: number;
+    metadata?: {
+        tags?: string[] | undefined;
+        createdAt?: string | undefined;
+        createdBy?: string | undefined;
+        updatedAt?: string | undefined;
+    } | undefined;
+    payload?: any;
+    timeoutMs?: number | undefined;
+    retryPolicy?: {
+        maxRetries: number;
+        backoffMultiplier: number;
+        backoffStrategy: "fixed" | "linear" | "exponential";
+        initialDelayMs: number;
+        maxDelayMs: number;
+    } | undefined;
+    scheduledAt?: string | undefined;
+}, {
+    type: string;
+    id: string;
+    status?: "timeout" | "pending" | "processing" | "completed" | "failed" | "queued" | "cancelled" | "dead" | undefined;
+    priority?: "background" | "normal" | "critical" | "high" | "low" | undefined;
+    metadata?: {
+        tags?: string[] | undefined;
+        createdAt?: string | undefined;
+        createdBy?: string | undefined;
+        updatedAt?: string | undefined;
+    } | undefined;
+    payload?: any;
+    timeoutMs?: number | undefined;
+    retryPolicy?: {
+        maxRetries?: number | undefined;
+        backoffMultiplier?: number | undefined;
+        backoffStrategy?: "fixed" | "linear" | "exponential" | undefined;
+        initialDelayMs?: number | undefined;
+        maxDelayMs?: number | undefined;
+    } | undefined;
+    queue?: string | undefined;
+    scheduledAt?: string | undefined;
+    attempts?: number | undefined;
+}> & {
+    create: <T extends z.input<typeof TaskSchema>>(task: T) => T;
+};
+/**
+ * Helper to create a queue config
+ */
+export declare const QueueConfig: z.ZodObject<{
+    /**
+     * Queue name
+     */
+    name: z.ZodString;
+    /**
+     * Maximum concurrent workers
+     */
+    concurrency: z.ZodDefault<z.ZodNumber>;
+    /**
+     * Rate limiting
+     */
+    rateLimit: z.ZodOptional<z.ZodObject<{
+        max: z.ZodNumber;
+        duration: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        max: number;
+        duration: number;
+    }, {
+        max: number;
+        duration: number;
+    }>>;
+    /**
+     * Default retry policy
+     */
+    defaultRetryPolicy: z.ZodOptional<z.ZodObject<{
+        maxRetries: z.ZodDefault<z.ZodNumber>;
+        backoffStrategy: z.ZodDefault<z.ZodEnum<["fixed", "linear", "exponential"]>>;
+        initialDelayMs: z.ZodDefault<z.ZodNumber>;
+        maxDelayMs: z.ZodDefault<z.ZodNumber>;
+        backoffMultiplier: z.ZodDefault<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        maxRetries: number;
+        backoffMultiplier: number;
+        backoffStrategy: "fixed" | "linear" | "exponential";
+        initialDelayMs: number;
+        maxDelayMs: number;
+    }, {
+        maxRetries?: number | undefined;
+        backoffMultiplier?: number | undefined;
+        backoffStrategy?: "fixed" | "linear" | "exponential" | undefined;
+        initialDelayMs?: number | undefined;
+        maxDelayMs?: number | undefined;
+    }>>;
+    /**
+     * Dead letter queue
+     */
+    deadLetterQueue: z.ZodOptional<z.ZodString>;
+    /**
+     * Queue priority
+     */
+    priority: z.ZodDefault<z.ZodNumber>;
+    /**
+     * Auto-scaling configuration
+     */
+    autoScale: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        minWorkers: z.ZodDefault<z.ZodNumber>;
+        maxWorkers: z.ZodDefault<z.ZodNumber>;
+        scaleUpThreshold: z.ZodDefault<z.ZodNumber>;
+        scaleDownThreshold: z.ZodDefault<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        enabled: boolean;
+        minWorkers: number;
+        maxWorkers: number;
+        scaleUpThreshold: number;
+        scaleDownThreshold: number;
+    }, {
+        enabled?: boolean | undefined;
+        minWorkers?: number | undefined;
+        maxWorkers?: number | undefined;
+        scaleUpThreshold?: number | undefined;
+        scaleDownThreshold?: number | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    priority: number;
+    concurrency: number;
+    rateLimit?: {
+        max: number;
+        duration: number;
+    } | undefined;
+    deadLetterQueue?: string | undefined;
+    defaultRetryPolicy?: {
+        maxRetries: number;
+        backoffMultiplier: number;
+        backoffStrategy: "fixed" | "linear" | "exponential";
+        initialDelayMs: number;
+        maxDelayMs: number;
+    } | undefined;
+    autoScale?: {
+        enabled: boolean;
+        minWorkers: number;
+        maxWorkers: number;
+        scaleUpThreshold: number;
+        scaleDownThreshold: number;
+    } | undefined;
+}, {
+    name: string;
+    priority?: number | undefined;
+    rateLimit?: {
+        max: number;
+        duration: number;
+    } | undefined;
+    concurrency?: number | undefined;
+    deadLetterQueue?: string | undefined;
+    defaultRetryPolicy?: {
+        maxRetries?: number | undefined;
+        backoffMultiplier?: number | undefined;
+        backoffStrategy?: "fixed" | "linear" | "exponential" | undefined;
+        initialDelayMs?: number | undefined;
+        maxDelayMs?: number | undefined;
+    } | undefined;
+    autoScale?: {
+        enabled?: boolean | undefined;
+        minWorkers?: number | undefined;
+        maxWorkers?: number | undefined;
+        scaleUpThreshold?: number | undefined;
+        scaleDownThreshold?: number | undefined;
+    } | undefined;
+}> & {
+    create: <T extends z.input<typeof QueueConfigSchema>>(config: T) => T;
+};
+/**
+ * Helper to create a worker config
+ */
+export declare const WorkerConfig: z.ZodObject<{
+    /**
+     * Worker name
+     */
+    name: z.ZodString;
+    /**
+     * Queues to process
+     */
+    queues: z.ZodArray<z.ZodString, "many">;
+    /**
+     * Queue configurations
+     */
+    queueConfigs: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        /**
+         * Queue name
+         */
+        name: z.ZodString;
+        /**
+         * Maximum concurrent workers
+         */
+        concurrency: z.ZodDefault<z.ZodNumber>;
+        /**
+         * Rate limiting
+         */
+        rateLimit: z.ZodOptional<z.ZodObject<{
+            max: z.ZodNumber;
+            duration: z.ZodNumber;
+        }, "strip", z.ZodTypeAny, {
+            max: number;
+            duration: number;
+        }, {
+            max: number;
+            duration: number;
+        }>>;
+        /**
+         * Default retry policy
+         */
+        defaultRetryPolicy: z.ZodOptional<z.ZodObject<{
+            maxRetries: z.ZodDefault<z.ZodNumber>;
+            backoffStrategy: z.ZodDefault<z.ZodEnum<["fixed", "linear", "exponential"]>>;
+            initialDelayMs: z.ZodDefault<z.ZodNumber>;
+            maxDelayMs: z.ZodDefault<z.ZodNumber>;
+            backoffMultiplier: z.ZodDefault<z.ZodNumber>;
+        }, "strip", z.ZodTypeAny, {
+            maxRetries: number;
+            backoffMultiplier: number;
+            backoffStrategy: "fixed" | "linear" | "exponential";
+            initialDelayMs: number;
+            maxDelayMs: number;
+        }, {
+            maxRetries?: number | undefined;
+            backoffMultiplier?: number | undefined;
+            backoffStrategy?: "fixed" | "linear" | "exponential" | undefined;
+            initialDelayMs?: number | undefined;
+            maxDelayMs?: number | undefined;
+        }>>;
+        /**
+         * Dead letter queue
+         */
+        deadLetterQueue: z.ZodOptional<z.ZodString>;
+        /**
+         * Queue priority
+         */
+        priority: z.ZodDefault<z.ZodNumber>;
+        /**
+         * Auto-scaling configuration
+         */
+        autoScale: z.ZodOptional<z.ZodObject<{
+            enabled: z.ZodDefault<z.ZodBoolean>;
+            minWorkers: z.ZodDefault<z.ZodNumber>;
+            maxWorkers: z.ZodDefault<z.ZodNumber>;
+            scaleUpThreshold: z.ZodDefault<z.ZodNumber>;
+            scaleDownThreshold: z.ZodDefault<z.ZodNumber>;
+        }, "strip", z.ZodTypeAny, {
+            enabled: boolean;
+            minWorkers: number;
+            maxWorkers: number;
+            scaleUpThreshold: number;
+            scaleDownThreshold: number;
+        }, {
+            enabled?: boolean | undefined;
+            minWorkers?: number | undefined;
+            maxWorkers?: number | undefined;
+            scaleUpThreshold?: number | undefined;
+            scaleDownThreshold?: number | undefined;
+        }>>;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+        priority: number;
+        concurrency: number;
+        rateLimit?: {
+            max: number;
+            duration: number;
+        } | undefined;
+        deadLetterQueue?: string | undefined;
+        defaultRetryPolicy?: {
+            maxRetries: number;
+            backoffMultiplier: number;
+            backoffStrategy: "fixed" | "linear" | "exponential";
+            initialDelayMs: number;
+            maxDelayMs: number;
+        } | undefined;
+        autoScale?: {
+            enabled: boolean;
+            minWorkers: number;
+            maxWorkers: number;
+            scaleUpThreshold: number;
+            scaleDownThreshold: number;
+        } | undefined;
+    }, {
+        name: string;
+        priority?: number | undefined;
+        rateLimit?: {
+            max: number;
+            duration: number;
+        } | undefined;
+        concurrency?: number | undefined;
+        deadLetterQueue?: string | undefined;
+        defaultRetryPolicy?: {
+            maxRetries?: number | undefined;
+            backoffMultiplier?: number | undefined;
+            backoffStrategy?: "fixed" | "linear" | "exponential" | undefined;
+            initialDelayMs?: number | undefined;
+            maxDelayMs?: number | undefined;
+        } | undefined;
+        autoScale?: {
+            enabled?: boolean | undefined;
+            minWorkers?: number | undefined;
+            maxWorkers?: number | undefined;
+            scaleUpThreshold?: number | undefined;
+            scaleDownThreshold?: number | undefined;
+        } | undefined;
+    }>, "many">>;
+    /**
+     * Polling interval
+     */
+    pollIntervalMs: z.ZodDefault<z.ZodNumber>;
+    /**
+     * Visibility timeout
+     */
+    visibilityTimeoutMs: z.ZodDefault<z.ZodNumber>;
+    /**
+     * Task timeout
+     */
+    defaultTimeoutMs: z.ZodDefault<z.ZodNumber>;
+    /**
+     * Graceful shutdown timeout
+     */
+    shutdownTimeoutMs: z.ZodDefault<z.ZodNumber>;
+    /**
+     * Task handlers
+     */
+    handlers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodFunction<z.ZodTuple<[], z.ZodUnknown>, z.ZodUnknown>>>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    queues: string[];
+    pollIntervalMs: number;
+    visibilityTimeoutMs: number;
+    defaultTimeoutMs: number;
+    shutdownTimeoutMs: number;
+    handlers?: Record<string, (...args: unknown[]) => unknown> | undefined;
+    queueConfigs?: {
+        name: string;
+        priority: number;
+        concurrency: number;
+        rateLimit?: {
+            max: number;
+            duration: number;
+        } | undefined;
+        deadLetterQueue?: string | undefined;
+        defaultRetryPolicy?: {
+            maxRetries: number;
+            backoffMultiplier: number;
+            backoffStrategy: "fixed" | "linear" | "exponential";
+            initialDelayMs: number;
+            maxDelayMs: number;
+        } | undefined;
+        autoScale?: {
+            enabled: boolean;
+            minWorkers: number;
+            maxWorkers: number;
+            scaleUpThreshold: number;
+            scaleDownThreshold: number;
+        } | undefined;
+    }[] | undefined;
+}, {
+    name: string;
+    queues: string[];
+    handlers?: Record<string, (...args: unknown[]) => unknown> | undefined;
+    queueConfigs?: {
+        name: string;
+        priority?: number | undefined;
+        rateLimit?: {
+            max: number;
+            duration: number;
+        } | undefined;
+        concurrency?: number | undefined;
+        deadLetterQueue?: string | undefined;
+        defaultRetryPolicy?: {
+            maxRetries?: number | undefined;
+            backoffMultiplier?: number | undefined;
+            backoffStrategy?: "fixed" | "linear" | "exponential" | undefined;
+            initialDelayMs?: number | undefined;
+            maxDelayMs?: number | undefined;
+        } | undefined;
+        autoScale?: {
+            enabled?: boolean | undefined;
+            minWorkers?: number | undefined;
+            maxWorkers?: number | undefined;
+            scaleUpThreshold?: number | undefined;
+            scaleDownThreshold?: number | undefined;
+        } | undefined;
+    }[] | undefined;
+    pollIntervalMs?: number | undefined;
+    visibilityTimeoutMs?: number | undefined;
+    defaultTimeoutMs?: number | undefined;
+    shutdownTimeoutMs?: number | undefined;
+}> & {
+    create: <T extends z.input<typeof WorkerConfigSchema>>(config: T) => T;
+};
+/**
+ * Helper to create a batch task
+ */
+export declare const BatchTask: z.ZodObject<{
+    /**
+     * Batch job identifier
+     */
+    id: z.ZodString;
+    /**
+     * Task type for processing each item
+     */
+    type: z.ZodString;
+    /**
+     * Items to process
+     */
+    items: z.ZodArray<z.ZodAny, "many">;
+    /**
+     * Batch size (items per task)
+     */
+    batchSize: z.ZodDefault<z.ZodNumber>;
+    /**
+     * Queue name
+     */
+    queue: z.ZodDefault<z.ZodString>;
+    /**
+     * Priority
+     */
+    priority: z.ZodDefault<z.ZodEnum<["critical", "high", "normal", "low", "background"]>>;
+    /**
+     * Parallel processing
+     */
+    parallel: z.ZodDefault<z.ZodBoolean>;
+    /**
+     * Stop on error
+     */
+    stopOnError: z.ZodDefault<z.ZodBoolean>;
+    /**
+     * Progress callback
+     *
+     * Called after each batch completes to report progress.
+     * Invoked asynchronously and should not throw errors.
+     * If the callback throws, the error is logged but batch processing continues.
+     *
+     * @param progress - Object containing processed count, total count, and failed count
+     */
+    onProgress: z.ZodOptional<z.ZodFunction<z.ZodTuple<[z.ZodObject<{
+        processed: z.ZodNumber;
+        total: z.ZodNumber;
+        failed: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        total: number;
+        failed: number;
+        processed: number;
+    }, {
+        total: number;
+        failed: number;
+        processed: number;
+    }>], z.ZodUnknown>, z.ZodVoid>>;
+}, "strip", z.ZodTypeAny, {
+    type: string;
+    priority: "background" | "normal" | "critical" | "high" | "low";
+    id: string;
+    batchSize: number;
+    items: any[];
+    queue: string;
+    parallel: boolean;
+    stopOnError: boolean;
+    onProgress?: ((args_0: {
+        total: number;
+        failed: number;
+        processed: number;
+    }, ...args: unknown[]) => void) | undefined;
+}, {
+    type: string;
+    id: string;
+    items: any[];
+    priority?: "background" | "normal" | "critical" | "high" | "low" | undefined;
+    batchSize?: number | undefined;
+    queue?: string | undefined;
+    parallel?: boolean | undefined;
+    stopOnError?: boolean | undefined;
+    onProgress?: ((args_0: {
+        total: number;
+        failed: number;
+        processed: number;
+    }, ...args: unknown[]) => void) | undefined;
+}> & {
+    create: <T extends z.input<typeof BatchTaskSchema>>(batch: T) => T;
+};
+//# sourceMappingURL=worker.zod.d.ts.map