@objectstack/spec 0.7.2 → 0.8.0

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

@@ -31,7 +31,13 @@ import { z } from 'zod';
  * Task Priority Enum
  * Lower numbers = higher priority
  */
-export declare const TaskPriority: z.ZodEnum<["critical", "high", "normal", "low", "background"]>;
+export declare const TaskPriority: z.ZodEnum<{
+    background: "background";
+    normal: "normal";
+    critical: "critical";
+    high: "high";
+    low: "low";
+}>;
 export type TaskPriority = z.infer<typeof TaskPriority>;
 /**
  * Task Priority Mapping
@@ -42,7 +48,16 @@ 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 declare const TaskStatus: z.ZodEnum<{
+    timeout: "timeout";
+    pending: "pending";
+    processing: "processing";
+    completed: "completed";
+    failed: "failed";
+    queued: "queued";
+    cancelled: "cancelled";
+    dead: "dead";
+}>;
 export type TaskStatus = z.infer<typeof TaskStatus>;
 /**
  * Task Retry Policy Schema
@@ -50,23 +65,15 @@ export type TaskStatus = z.infer<typeof TaskStatus>;
  */
 export declare const TaskRetryPolicySchema: z.ZodObject<{
     maxRetries: z.ZodDefault<z.ZodNumber>;
-    backoffStrategy: z.ZodDefault<z.ZodEnum<["fixed", "linear", "exponential"]>>;
+    backoffStrategy: z.ZodDefault<z.ZodEnum<{
+        fixed: "fixed";
+        linear: "linear";
+        exponential: "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;
-}>;
+}, z.core.$strip>;
 export type TaskRetryPolicy = z.infer<typeof TaskRetryPolicySchema>;
 /**
  * Task Schema
@@ -86,207 +93,77 @@ export type TaskRetryPolicy = z.infer<typeof TaskRetryPolicySchema>;
  * }
  */
 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
-     */
+    priority: z.ZodDefault<z.ZodEnum<{
+        background: "background";
+        normal: "normal";
+        critical: "critical";
+        high: "high";
+        low: "low";
+    }>>;
     retryPolicy: z.ZodOptional<z.ZodObject<{
         maxRetries: z.ZodDefault<z.ZodNumber>;
-        backoffStrategy: z.ZodDefault<z.ZodEnum<["fixed", "linear", "exponential"]>>;
+        backoffStrategy: z.ZodDefault<z.ZodEnum<{
+            fixed: "fixed";
+            linear: "linear";
+            exponential: "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
-     */
+    }, z.core.$strip>>;
     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
-     */
+    status: z.ZodDefault<z.ZodEnum<{
+        timeout: "timeout";
+        pending: "pending";
+        processing: "processing";
+        completed: "completed";
+        failed: "failed";
+        queued: "queued";
+        cancelled: "cancelled";
+        dead: "dead";
+    }>>;
     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;
-}>;
+        tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
 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
-     */
+    status: z.ZodEnum<{
+        timeout: "timeout";
+        pending: "pending";
+        processing: "processing";
+        completed: "completed";
+        failed: "failed";
+        queued: "queued";
+        cancelled: "cancelled";
+        dead: "dead";
+    }>;
     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
-     */
+    }, z.core.$strip>>;
     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;
-}>;
+}, z.core.$strip>;
 export type TaskExecutionResult = z.infer<typeof TaskExecutionResultSchema>;
 /**
  * Queue Configuration Schema
@@ -303,126 +180,33 @@ export type TaskExecutionResult = z.infer<typeof TaskExecutionResultSchema>;
  * }
  */
 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
-     */
+    }, z.core.$strip>>;
     defaultRetryPolicy: z.ZodOptional<z.ZodObject<{
         maxRetries: z.ZodDefault<z.ZodNumber>;
-        backoffStrategy: z.ZodDefault<z.ZodEnum<["fixed", "linear", "exponential"]>>;
+        backoffStrategy: z.ZodDefault<z.ZodEnum<{
+            fixed: "fixed";
+            linear: "linear";
+            exponential: "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
-     */
+    }, z.core.$strip>>;
     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;
-}>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
 export type QueueConfig = z.infer<typeof QueueConfigSchema>;
 /**
  * Batch Task Schema
@@ -438,1021 +222,258 @@ export type QueueConfig = z.infer<typeof QueueConfigSchema>;
  * }
  */
 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)
-     */
+    items: z.ZodArray<z.ZodAny>;
     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
-     */
+    priority: z.ZodDefault<z.ZodEnum<{
+        background: "background";
+        normal: "normal";
+        critical: "critical";
+        high: "high";
+        low: "low";
+    }>>;
     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;
-}>;
+    }, z.core.$strip>], null>, z.ZodVoid>>;
+}, z.core.$strip>;
 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
-     */
+    status: z.ZodEnum<{
+        pending: "pending";
+        completed: "completed";
+        failed: "failed";
+        running: "running";
+        cancelled: "cancelled";
+    }>;
     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;
-}>;
+}, z.core.$strip>;
 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
-     */
+    queues: z.ZodArray<z.ZodString>;
     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
-         */
+        }, z.core.$strip>>;
         defaultRetryPolicy: z.ZodOptional<z.ZodObject<{
             maxRetries: z.ZodDefault<z.ZodNumber>;
-            backoffStrategy: z.ZodDefault<z.ZodEnum<["fixed", "linear", "exponential"]>>;
+            backoffStrategy: z.ZodDefault<z.ZodEnum<{
+                fixed: "fixed";
+                linear: "linear";
+                exponential: "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
-         */
+        }, z.core.$strip>>;
         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
-     */
+        }, z.core.$strip>>;
+    }, z.core.$strip>>>;
     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;
-}>;
+    handlers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodFunction<z.core.$ZodFunctionArgs, z.core.$ZodFunctionOut>>>;
+}, z.core.$strip>;
 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;
-}>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
 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
-     */
+    priority: z.ZodDefault<z.ZodEnum<{
+        background: "background";
+        normal: "normal";
+        critical: "critical";
+        high: "high";
+        low: "low";
+    }>>;
     retryPolicy: z.ZodOptional<z.ZodObject<{
         maxRetries: z.ZodDefault<z.ZodNumber>;
-        backoffStrategy: z.ZodDefault<z.ZodEnum<["fixed", "linear", "exponential"]>>;
+        backoffStrategy: z.ZodDefault<z.ZodEnum<{
+            fixed: "fixed";
+            linear: "linear";
+            exponential: "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
-     */
+    }, z.core.$strip>>;
     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
-     */
+    status: z.ZodDefault<z.ZodEnum<{
+        timeout: "timeout";
+        pending: "pending";
+        processing: "processing";
+        completed: "completed";
+        failed: "failed";
+        queued: "queued";
+        cancelled: "cancelled";
+        dead: "dead";
+    }>>;
     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;
-}> & {
+        tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>;
+}, z.core.$strip> & {
     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
-     */
+    }, z.core.$strip>>;
     defaultRetryPolicy: z.ZodOptional<z.ZodObject<{
         maxRetries: z.ZodDefault<z.ZodNumber>;
-        backoffStrategy: z.ZodDefault<z.ZodEnum<["fixed", "linear", "exponential"]>>;
+        backoffStrategy: z.ZodDefault<z.ZodEnum<{
+            fixed: "fixed";
+            linear: "linear";
+            exponential: "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
-     */
+    }, z.core.$strip>>;
     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;
-}> & {
+    }, z.core.$strip>>;
+}, z.core.$strip> & {
     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
-     */
+    queues: z.ZodArray<z.ZodString>;
     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
-         */
+        }, z.core.$strip>>;
         defaultRetryPolicy: z.ZodOptional<z.ZodObject<{
             maxRetries: z.ZodDefault<z.ZodNumber>;
-            backoffStrategy: z.ZodDefault<z.ZodEnum<["fixed", "linear", "exponential"]>>;
+            backoffStrategy: z.ZodDefault<z.ZodEnum<{
+                fixed: "fixed";
+                linear: "linear";
+                exponential: "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
-         */
+        }, z.core.$strip>>;
         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
-     */
+        }, z.core.$strip>>;
+    }, z.core.$strip>>>;
     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;
-}> & {
+    handlers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodFunction<z.core.$ZodFunctionArgs, z.core.$ZodFunctionOut>>>;
+}, z.core.$strip> & {
     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)
-     */
+    items: z.ZodArray<z.ZodAny>;
     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
-     */
+    priority: z.ZodDefault<z.ZodEnum<{
+        background: "background";
+        normal: "normal";
+        critical: "critical";
+        high: "high";
+        low: "low";
+    }>>;
     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;
-}> & {
+    }, z.core.$strip>], null>, z.ZodVoid>>;
+}, z.core.$strip> & {
     create: <T extends z.input<typeof BatchTaskSchema>>(batch: T) => T;
 };
 //# sourceMappingURL=worker.zod.d.ts.map