ai-workflows 2.1.3 → 2.3.0

package/dist/worker.d.ts

@@ -0,0 +1,800 @@
+/**
+ * Worker Export - WorkerEntrypoint for RPC access to AI Workflows
+ *
+ * Exposes workflow functionality via Cloudflare RPC.
+ * Works both in Cloudflare Workers and standalone (for testing).
+ *
+ * @example
+ * ```typescript
+ * // wrangler.jsonc
+ * {
+ *   "services": [
+ *     { "binding": "WORKFLOWS", "service": "ai-workflows" }
+ *   ]
+ * }
+ *
+ * // worker.ts - consuming service
+ * export default {
+ *   async fetch(request: Request, env: Env) {
+ *     const service = env.WORKFLOWS.connect()
+ *     const workflow = service.create('my-workflow', {
+ *       context: { userId: '123' }
+ *     })
+ *     await workflow.emit('Customer.created', { name: 'John' })
+ *     return Response.json({ status: 'ok' })
+ *   }
+ * }
+ * ```
+ *
+ * @packageDocumentation
+ */
+import { WorkerEntrypoint, RpcTarget, WorkflowEntrypoint, WorkflowStep } from 'cloudflare:workers';
+import type { WorkflowEvent } from 'cloudflare:workers';
+import type { WorkflowContext, WorkflowState, WorkflowOptions, EventRegistration, ScheduleRegistration, ScheduleInterval, ParsedEvent } from './types.js';
+import { WorkflowStateAdapter, type DatabaseConnection, type PersistedWorkflowState, type StepCheckpoint, type SnapshotInfo } from './worker/state-adapter.js';
+/**
+ * Environment bindings for the worker
+ */
+export interface Env {
+    DB?: DatabaseConnection;
+}
+/**
+ * Workflow instance info returned by the service
+ */
+export interface WorkflowInstanceInfo {
+    id: string;
+    name: string;
+    state: WorkflowState;
+    eventCount: number;
+    scheduleCount: number;
+    started: boolean;
+}
+/**
+ * WorkflowServiceCore - RpcTarget wrapper around workflow functionality
+ *
+ * Exposes all required methods as RPC-callable methods.
+ * This is the core service class that can be instantiated directly.
+ *
+ * ## State Persistence
+ *
+ * The service supports optional state persistence via WorkflowStateAdapter.
+ * When a database connection is provided, workflow state is automatically
+ * persisted across restarts and can be queried.
+ *
+ * @example
+ * ```typescript
+ * // With state persistence
+ * import { DB } from 'ai-database'
+ * import { WorkflowServiceCore } from 'ai-workflows/worker'
+ *
+ * const { db } = DB({ WorkflowState: { status: 'string' } })
+ * const service = new WorkflowServiceCore(db)
+ *
+ * // Create and persist workflow
+ * const workflow = service.create('order-processor')
+ * await service.persistState(workflow.id, { status: 'running' })
+ *
+ * // Query workflows by status
+ * const running = await service.queryByStatus('running')
+ * ```
+ */
+export declare class WorkflowServiceCore extends RpcTarget {
+    private stateAdapter;
+    /**
+     * Create a WorkflowServiceCore instance
+     *
+     * @param database - Optional database connection for state persistence
+     */
+    constructor(database?: DatabaseConnection);
+    /**
+     * Check if state persistence is enabled
+     *
+     * @returns True if a database connection was provided
+     */
+    hasStatePersistence(): boolean;
+    /**
+     * Get the state adapter for direct access
+     *
+     * @returns WorkflowStateAdapter or null if persistence is not enabled
+     */
+    getStateAdapter(): WorkflowStateAdapter | null;
+    /**
+     * Persist workflow state to the database
+     *
+     * Saves the current state of a workflow. If the workflow doesn't exist,
+     * creates a new record. If it exists, updates the existing record.
+     *
+     * @param workflowId - The workflow ID
+     * @param state - Partial state to save (merged with existing)
+     * @throws Error if state persistence is not enabled
+     *
+     * @example
+     * ```typescript
+     * await service.persistState('wf-123', {
+     *   status: 'running',
+     *   currentStep: 'process-payment',
+     *   context: { orderId: 'order-1' }
+     * })
+     * ```
+     */
+    persistState(workflowId: string, state: Partial<PersistedWorkflowState>): Promise<void>;
+    /**
+     * Load persisted workflow state from the database
+     *
+     * @param workflowId - The workflow ID to load
+     * @returns The persisted state or null if not found
+     * @throws Error if state persistence is not enabled
+     *
+     * @example
+     * ```typescript
+     * const state = await service.loadPersistedState('wf-123')
+     * if (state) {
+     *   console.log(`Workflow status: ${state.status}`)
+     *   console.log(`Current step: ${state.currentStep}`)
+     * }
+     * ```
+     */
+    loadPersistedState(workflowId: string): Promise<PersistedWorkflowState | null>;
+    /**
+     * Save a checkpoint for a workflow step
+     *
+     * Checkpoints track the execution state of individual steps within a workflow.
+     * They enable resumption from the last successful step after failures.
+     *
+     * @param workflowId - The workflow ID
+     * @param stepId - The step ID
+     * @param checkpoint - Checkpoint data including status and result
+     * @throws Error if state persistence is not enabled
+     *
+     * @example
+     * ```typescript
+     * await service.saveCheckpoint('wf-123', 'process-payment', {
+     *   stepId: 'process-payment',
+     *   status: 'completed',
+     *   result: { transactionId: 'tx-456' },
+     *   attempt: 1,
+     *   completedAt: new Date()
+     * })
+     * ```
+     */
+    saveCheckpoint(workflowId: string, stepId: string, checkpoint: StepCheckpoint): Promise<void>;
+    /**
+     * Get a checkpoint for a workflow step
+     *
+     * @param workflowId - The workflow ID
+     * @param stepId - The step ID
+     * @returns The checkpoint or null if not found
+     * @throws Error if state persistence is not enabled
+     */
+    getCheckpoint(workflowId: string, stepId: string): Promise<StepCheckpoint | null>;
+    /**
+     * Update state with optimistic locking
+     *
+     * Only updates if the current version matches expectedVersion.
+     * Use this for concurrent updates to prevent lost writes.
+     *
+     * @param workflowId - The workflow ID
+     * @param expectedVersion - Expected current version
+     * @param state - State updates to apply
+     * @returns true if updated, false if version mismatch (concurrent modification)
+     * @throws Error if state persistence is not enabled
+     *
+     * @example
+     * ```typescript
+     * const state = await service.loadPersistedState('wf-123')
+     * const success = await service.updateStateWithVersion(
+     *   'wf-123',
+     *   state.version,
+     *   { status: 'completed' }
+     * )
+     * if (!success) {
+     *   console.log('Concurrent modification detected, retrying...')
+     * }
+     * ```
+     */
+    updateStateWithVersion(workflowId: string, expectedVersion: number, state: Partial<PersistedWorkflowState>): Promise<boolean>;
+    /**
+     * Query workflows by status
+     *
+     * @param status - Status to filter by ('pending', 'running', 'completed', 'failed', 'paused')
+     * @returns Array of workflows matching the status
+     * @throws Error if state persistence is not enabled
+     *
+     * @example
+     * ```typescript
+     * const runningWorkflows = await service.queryByStatus('running')
+     * console.log(`${runningWorkflows.length} workflows currently running`)
+     * ```
+     */
+    queryByStatus(status: PersistedWorkflowState['status']): Promise<PersistedWorkflowState[]>;
+    /**
+     * Query multiple workflows by their IDs
+     *
+     * @param workflowIds - Array of workflow IDs to query
+     * @returns Array of found workflows (non-existent IDs are excluded)
+     * @throws Error if state persistence is not enabled
+     */
+    queryByIds(workflowIds: string[]): Promise<PersistedWorkflowState[]>;
+    /**
+     * Delete persisted workflow state
+     *
+     * @param workflowId - The workflow ID to delete
+     * @returns true if deleted, false if not found
+     * @throws Error if state persistence is not enabled
+     */
+    deletePersistedState(workflowId: string): Promise<boolean>;
+    /**
+     * List all persisted workflows with pagination
+     *
+     * @param options - Pagination options (limit, offset)
+     * @returns Array of workflows
+     * @throws Error if state persistence is not enabled
+     *
+     * @example
+     * ```typescript
+     * // Get first 10 workflows
+     * const workflows = await service.listPersistedWorkflows({ limit: 10, offset: 0 })
+     *
+     * // Get next page
+     * const nextPage = await service.listPersistedWorkflows({ limit: 10, offset: 10 })
+     * ```
+     */
+    listPersistedWorkflows(options?: {
+        limit?: number;
+        offset?: number;
+    }): Promise<PersistedWorkflowState[]>;
+    /**
+     * Create a snapshot of current workflow state
+     *
+     * Snapshots allow point-in-time recovery of workflow state.
+     * Useful before executing risky operations.
+     *
+     * @param workflowId - The workflow ID
+     * @param label - Optional human-readable label
+     * @returns Snapshot ID
+     * @throws Error if state persistence is not enabled or workflow not found
+     *
+     * @example
+     * ```typescript
+     * const snapshotId = await service.createSnapshot('wf-123', 'before-payment')
+     * // ... execute risky operation ...
+     * // If something goes wrong:
+     * await service.restoreSnapshot('wf-123', snapshotId)
+     * ```
+     */
+    createSnapshot(workflowId: string, label?: string): Promise<string>;
+    /**
+     * Restore workflow state from a snapshot
+     *
+     * @param workflowId - The workflow ID
+     * @param snapshotId - The snapshot ID to restore from
+     * @throws Error if state persistence is not enabled or snapshot not found
+     */
+    restoreSnapshot(workflowId: string, snapshotId: string): Promise<void>;
+    /**
+     * Get all snapshots for a workflow
+     *
+     * @param workflowId - The workflow ID
+     * @returns Array of snapshot metadata
+     * @throws Error if state persistence is not enabled
+     */
+    getSnapshots(workflowId: string): Promise<SnapshotInfo[]>;
+    /**
+     * Create a new workflow instance
+     *
+     * @param name - Optional workflow name
+     * @param options - Workflow options (initial context, etc.)
+     * @returns Workflow instance info including ID
+     */
+    create(name?: string, options?: WorkflowOptions): WorkflowInstanceInfo;
+    /**
+     * Create a workflow with a definition function
+     * The definition function receives the $ context for registering handlers
+     *
+     * @param setup - Setup function that receives $ context
+     * @param options - Workflow options
+     * @returns Workflow instance info
+     */
+    createWithSetup(setup: ($: WorkflowContext) => void, options?: WorkflowOptions): WorkflowInstanceInfo;
+    /**
+     * Start a workflow (begin processing schedules)
+     *
+     * @param workflowId - The workflow ID to start
+     */
+    start(workflowId: string): Promise<void>;
+    /**
+     * Stop a workflow
+     *
+     * @param workflowId - The workflow ID to stop
+     */
+    stop(workflowId: string): Promise<void>;
+    /**
+     * Destroy a workflow and clean up resources
+     *
+     * @param workflowId - The workflow ID to destroy
+     */
+    destroy(workflowId: string): Promise<void>;
+    /**
+     * Send an event to a workflow
+     *
+     * @param workflowId - The workflow ID
+     * @param event - Event name in Noun.event format (e.g., 'Customer.created')
+     * @param data - Event data
+     * @returns Event ID
+     */
+    emit<T = unknown>(workflowId: string, event: string, data: T): string;
+    /**
+     * Send an event using the global event bus (for standalone/testing)
+     *
+     * @param event - Event name
+     * @param data - Event data
+     */
+    sendGlobal<T = unknown>(event: string, data: T): Promise<void>;
+    /**
+     * Get workflow state
+     *
+     * @param workflowId - The workflow ID
+     * @returns Current workflow state
+     */
+    getState(workflowId: string): WorkflowState;
+    /**
+     * Set a value in workflow context
+     *
+     * @param workflowId - The workflow ID
+     * @param key - Context key
+     * @param value - Value to set
+     */
+    setState<T = unknown>(workflowId: string, key: string, value: T): void;
+    /**
+     * Get a value from workflow context
+     *
+     * @param workflowId - The workflow ID
+     * @param key - Context key
+     * @returns Value or undefined
+     */
+    getValue<T = unknown>(workflowId: string, key: string): T | undefined;
+    /**
+     * Get workflow info
+     *
+     * @param workflowId - The workflow ID
+     * @returns Workflow instance info
+     */
+    get(workflowId: string): WorkflowInstanceInfo | null;
+    /**
+     * List all workflow IDs
+     *
+     * @returns Array of workflow IDs
+     */
+    list(): string[];
+    /**
+     * Check if a workflow exists
+     *
+     * @param workflowId - The workflow ID
+     * @returns True if workflow exists
+     */
+    has(workflowId: string): boolean;
+    /**
+     * Register a global event handler (for standalone usage)
+     *
+     * @param noun - Noun (e.g., 'Customer')
+     * @param event - Event name (e.g., 'created')
+     * @param handler - Handler function
+     */
+    registerGlobalEvent(noun: string, event: string, handler: (data: unknown, $: WorkflowContext) => void | Promise<void>): void;
+    /**
+     * Get all global event handlers
+     *
+     * @returns Array of event registrations
+     */
+    getGlobalEventHandlers(): EventRegistration[];
+    /**
+     * Clear all global event handlers
+     */
+    clearGlobalEventHandlers(): void;
+    /**
+     * Register a global schedule handler (for standalone usage)
+     *
+     * @param interval - Schedule interval
+     * @param handler - Handler function
+     */
+    registerGlobalSchedule(interval: ScheduleInterval, handler: ($: WorkflowContext) => void | Promise<void>): void;
+    /**
+     * Get all global schedule handlers
+     *
+     * @returns Array of schedule registrations
+     */
+    getGlobalScheduleHandlers(): ScheduleRegistration[];
+    /**
+     * Clear all global schedule handlers
+     */
+    clearGlobalScheduleHandlers(): void;
+    /**
+     * Parse an event string into noun and event
+     *
+     * @param event - Event string (e.g., 'Customer.created')
+     * @returns Parsed event or null if invalid
+     */
+    parseEvent(event: string): ParsedEvent | null;
+    /**
+     * Convert a natural language schedule description to cron expression
+     *
+     * @param description - Natural language description (e.g., 'every hour', 'every Monday')
+     * @returns Cron expression
+     */
+    toCron(description: string): Promise<string>;
+    /**
+     * Convert a schedule interval to milliseconds
+     *
+     * @param interval - Schedule interval
+     * @returns Milliseconds
+     */
+    intervalToMs(interval: ScheduleInterval): number;
+    /**
+     * Format a schedule interval as a human-readable string
+     *
+     * @param interval - Schedule interval
+     * @returns Formatted string
+     */
+    formatInterval(interval: ScheduleInterval): string;
+    /**
+     * Create an isolated test context
+     *
+     * @returns Test context with emittedEvents tracking
+     */
+    createTestContext(): WorkflowContext & {
+        emittedEvents: Array<{
+            event: string;
+            data: unknown;
+        }>;
+    };
+    /**
+     * Clear all workflows (for testing)
+     */
+    clear(): void;
+    /**
+     * Register a built workflow from WorkflowBuilder
+     *
+     * @param workflow - The built workflow from WorkflowBuilder.build()
+     * @returns Registration info with unique ID
+     */
+    registerWorkflow(workflow: {
+        name: string;
+        steps: ReadonlyArray<{
+            name: string;
+            fn: Function;
+        }>;
+        triggers: {
+            events: ReadonlyArray<{
+                event: string;
+                stepName: string;
+                filter?: Function;
+            }>;
+            schedules: ReadonlyArray<{
+                schedule: string;
+                stepName: string;
+                time?: string;
+                timezone?: string;
+            }>;
+        };
+        execute?: (input?: unknown) => Promise<unknown>;
+    }): {
+        id: string;
+    };
+    /**
+     * Parse schedule string to ScheduleInterval
+     */
+    private parseScheduleToInterval;
+}
+/**
+ * WorkflowService - WorkerEntrypoint for RPC access
+ *
+ * Provides `connect()` method that returns an RpcTarget service
+ * with all workflow methods.
+ *
+ * @example
+ * ```typescript
+ * // In consuming worker
+ * const service = env.WORKFLOWS.connect()
+ * const workflow = service.create('my-workflow')
+ * await service.start(workflow.id)
+ * service.emit(workflow.id, 'Customer.created', { name: 'John' })
+ * ```
+ */
+export declare class WorkflowService extends WorkerEntrypoint<Env> {
+    /**
+     * Connect to the workflow service and get an RPC-enabled service
+     *
+     * @returns WorkflowServiceCore instance for RPC calls
+     */
+    connect(): WorkflowServiceCore;
+}
+/**
+ * Test workflow event parameters
+ */
+interface TestWorkflowParams {
+    testId?: string;
+    input?: unknown;
+}
+/**
+ * TestWorkflow - A Cloudflare Workflow class for testing DurableStep
+ *
+ * This workflow handles various test scenarios based on the workflow instance ID.
+ * Each test creates a workflow instance with a specific ID pattern, and this
+ * workflow executes the appropriate test scenario.
+ *
+ * @example
+ * ```typescript
+ * // In wrangler.jsonc
+ * {
+ *   "workflows": [{
+ *     "name": "test-workflow",
+ *     "binding": "WORKFLOW",
+ *     "class_name": "TestWorkflow"
+ *   }]
+ * }
+ * ```
+ */
+export declare class TestWorkflow extends WorkflowEntrypoint<Env, TestWorkflowParams> {
+    /**
+     * Main workflow entry point
+     * Routes to different test scenarios based on the workflow instance ID
+     */
+    run(event: WorkflowEvent<TestWorkflowParams>, step: WorkflowStep): Promise<unknown>;
+    /**
+     * Basic execution test - verifies DurableStep executes and returns value
+     */
+    private execTest;
+    /**
+     * Durability test - verifies step.do() is called with correct name
+     */
+    private durabilityTest;
+    /**
+     * Config test - verifies configuration is passed to step.do()
+     */
+    private configTest;
+    /**
+     * Result test - verifies correct values are returned
+     */
+    private resultTest;
+    /**
+     * Error test - verifies errors are propagated
+     * Explicitly disable retries so error propagates immediately
+     */
+    private errorTest;
+    /**
+     * Typed test - verifies generic types work correctly
+     */
+    private typedTest;
+    /**
+     * Void input test - verifies void input works
+     */
+    private voidInputTest;
+    /**
+     * Context test - verifies StepContext is provided
+     */
+    private ctxTest;
+    /**
+     * Metadata test - verifies step metadata is accessible
+     */
+    private metadataTest;
+    /**
+     * Side effect test - verifies ctx.do() works
+     */
+    private sideEffectTest;
+    /**
+     * Retry config test - verifies ctx.do() with config works
+     */
+    private retryConfigTest;
+    /**
+     * Side effect error test - verifies errors propagate from ctx.do()
+     * Explicitly disable retries so error propagates immediately
+     */
+    private sideEffectErrorTest;
+    /**
+     * Sequential test - verifies multiple ctx.do() calls work
+     */
+    private sequentialTest;
+    /**
+     * Sleep test - verifies step.sleep() works
+     * Note: sleep must be called at workflow level, not inside step.do()
+     * Using '1 second' as miniflare may not support very short durations
+     */
+    private sleepTest;
+    /**
+     * Multi-sleep test - verifies multiple sleep calls with different units
+     * Note: sleep must be called at workflow level, not inside step.do()
+     * Using standard duration formats that Cloudflare Workflows supports
+     */
+    private multiSleepTest;
+    /**
+     * Sleep until test - verifies step.sleepUntil() with Date works
+     * Note: sleep must be called at workflow level, not inside step.do()
+     */
+    private sleepUntilTest;
+    /**
+     * Timestamp sleep test - verifies step.sleepUntil() with timestamp works
+     * Note: sleep must be called at workflow level, not inside step.do()
+     */
+    private timestampSleepTest;
+    /**
+     * Step ID test - verifies step ID is exposed in metadata
+     */
+    private stepIdTest;
+    /**
+     * Attempt test - verifies attempt number is exposed
+     */
+    private attemptTest;
+    /**
+     * Retries limit test - verifies retries limit is exposed
+     */
+    private retriesLimitTest;
+    /**
+     * No retries test - verifies retries is 0 when not configured
+     */
+    private noRetriesTest;
+    /**
+     * Retry behavior test - verifies actual retry behavior
+     *
+     * Note: In Cloudflare Workflows, retries are handled by the runtime.
+     * Each retry is a fresh execution, so we can't track attempts across retries
+     * using in-memory state. Instead, we verify that a step with retries
+     * eventually succeeds after initial failures.
+     *
+     * We use a counter stored in the step context to track attempts.
+     */
+    private retryBehaviorTest;
+    /**
+     * Timeout test - verifies timeout behavior
+     */
+    private timeoutTest;
+    /**
+     * Exponential backoff test - verifies exponential backoff config
+     */
+    private expBackoffTest;
+    /**
+     * Linear backoff test - verifies linear backoff config
+     */
+    private linearBackoffTest;
+    /**
+     * Constant backoff test - verifies constant backoff config
+     */
+    private constantBackoffTest;
+    /**
+     * No retry error test - verifies immediate failure without retries
+     * Explicitly disable retries to ensure error propagates immediately
+     */
+    private noRetryErrorTest;
+    /**
+     * Sequential steps test - verifies multiple DurableSteps run sequentially
+     */
+    private sequentialStepsTest;
+    /**
+     * Factory test - verifies DurableStep factory pattern
+     */
+    private factoryTest;
+    /**
+     * Parallel test - verifies parallel DurableStep execution
+     */
+    private parallelTest;
+    /**
+     * Persist before test - verifies state is persisted before execution
+     */
+    private persistBeforeTest;
+    /**
+     * Persist after test - verifies state is persisted after execution
+     */
+    private persistAfterTest;
+    /**
+     * Resume test - verifies workflow resumes from last successful step
+     */
+    private resumeTest;
+    /**
+     * History test - verifies execution history is tracked
+     */
+    private historyTest;
+    /**
+     * Graceful timeout test - verifies timeout is handled gracefully
+     */
+    private gracefulTimeoutTest;
+    /**
+     * After timeout test - verifies subsequent steps work after timeout handling
+     */
+    private afterTimeoutTest;
+    /**
+     * Per-step timeout test - verifies different timeouts per step
+     */
+    private perStepTimeoutTest;
+    /**
+     * Service integration test - verifies DurableStep works with WorkflowService
+     */
+    private serviceIntegrationTest;
+    /**
+     * Context access test - verifies workflow context is accessible
+     */
+    private contextAccessTest;
+    /**
+     * State sharing test - verifies state can be shared between steps
+     */
+    private stateSharingTest;
+    /**
+     * Empty input test - verifies empty/undefined input is handled
+     */
+    private emptyInputTest;
+    /**
+     * Large input test - verifies large input data is handled
+     */
+    private largeInputTest;
+    /**
+     * Large output test - verifies large output data is handled
+     */
+    private largeOutputTest;
+    /**
+     * Nested do test - verifies nested ctx.do() calls work
+     */
+    private nestedDoTest;
+    /**
+     * Concurrent test - verifies concurrent workflow instances work
+     */
+    private concurrentTest;
+    private cascadeOrderTest;
+    private cascadeShortcircuitTest;
+    private cascadeEscalateTest;
+    private cascadeSkipTest;
+    private aiHumanFallbackTest;
+    private aiErrorContextTest;
+    private aiReasoningTest;
+    private customEscalationTest;
+    private fastSlowModelTest;
+    private modelCascadeTest;
+    private customModelOrderTest;
+    private modelTimeoutTest;
+    private aiGatewayCacheTest;
+    private tierTimeoutConfigTest;
+    private defaultTimeoutTest;
+    private timeoutEscalationTest;
+    private timeoutRecordTest;
+    private totalTimeoutTest;
+    private returnSuccessTest;
+    private throwFailureTest;
+    private customSuccessTest;
+    private partialSuccessTest;
+    private retryBeforeEscalateTest;
+    private resultAccumulateTest;
+    private resultMergeTest;
+    private individualResultsTest;
+    private customMergerTest;
+    private tierMetadataTest;
+    private errorPropagateTest;
+    private errorAccumulateTest;
+    private allTiersFailTest;
+    private errorHistoryTest;
+    private customErrorHandlerTest;
+    private errorTransformTest;
+    private durableCheckpointTest;
+    private cascadeResumeTest;
+    private durableIoTest;
+    private cascadeSnapshotTest;
+    private auditWhoTest;
+    private auditWhatTest;
+    private auditWhenTest;
+    private auditWhereTest;
+    private auditWhyTest;
+    private auditHowTest;
+    private auditPersistTest;
+    private aiGatewayBindingTest;
+    private aiGatewayCachingTest;
+    private aiContextTest;
+    private aiGatewayErrorTest;
+    private cascadeContextTest;
+    private fivewhEventsTest;
+    private metricsTest;
+}
+/**
+ * Default export for Cloudflare Workers
+ */
+declare const _default: {
+    fetch: () => Response;
+};
+export default _default;
+export { WorkflowService as WorkflowWorker };
+//# sourceMappingURL=worker.d.ts.map