flowfn 0.0.1

package/dist/index.d.mts

@@ -0,0 +1,1305 @@
+import EventEmitter from 'eventemitter3';
+import Redis, { RedisOptions } from 'ioredis';
+
+interface Queue<T = any> {
+    name: string;
+    add(name: string, data: T, opts?: JobOptions): Promise<Job<T>>;
+    addBulk(jobs: Array<{
+        name: string;
+        data: T;
+        opts?: JobOptions;
+    }>): Promise<Job<T>[]>;
+    process(handler: JobHandler<T>): void;
+    process(name: string, handler: JobHandler<T>): void;
+    process(concurrency: number, handler: JobHandler<T>): void;
+    process(name: string, concurrency: number, handler: JobHandler<T>): void;
+    processBatch(name: string, batchSize: number, handler: BatchHandler<T>): void;
+    processBatch(name: string, options: BatchOptions$1, handler: BatchHandler<T>): void;
+    pause(): Promise<void>;
+    resume(): Promise<void>;
+    drain(): Promise<void>;
+    clean(grace: number, status: JobStatus): Promise<number>;
+    getDLQ?(): any;
+    getJob(jobId: string): Promise<Job<T> | null>;
+    getJobs(status: JobStatus): Promise<Job<T>[]>;
+    getJobCounts(): Promise<QueueStats>;
+    on(event: QueueEvent, handler: (...args: any[]) => void): void;
+    close(): Promise<void>;
+}
+type QueueEvent = "completed" | "failed" | "stalled" | "progress" | "waiting" | "active";
+interface Job<T = any> {
+    id: string;
+    name: string;
+    data: T;
+    opts: JobOptions;
+    state: JobStatus;
+    progress: number;
+    returnvalue?: any;
+    timestamp: number;
+    processedOn?: number;
+    finishedOn?: number;
+    delay: number;
+    attemptsMade: number;
+    failedReason?: string;
+    stacktrace?: string[];
+    update(data: Partial<T>): Promise<void>;
+    log(message: string): Promise<void>;
+    updateProgress(progress: number): Promise<void>;
+    moveToCompleted(returnValue: any): Promise<void>;
+    moveToFailed(error: Error): Promise<void>;
+    retry(): Promise<void>;
+    discard(): Promise<void>;
+    waitUntilFinished(): Promise<any>;
+}
+type JobStatus = "waiting" | "active" | "completed" | "failed" | "delayed" | "paused";
+interface JobOptions {
+    priority?: number;
+    delay?: number;
+    attempts?: number;
+    backoff?: BackoffOptions;
+    lifo?: boolean;
+    timeout?: number;
+    removeOnComplete?: boolean | number;
+    removeOnFail?: boolean | number;
+    stackTraceLimit?: number;
+    jobId?: string;
+    preventDuplicates?: boolean;
+    deduplicationKey?: string;
+    waitFor?: string[];
+}
+interface BackoffOptions {
+    type: "fixed" | "exponential" | "custom";
+    delay: number;
+    maxDelay?: number;
+}
+interface QueueOptions {
+    defaultJobOptions?: JobOptions;
+    limiter?: RateLimiterOptions;
+    cache?: CacheOptions;
+    dlq?: {
+        enabled: boolean;
+        maxRetries?: number;
+        queueName?: string;
+    };
+}
+interface RateLimiterOptions {
+    max: number;
+    duration: number;
+}
+interface CacheOptions {
+    enabled: boolean;
+    ttl: number;
+    keyGenerator?: (job: Job) => string;
+}
+interface QueueStats {
+    waiting: number;
+    active: number;
+    completed: number;
+    failed: number;
+    delayed: number;
+    paused: number;
+}
+type JobHandler<T> = (job: Job<T>) => Promise<any>;
+type BatchHandler<T> = (jobs: Job<T>[]) => Promise<any[]>;
+interface BatchOptions$1 {
+    batchSize: number;
+    maxWait?: number;
+}
+
+interface StreamOptions {
+    maxLength?: number;
+    retention?: number;
+    partitions?: number;
+}
+interface Stream<T = any> {
+    name: string;
+    publish(data: T, options?: PublishOptions): Promise<string>;
+    publishBatch(messages: Array<{
+        data: T;
+        options?: PublishOptions;
+    }>): Promise<string[]>;
+    subscribe(handler: MessageHandler<T>, options?: SubscribeOptions): Promise<Subscription>;
+    createConsumer(consumerId: string, options: ConsumerOptions): Consumer<T>;
+    getInfo(): Promise<StreamInfo>;
+    trim(strategy: TrimStrategy): Promise<number>;
+    getMessages(start: string, end: string, count?: number): Promise<Message<T>[]>;
+    close(): Promise<void>;
+}
+interface Message<T = any> {
+    id: string;
+    stream: string;
+    data: T;
+    headers?: Record<string, string>;
+    timestamp: number;
+    partition?: number;
+    offset?: number;
+    key?: string;
+    ack(): Promise<void>;
+    nack(requeue?: boolean): Promise<void>;
+}
+interface PublishOptions {
+    key?: string;
+    headers?: Record<string, string>;
+    partition?: number;
+}
+interface SubscribeOptions {
+}
+interface ConsumerOptions {
+    groupId: string;
+    fromBeginning?: boolean;
+    autoCommit?: boolean;
+    commitInterval?: number;
+    maxInFlight?: number;
+}
+interface Consumer<T = any> {
+    subscribe(handler: MessageHandler<T>): Promise<void>;
+    pause(): Promise<void>;
+    resume(): Promise<void>;
+    close(): Promise<void>;
+}
+type MessageHandler<T> = (message: Message<T>) => Promise<void>;
+interface Subscription {
+    unsubscribe(): Promise<void>;
+}
+interface StreamInfo {
+    name: string;
+    length: number;
+    groups: number;
+}
+interface TrimStrategy {
+    maxLength?: number;
+    maxAgeSeconds?: number;
+}
+
+interface WorkflowContext<T = any> {
+    workflowId: string;
+    executionId: string;
+    input: T;
+    state: Record<string, any>;
+    metadata: Record<string, any>;
+    set(key: string, value: any): void;
+    get(key: string): any;
+    sleep(ms: number): Promise<void>;
+    waitForEvent(event: string, timeout?: number): Promise<any>;
+}
+interface Workflow<T = any> {
+    id: string;
+    name: string;
+    execute(input: T): Promise<WorkflowExecution>;
+    getExecution(executionId: string): Promise<WorkflowExecution>;
+    listExecutions(options?: ListOptions$1): Promise<WorkflowExecution[]>;
+    cancelExecution(executionId: string): Promise<void>;
+    retryExecution(executionId: string): Promise<WorkflowExecution>;
+    getExecutionHistory(executionId: string): Promise<WorkflowEvent[]>;
+    getMetrics(): Promise<WorkflowMetrics>;
+}
+interface WorkflowExecution {
+    id: string;
+    workflowId: string;
+    status: ExecutionStatus;
+    input: any;
+    output?: any;
+    error?: any;
+    state?: Record<string, any>;
+    startedAt: number;
+    completedAt?: number;
+    createdAt?: number;
+    updatedAt?: number;
+}
+type ExecutionStatus = "pending" | "running" | "completed" | "failed" | "cancelled";
+interface WorkflowEvent {
+    timestamp: number;
+    type: string;
+    step?: string;
+    data?: any;
+}
+interface WorkflowMetrics {
+    totalExecutions: number;
+    successRate: number;
+    avgDuration: number;
+}
+interface ListOptions$1 {
+    status?: ExecutionStatus;
+    limit?: number;
+    offset?: number;
+}
+type StepHandler<T, R> = (ctx: WorkflowContext<T>, ...args: any[]) => Promise<R>;
+type ErrorHandler<T> = (ctx: WorkflowContext<T>, error: Error) => Promise<void>;
+type CompensateHandler<T> = (ctx: WorkflowContext<T>) => Promise<void>;
+interface BranchOptions<T> {
+    condition: (ctx: WorkflowContext<T>) => boolean | Promise<boolean>;
+    then: WorkflowBuilder<T>;
+    else?: WorkflowBuilder<T>;
+}
+interface SagaDefinition<T> {
+    execute: StepHandler<T, any>;
+    compensate: CompensateHandler<T>;
+}
+interface ApprovalOptions<T> {
+    timeout: number;
+    data?: (ctx: WorkflowContext<T>) => any;
+    onTimeout?: (ctx: WorkflowContext<T>) => Promise<void>;
+}
+interface EventOptions {
+    timeout?: number;
+}
+type Duration$1 = {
+    ms?: number;
+    seconds?: number;
+    minutes?: number;
+    hours?: number;
+    days?: number;
+};
+interface WorkflowBuilder<T = any> {
+    input<I>(): WorkflowBuilder<I>;
+    step<R>(name: string, handler: StepHandler<T, R>): WorkflowBuilder<T>;
+    parallel(steps: StepHandler<T, any>[]): WorkflowBuilder<T>;
+    branch(options: BranchOptions<T>): WorkflowBuilder<T>;
+    saga(name: string, saga: SagaDefinition<T>): WorkflowBuilder<T>;
+    delay(duration: Duration$1): WorkflowBuilder<T>;
+    delayUntil(condition: (ctx: WorkflowContext<T>) => number): WorkflowBuilder<T>;
+    waitForApproval(approver: string, options: ApprovalOptions<T>): WorkflowBuilder<T>;
+    waitForEvent(event: string, options?: EventOptions): WorkflowBuilder<T>;
+    onError(step: string, handler: ErrorHandler<T>): WorkflowBuilder<T>;
+    compensate(step: string, handler: CompensateHandler<T>): WorkflowBuilder<T>;
+    build(): Workflow<T>;
+}
+
+interface FlowAdapter {
+    enqueue(queue: string, job: Job): Promise<string>;
+    dequeue(queue: string): Promise<Job | null>;
+    ack(queue: string, jobId: string): Promise<void>;
+    nack(queue: string, jobId: string, requeue?: boolean): Promise<void>;
+    publish(stream: string, message: Message): Promise<string>;
+    subscribe(stream: string, handler: MessageHandler<any>): Promise<Subscription>;
+    consume(stream: string, group: string, consumer: string, handler: MessageHandler<any>): Promise<Subscription>;
+    createConsumerGroup(stream: string, group: string): Promise<void>;
+    saveWorkflowState(workflowId: string, state: WorkflowExecution): Promise<void>;
+    loadWorkflowState(workflowId: string): Promise<WorkflowExecution | null>;
+    getJob(queue: string, jobId: string): Promise<Job | null>;
+    getJobs(queue: string, status: string): Promise<Job[]>;
+    getAllJobs(queue: string): Promise<Job[]>;
+    cleanJobs(queue: string, grace: number, status: string): Promise<number>;
+    getQueueStats(queue: string): Promise<QueueStats>;
+    getStreamInfo(stream: string): Promise<StreamInfo>;
+    cleanup(): Promise<void>;
+}
+
+interface ScheduleOptions {
+    pattern?: string;
+    timezone?: string;
+    data?: any;
+    startDate?: Date;
+    endDate?: Date;
+    limit?: number;
+    every?: number;
+}
+declare class Scheduler {
+    private tasks;
+    schedule(name: string, pattern: string | ScheduleOptions, handler: Function): Promise<void>;
+    repeat(name: string, options: any, handler: Function): Promise<void>;
+    private plan;
+    list(): Promise<any[]>;
+    cancel(name: string): Promise<void>;
+    pause(name: string): Promise<void>;
+    resume(name: string): Promise<void>;
+    close(): Promise<void>;
+}
+
+interface MetricDataPoint {
+    timestamp: number;
+    value: number;
+    tags?: Record<string, string>;
+}
+interface TimeSeriesMetrics {
+    dataPoints: MetricDataPoint[];
+    min: number;
+    max: number;
+    avg: number;
+    sum: number;
+    count: number;
+    p50?: number;
+    p95?: number;
+    p99?: number;
+}
+declare class MetricsManager {
+    private adapter;
+    private metrics;
+    private maxDataPoints;
+    constructor(adapter: FlowAdapter);
+    /**
+     * Record a metric data point
+     */
+    record(name: string, value: number, tags?: Record<string, string>): void;
+    /**
+     * Get time series for a metric
+     */
+    getTimeSeries(name: string, options?: {
+        tags?: Record<string, string>;
+        since?: number;
+        limit?: number;
+    }): TimeSeriesMetrics | null;
+    private calculateAggregations;
+    private percentile;
+    private getMetricKey;
+    getQueueMetrics(name: string): Promise<any>;
+    getStreamMetrics(name: string): Promise<any>;
+    getWorkflowMetrics(name: string): Promise<any>;
+    getSystemMetrics(): Promise<any>;
+    /**
+     * Clear old metrics
+     */
+    cleanup(maxAge: number): void;
+}
+
+/**
+ * Monitoring and health check system for FlowFn
+ */
+interface HealthStatus {
+    healthy: boolean;
+    timestamp: number;
+    checks: HealthCheck[];
+    details?: Record<string, any>;
+}
+interface HealthCheck {
+    name: string;
+    status: "pass" | "fail" | "warn";
+    message?: string;
+    responseTime?: number;
+    details?: Record<string, any>;
+}
+interface MonitoringMetrics {
+    queues?: {
+        [queueName: string]: {
+            waiting: number;
+            active: number;
+            completed: number;
+            failed: number;
+            delayed: number;
+            throughput: number;
+            avgDuration: number;
+            errorRate: number;
+        };
+    };
+    streams?: {
+        [streamName: string]: {
+            messageCount: number;
+            publishRate: number;
+            consumerCount: number;
+            lag: number;
+        };
+    };
+    workflows?: {
+        [workflowName: string]: {
+            totalExecutions: number;
+            running: number;
+            completed: number;
+            failed: number;
+            successRate: number;
+            avgDuration: number;
+        };
+    };
+    system?: {
+        uptime: number;
+        memoryUsage: number;
+        cpuUsage?: number;
+    };
+}
+interface HealthChecker {
+    /**
+     * Perform health check
+     */
+    check(): Promise<HealthStatus>;
+    /**
+     * Add custom health check
+     */
+    addCheck(name: string, checker: () => Promise<HealthCheck>): void;
+    /**
+     * Remove health check
+     */
+    removeCheck(name: string): void;
+}
+/**
+ * Health checker implementation
+ */
+declare class HealthCheckerImpl implements HealthChecker {
+    private checks;
+    private startTime;
+    constructor();
+    addCheck(name: string, checker: () => Promise<HealthCheck>): void;
+    removeCheck(name: string): void;
+    check(): Promise<HealthStatus>;
+}
+/**
+ * Event tracking for monitoring
+ */
+interface TrackedEvent {
+    id: string;
+    type: string;
+    category: "queue" | "stream" | "workflow" | "system";
+    severity: "info" | "warn" | "error";
+    message: string;
+    timestamp: number;
+    metadata?: Record<string, any>;
+}
+interface EventTracker {
+    /**
+     * Track an event
+     */
+    track(event: Omit<TrackedEvent, "id" | "timestamp">): void;
+    /**
+     * Get events
+     */
+    getEvents(filter?: {
+        category?: string;
+        severity?: string;
+        since?: number;
+        limit?: number;
+    }): TrackedEvent[];
+    /**
+     * Clear old events
+     */
+    cleanup(maxAge: number): number;
+}
+declare class MemoryEventTracker implements EventTracker {
+    private events;
+    private maxEvents;
+    track(event: Omit<TrackedEvent, "id" | "timestamp">): void;
+    getEvents(filter?: {
+        category?: string;
+        severity?: string;
+        since?: number;
+        limit?: number;
+    }): TrackedEvent[];
+    cleanup(maxAge: number): number;
+    clear(): void;
+}
+
+interface FlowFnConfig {
+    adapter: FlowAdapter | "memory" | "redis" | "postgres" | "d1" | "sqs" | "kafka";
+    namespace?: string;
+    defaultJobOptions?: any;
+    defaultQueueOptions?: QueueOptions;
+    defaultStreamOptions?: StreamOptions;
+    telemetry?: {
+        enabled: boolean;
+        provider?: "opentelemetry" | "custom";
+    };
+    onError?: (error: Error, context: any) => void;
+}
+interface FlowFn {
+    queue<T = any>(name: string, options?: QueueOptions): Queue<T>;
+    listQueues(): Promise<string[]>;
+    stream<T = any>(name: string, options?: StreamOptions): Stream<T>;
+    listStreams(): Promise<string[]>;
+    workflow<T = any>(name: string): WorkflowBuilder<T>;
+    listWorkflows(): Promise<Workflow[]>;
+    scheduler(): Scheduler;
+    metrics: MetricsManager;
+    healthCheck(): Promise<HealthStatus>;
+    getEventTracker(): EventTracker;
+    on(event: string, handler: (...args: any[]) => void): void;
+    off(event: string, handler: (...args: any[]) => void): void;
+    close(): Promise<void>;
+}
+declare class FlowFnImpl extends EventEmitter implements FlowFn {
+    private adapter;
+    private queues;
+    private streams;
+    private _metrics;
+    private _scheduler;
+    private healthChecker;
+    private eventTracker;
+    private startTime;
+    constructor(config: FlowFnConfig);
+    private setupHealthChecks;
+    queue<T = any>(name: string, options?: QueueOptions): Queue<T>;
+    listQueues(): Promise<string[]>;
+    stream<T = any>(name: string, options?: StreamOptions): Stream<T>;
+    listStreams(): Promise<string[]>;
+    workflow<T = any>(name: string): WorkflowBuilder<T>;
+    listWorkflows(): Promise<Workflow[]>;
+    scheduler(): Scheduler;
+    get metrics(): MetricsManager;
+    healthCheck(): Promise<HealthStatus>;
+    /**
+     * Get event tracker
+     */
+    getEventTracker(): EventTracker;
+    close(): Promise<void>;
+}
+declare function createFlow(config: FlowFnConfig): FlowFn;
+
+interface WorkerOptions {
+    flow: FlowFn;
+    queues: string[];
+    concurrency?: number | Record<string, number>;
+    settings?: {
+        stalledInterval?: number;
+        maxStalledCount?: number;
+    };
+}
+declare class Worker extends EventEmitter {
+    private flow;
+    private queueNames;
+    private concurrency;
+    private queues;
+    constructor(options: WorkerOptions);
+    run(): Promise<void>;
+    register(queueName: string, handler: (job: Job) => Promise<any>): void;
+    close(): Promise<void>;
+}
+declare function createWorker(options: WorkerOptions): Worker;
+
+/**
+ * Dead-Letter Queue (DLQ) implementation for FlowFn
+ */
+
+interface DLQOptions {
+    /**
+     * Queue name for dead-letter jobs
+     */
+    queueName?: string;
+    /**
+     * Maximum retries before moving to DLQ
+     */
+    maxRetries?: number;
+    /**
+     * Time to live for DLQ items (ms)
+     */
+    ttl?: number;
+    /**
+     * Handler called when job moves to DLQ
+     */
+    onDLQ?: (job: Job, reason: string) => void | Promise<void>;
+}
+interface DLQJob<T = any> extends Job<T> {
+    /**
+     * Original queue name
+     */
+    originalQueue: string;
+    /**
+     * Reason for DLQ
+     */
+    dlqReason: string;
+    /**
+     * Timestamp when moved to DLQ
+     */
+    dlqTimestamp: number;
+    /**
+     * All error messages from attempts
+     */
+    errors: string[];
+}
+interface DLQManager {
+    /**
+     * Move job to DLQ
+     */
+    moveToDLQ<T>(job: Job<T>, reason: string): Promise<DLQJob<T>>;
+    /**
+     * Get all DLQ jobs
+     */
+    getAll(): Promise<DLQJob[]>;
+    /**
+     * Get DLQ jobs by original queue
+     */
+    getByQueue(queueName: string): Promise<DLQJob[]>;
+    /**
+     * Retry a DLQ job
+     */
+    retry<T>(jobId: string): Promise<Job<T>>;
+    /**
+     * Retry all DLQ jobs from a queue
+     */
+    retryAll(queueName: string): Promise<number>;
+    /**
+     * Delete a DLQ job
+     */
+    delete(jobId: string): Promise<void>;
+    /**
+     * Clean expired DLQ jobs
+     */
+    clean(maxAge: number): Promise<number>;
+    /**
+     * Get DLQ stats
+     */
+    getStats(): Promise<{
+        total: number;
+        byQueue: Record<string, number>;
+    }>;
+}
+/**
+ * In-memory DLQ implementation
+ */
+declare class MemoryDLQManager implements DLQManager {
+    private dlqJobs;
+    private options;
+    constructor(options?: DLQOptions);
+    moveToDLQ<T>(job: Job<T>, reason: string): Promise<DLQJob<T>>;
+    getAll(): Promise<DLQJob[]>;
+    getByQueue(queueName: string): Promise<DLQJob[]>;
+    retry<T>(jobId: string): Promise<Job<T>>;
+    retryAll(queueName: string): Promise<number>;
+    delete(jobId: string): Promise<void>;
+    clean(maxAge: number): Promise<number>;
+    getStats(): Promise<{
+        total: number;
+        byQueue: Record<string, number>;
+    }>;
+    /**
+     * Clear all DLQ jobs (for testing)
+     */
+    clear(): void;
+}
+
+declare class MemoryAdapter implements FlowAdapter {
+    private queues;
+    private allJobs;
+    private streams;
+    private streamEmitters;
+    private workflowStates;
+    enqueue(queueName: string, job: Job): Promise<string>;
+    dequeue(queueName: string): Promise<Job | null>;
+    ack(queue: string, jobId: string): Promise<void>;
+    nack(queueName: string, jobId: string, requeue?: boolean): Promise<void>;
+    getJob(queueName: string, jobId: string): Promise<Job | null>;
+    getJobs(queue: string, status: string): Promise<Job[]>;
+    getAllJobs(queue: string): Promise<Job[]>;
+    cleanJobs(queue: string, grace: number, status: string): Promise<number>;
+    publish(streamName: string, message: Message): Promise<string>;
+    subscribe(streamName: string, handler: MessageHandler<any>): Promise<Subscription>;
+    consume(stream: string, group: string, consumer: string, handler: MessageHandler<any>): Promise<Subscription>;
+    createConsumerGroup(stream: string, group: string): Promise<void>;
+    saveWorkflowState(workflowId: string, state: WorkflowExecution): Promise<void>;
+    loadWorkflowState(workflowId: string): Promise<WorkflowExecution | null>;
+    getQueueStats(queueName: string): Promise<QueueStats>;
+    getStreamInfo(streamName: string): Promise<StreamInfo>;
+    cleanup(): Promise<void>;
+}
+
+interface RedisAdapterOptions {
+    connection?: Redis | RedisOptions;
+    prefix?: string;
+}
+declare class RedisAdapter implements FlowAdapter {
+    private redis;
+    private prefix;
+    private subscriptions;
+    constructor(options?: RedisAdapterOptions);
+    private key;
+    enqueue(queueName: string, job: Job): Promise<string>;
+    dequeue(queueName: string): Promise<Job | null>;
+    ack(queue: string, jobId: string): Promise<void>;
+    nack(queueName: string, jobId: string, requeue?: boolean): Promise<void>;
+    publish(streamName: string, message: Message): Promise<string>;
+    subscribe(streamName: string, handler: MessageHandler<any>): Promise<Subscription>;
+    consume(streamName: string, group: string, consumer: string, handler: MessageHandler<any>): Promise<Subscription>;
+    createConsumerGroup(stream: string, group: string): Promise<void>;
+    saveWorkflowState(workflowId: string, state: WorkflowExecution): Promise<void>;
+    loadWorkflowState(workflowId: string): Promise<WorkflowExecution | null>;
+    getJob(queue: string, jobId: string): Promise<Job | null>;
+    getJobs(queue: string, status: string): Promise<Job[]>;
+    getAllJobs(queue: string): Promise<Job[]>;
+    cleanJobs(queue: string, grace: number, status: string): Promise<number>;
+    getQueueStats(queueName: string): Promise<QueueStats>;
+    getStreamInfo(streamName: string): Promise<StreamInfo>;
+    cleanup(): Promise<void>;
+}
+
+interface PostgresAdapterOptions {
+    db: any;
+    schema?: string;
+    pollInterval?: number;
+}
+declare class PostgresAdapter implements FlowAdapter {
+    private db;
+    private pollInterval;
+    private activeSubscriptions;
+    constructor(options: PostgresAdapterOptions);
+    enqueue(queueName: string, job: Job): Promise<string>;
+    dequeue(queueName: string): Promise<Job | null>;
+    ack(queue: string, jobId: string): Promise<void>;
+    nack(queue: string, jobId: string, requeue?: boolean): Promise<void>;
+    publish(streamName: string, message: Message): Promise<string>;
+    subscribe(streamName: string, handler: MessageHandler<any>): Promise<Subscription>;
+    createConsumerGroup(stream: string, group: string): Promise<void>;
+    saveWorkflowState(workflowId: string, state: WorkflowExecution): Promise<void>;
+    loadWorkflowState(executionId: string): Promise<WorkflowExecution | null>;
+    getJob(queue: string, jobId: string): Promise<Job | null>;
+    getQueueStats(queueName: string): Promise<QueueStats>;
+    getStreamInfo(streamName: string): Promise<StreamInfo>;
+    consume(stream: string, group: string, consumer: string, handler: MessageHandler<any>): Promise<Subscription>;
+    getJobs(queue: string, status: string): Promise<Job[]>;
+    getAllJobs(queue: string): Promise<Job[]>;
+    cleanJobs(queue: string, grace: number, status: string): Promise<number>;
+    cleanup(): Promise<void>;
+}
+
+declare function calculateBackoff(attemptsMade: number, options: BackoffOptions): number;
+
+interface CircuitBreakerOptions {
+    threshold: number;
+    timeout: number;
+    resetTimeout?: number;
+}
+type CircuitState = 'CLOSED' | 'OPEN' | 'HALF_OPEN';
+declare function circuitBreaker<T>(options: CircuitBreakerOptions, handler: (job: Job<T>) => Promise<any>): (job: Job<T>) => Promise<any>;
+
+/**
+ * Rate limiting pattern for FlowFn
+ */
+interface RateLimitOptions {
+    /**
+     * Maximum number of requests allowed
+     */
+    limit: number;
+    /**
+     * Time window in milliseconds
+     */
+    window: number;
+    /**
+     * Strategy for handling rate limit exceeded
+     */
+    strategy?: "throw" | "delay" | "drop";
+    /**
+     * Custom key generator for partitioning rate limits
+     */
+    keyGenerator?: (...args: any[]) => string;
+}
+interface RateLimitResult {
+    allowed: boolean;
+    remaining: number;
+    resetAt: number;
+    retryAfter?: number;
+}
+declare class RateLimiter {
+    private counters;
+    private options;
+    constructor(options: RateLimitOptions);
+    /**
+     * Check if request is allowed
+     */
+    check(key?: string): Promise<RateLimitResult>;
+    /**
+     * Execute a function with rate limiting
+     */
+    execute<T>(fn: () => Promise<T>, key?: string): Promise<T>;
+    /**
+     * Clear all rate limit counters
+     */
+    reset(): void;
+    /**
+     * Clear rate limit counter for specific key
+     */
+    resetKey(key: string): void;
+    /**
+     * Get current limit info for a key
+     */
+    getInfo(key?: string): RateLimitResult;
+}
+/**
+ * Create a rate limiter
+ */
+declare function createRateLimiter(options: RateLimitOptions): RateLimiter;
+/**
+ * Sliding window rate limiter (more accurate)
+ */
+declare class SlidingWindowRateLimiter {
+    private requests;
+    private options;
+    constructor(options: RateLimitOptions);
+    check(key?: string): Promise<RateLimitResult>;
+    execute<T>(fn: () => Promise<T>, key?: string): Promise<T>;
+    reset(): void;
+}
+/**
+ * Token bucket rate limiter
+ */
+declare class TokenBucketRateLimiter {
+    private buckets;
+    private capacity;
+    private refillRate;
+    private refillInterval;
+    constructor(options: {
+        capacity: number;
+        refillRate: number;
+        refillInterval?: number;
+    });
+    private refill;
+    check(key?: string, cost?: number): Promise<RateLimitResult>;
+    reset(): void;
+}
+
+/**
+ * Batching utilities for FlowFn
+ */
+interface BatchOptions {
+    /**
+     * Maximum number of items per batch
+     */
+    maxSize: number;
+    /**
+     * Maximum time to wait before flushing batch (ms)
+     */
+    maxWait?: number;
+    /**
+     * Minimum size before processing (default: 1)
+     */
+    minSize?: number;
+}
+interface BatchProcessor<T, R> {
+    /**
+     * Process a batch of items
+     */
+    (items: T[]): Promise<R[]>;
+}
+/**
+ * Batch accumulator for collecting and processing items in batches
+ */
+declare class BatchAccumulator<T, R = any> {
+    private batch;
+    private timer;
+    private options;
+    private processor;
+    private pending;
+    constructor(processor: BatchProcessor<T, R>, options: BatchOptions);
+    /**
+     * Add an item to the batch
+     */
+    add(item: T): Promise<R>;
+    /**
+     * Manually flush the current batch
+     */
+    flush(): Promise<void>;
+    /**
+     * Get current batch size
+     */
+    size(): number;
+    /**
+     * Clear the batch without processing
+     */
+    clear(): void;
+}
+/**
+ * Create a batched version of a function
+ */
+declare function batch<T, R>(fn: (items: T[]) => Promise<R[]>, options: BatchOptions): (item: T) => Promise<R>;
+/**
+ * Batch array into chunks
+ */
+declare function chunk<T>(array: T[], size: number): T[][];
+/**
+ * Process array in batches with delay between batches
+ */
+declare function processBatches<T, R>(items: T[], processor: (batch: T[]) => Promise<R[]>, options: {
+    batchSize: number;
+    delayMs?: number;
+}): Promise<R[]>;
+/**
+ * Batch write operations with auto-flush
+ */
+declare class BatchWriter<T> {
+    private accumulator;
+    constructor(writer: (items: T[]) => Promise<void>, options: BatchOptions);
+    write(item: T): Promise<void>;
+    flush(): Promise<void>;
+    size(): number;
+    clear(): void;
+}
+/**
+ * Group items by a key function and process in batches
+ */
+declare function batchByKey<T, R>(items: T[], keyFn: (item: T) => string, processor: (key: string, items: T[]) => Promise<R[]>, options?: {
+    concurrency?: number;
+}): Promise<R[]>;
+
+/**
+ * Priority queue pattern for FlowFn
+ */
+interface PriorityItem<T> {
+    value: T;
+    priority: number;
+}
+/**
+ * Priority queue implementation using binary heap
+ */
+declare class PriorityQueue<T> {
+    private heap;
+    private compareFn;
+    constructor(mode?: "min" | "max");
+    /**
+     * Add item with priority
+     */
+    enqueue(value: T, priority: number): void;
+    /**
+     * Remove and return highest priority item
+     */
+    dequeue(): T | undefined;
+    /**
+     * Peek at highest priority item without removing
+     */
+    peek(): T | undefined;
+    /**
+     * Get queue size
+     */
+    size(): number;
+    /**
+     * Check if queue is empty
+     */
+    isEmpty(): boolean;
+    /**
+     * Clear the queue
+     */
+    clear(): void;
+    /**
+     * Convert to array (sorted by priority)
+     */
+    toArray(): T[];
+    private bubbleUp;
+    private bubbleDown;
+}
+
+/**
+ * Generate a hash for job deduplication
+ */
+declare function hashJob(data: any, options?: {
+    algorithm?: string;
+}): string;
+/**
+ * Generate a deduplication key from job name and data
+ */
+declare function generateDeduplicationKey(name: string, data: any): string;
+/**
+ * Check if two job payloads are equivalent
+ */
+declare function areJobsEquivalent(job1: any, job2: any): boolean;
+
+/**
+ * ID generation strategies
+ */
+type IdStrategy = "uuid-v4" | "uuid-v5" | "uuid-v1" | "nanoid" | "incremental" | "custom";
+interface IdGeneratorOptions {
+    strategy?: IdStrategy;
+    namespace?: string;
+    prefix?: string;
+    customGenerator?: () => string;
+}
+/**
+ * Generate a unique identifier based on the specified strategy
+ */
+declare function generateId(options?: IdGeneratorOptions): string;
+/**
+ * Generate a job ID with optional prefix
+ */
+declare function generateJobId(prefix?: string): string;
+/**
+ * Generate a workflow execution ID
+ */
+declare function generateExecutionId(prefix?: string): string;
+/**
+ * Generate a message ID for streams
+ */
+declare function generateMessageId(prefix?: string): string;
+/**
+ * Generate a deterministic ID based on content (useful for idempotency)
+ */
+declare function generateDeterministicId(content: string | object, prefix?: string): string;
+
+/**
+ * Time utility functions for FlowFn
+ */
+/**
+ * Duration units
+ */
+interface Duration {
+    milliseconds?: number;
+    seconds?: number;
+    minutes?: number;
+    hours?: number;
+    days?: number;
+    weeks?: number;
+}
+/**
+ * Convert duration object to milliseconds
+ */
+declare function toMilliseconds(duration: Duration): number;
+/**
+ * Convert milliseconds to duration object
+ */
+declare function fromMilliseconds(ms: number): Duration;
+/**
+ * Format duration as human-readable string
+ */
+declare function formatDuration(duration: Duration): string;
+/**
+ * Sleep for specified milliseconds
+ */
+declare function sleep(ms: number): Promise<void>;
+/**
+ * Sleep for specified duration
+ */
+declare function sleepDuration(duration: Duration): Promise<void>;
+/**
+ * Create a timeout promise
+ */
+declare function timeout<T>(promise: Promise<T>, ms: number, message?: string): Promise<T>;
+/**
+ * Get current timestamp in milliseconds
+ */
+declare function now(): number;
+/**
+ * Calculate delay until a specific timestamp
+ */
+declare function delayUntil(timestamp: number): number;
+/**
+ * Check if a timestamp is in the past
+ */
+declare function isPast(timestamp: number): boolean;
+/**
+ * Check if a timestamp is in the future
+ */
+declare function isFuture(timestamp: number): boolean;
+/**
+ * Add duration to timestamp
+ */
+declare function addDuration(timestamp: number, duration: Duration): number;
+/**
+ * Parse cron-like duration string (e.g., "5m", "1h", "30s")
+ */
+declare function parseDuration(str: string): number;
+
+/**
+ * Serialization utilities for FlowFn
+ */
+interface SerializationOptions {
+    pretty?: boolean;
+    includeUndefined?: boolean;
+    dateFormat?: "iso" | "timestamp";
+}
+/**
+ * Serialize job data to JSON string
+ */
+declare function serialize<T = any>(data: T, options?: SerializationOptions): string;
+/**
+ * Deserialize JSON string to object
+ */
+declare function deserialize<T = any>(json: string): T;
+/**
+ * Safely serialize data with circular reference handling
+ */
+declare function serializeSafe<T = any>(data: T, options?: SerializationOptions): string;
+/**
+ * Clone an object using serialization
+ */
+declare function cloneViaSerialization<T>(obj: T): T;
+/**
+ * Serialize with compression (base64 encode)
+ */
+declare function serializeCompressed<T = any>(data: T): string;
+/**
+ * Deserialize compressed data
+ */
+declare function deserializeCompressed<T = any>(compressed: string): T;
+/**
+ * Check if a value is serializable
+ */
+declare function isSerializable(value: any): boolean;
+/**
+ * Get size of serialized data in bytes
+ */
+declare function getSerializedSize(data: any): number;
+
+/**
+ * Storage abstraction for FlowFn job persistence
+ */
+
+interface JobStorage {
+    /**
+     * Save a job
+     */
+    save(queue: string, job: Job): Promise<void>;
+    /**
+     * Get a job by ID
+     */
+    get(queue: string, jobId: string): Promise<Job | null>;
+    /**
+     * Get jobs by status
+     */
+    getByStatus(queue: string, status: JobStatus): Promise<Job[]>;
+    /**
+     * Get all jobs for a queue
+     */
+    getAll(queue: string): Promise<Job[]>;
+    /**
+     * Update job status
+     */
+    updateStatus(queue: string, jobId: string, status: JobStatus): Promise<void>;
+    /**
+     * Update job data
+     */
+    update(queue: string, jobId: string, updates: Partial<Job>): Promise<void>;
+    /**
+     * Delete a job
+     */
+    delete(queue: string, jobId: string): Promise<void>;
+    /**
+     * Delete jobs older than grace period with given status
+     */
+    clean(queue: string, grace: number, status: JobStatus): Promise<number>;
+    /**
+     * Get job count by status
+     */
+    count(queue: string, status?: JobStatus): Promise<number>;
+    /**
+     * Check if job exists with deduplication key
+     */
+    existsByDeduplicationKey(queue: string, key: string): Promise<boolean>;
+}
+/**
+ * In-memory implementation of JobStorage
+ */
+declare class MemoryJobStorage implements JobStorage {
+    private jobs;
+    private deduplicationKeys;
+    save(queue: string, job: Job): Promise<void>;
+    get(queue: string, jobId: string): Promise<Job | null>;
+    getByStatus(queue: string, status: JobStatus): Promise<Job[]>;
+    getAll(queue: string): Promise<Job[]>;
+    updateStatus(queue: string, jobId: string, status: JobStatus): Promise<void>;
+    update(queue: string, jobId: string, updates: Partial<Job>): Promise<void>;
+    delete(queue: string, jobId: string): Promise<void>;
+    clean(queue: string, grace: number, status: JobStatus): Promise<number>;
+    count(queue: string, status?: JobStatus): Promise<number>;
+    existsByDeduplicationKey(queue: string, key: string): Promise<boolean>;
+    /**
+     * Clear all jobs
+     */
+    clear(): void;
+}
+
+/**
+ * Workflow state storage abstraction
+ */
+
+interface WorkflowStorage {
+    /**
+     * Save workflow execution state
+     */
+    save(workflowId: string, execution: WorkflowExecution): Promise<void>;
+    /**
+     * Get workflow execution by ID
+     */
+    get(executionId: string): Promise<WorkflowExecution | null>;
+    /**
+     * List executions for a workflow
+     */
+    list(workflowId: string, options?: ListOptions): Promise<WorkflowExecution[]>;
+    /**
+     * Update execution status
+     */
+    updateStatus(executionId: string, status: string): Promise<void>;
+    /**
+     * Update execution state
+     */
+    updateState(executionId: string, state: Record<string, any>): Promise<void>;
+    /**
+     * Delete an execution
+     */
+    delete(executionId: string): Promise<void>;
+    /**
+     * Clean old executions
+     */
+    clean(workflowId: string, grace: number): Promise<number>;
+}
+interface ListOptions {
+    status?: string;
+    limit?: number;
+    offset?: number;
+    sortBy?: "createdAt" | "updatedAt";
+    sortOrder?: "asc" | "desc";
+}
+/**
+ * In-memory workflow storage implementation
+ */
+declare class MemoryWorkflowStorage implements WorkflowStorage {
+    private executions;
+    private workflowIndex;
+    save(workflowId: string, execution: WorkflowExecution): Promise<void>;
+    get(executionId: string): Promise<WorkflowExecution | null>;
+    list(workflowId: string, options?: ListOptions): Promise<WorkflowExecution[]>;
+    updateStatus(executionId: string, status: ExecutionStatus): Promise<void>;
+    updateState(executionId: string, state: Record<string, any>): Promise<void>;
+    delete(executionId: string): Promise<void>;
+    clean(workflowId: string, grace: number): Promise<number>;
+    /**
+     * Clear all executions
+     */
+    clear(): void;
+}
+
+/**
+ * Event log for event sourcing pattern
+ */
+interface Event {
+    id: string;
+    type: string;
+    aggregateId: string;
+    aggregateType: string;
+    data: any;
+    metadata?: Record<string, any>;
+    timestamp: number;
+    version: number;
+}
+interface EventFilter {
+    aggregateId?: string;
+    aggregateType?: string;
+    types?: string[];
+    fromVersion?: number;
+    toVersion?: number;
+    fromTimestamp?: number;
+    toTimestamp?: number;
+    limit?: number;
+    offset?: number;
+}
+interface EventLog {
+    /**
+     * Append event to the log
+     */
+    append(event: Omit<Event, "id" | "timestamp" | "version">): Promise<Event>;
+    /**
+     * Get events by filter
+     */
+    getEvents(filter: EventFilter): Promise<Event[]>;
+    /**
+     * Get events for an aggregate
+     */
+    getAggregateEvents(aggregateId: string, fromVersion?: number): Promise<Event[]>;
+    /**
+     * Get latest version for an aggregate
+     */
+    getLatestVersion(aggregateId: string): Promise<number>;
+    /**
+     * Subscribe to event stream
+     */
+    subscribe(handler: (event: Event) => void | Promise<void>, filter?: EventFilter): () => void;
+}
+/**
+ * In-memory event log implementation
+ */
+declare class MemoryEventLog implements EventLog {
+    private events;
+    private aggregateVersions;
+    private subscribers;
+    append(event: Omit<Event, "id" | "timestamp" | "version">): Promise<Event>;
+    getEvents(filter: EventFilter): Promise<Event[]>;
+    getAggregateEvents(aggregateId: string, fromVersion?: number): Promise<Event[]>;
+    getLatestVersion(aggregateId: string): Promise<number>;
+    subscribe(handler: (event: Event) => void | Promise<void>, filter?: EventFilter): () => void;
+    private matchesFilter;
+    /**
+     * Clear all events
+     */
+    clear(): void;
+}
+
+export { type ApprovalOptions, type BackoffOptions, BatchAccumulator, type BatchHandler, type BatchOptions$1 as BatchOptions, BatchWriter, type BatchOptions as BatchingOptions, type BranchOptions, type CacheOptions, type CircuitBreakerOptions, type CircuitState, type CompensateHandler, type Consumer, type ConsumerOptions, type DLQJob, type DLQManager, type DLQOptions, type Duration$1 as Duration, type ErrorHandler, type Event, type EventFilter, type EventLog, type EventOptions, type EventTracker, type ExecutionStatus, type FlowAdapter, type FlowFn, type FlowFnConfig, FlowFnImpl, type HealthCheck, type HealthChecker, HealthCheckerImpl, type HealthStatus, type IdGeneratorOptions, type IdStrategy, type Job, type JobHandler, type JobOptions, type JobStatus, type JobStorage, type ListOptions$1 as ListOptions, MemoryAdapter, MemoryDLQManager, MemoryEventLog, MemoryEventTracker, MemoryJobStorage, MemoryWorkflowStorage, type Message, type MessageHandler, type MetricDataPoint, MetricsManager, type MonitoringMetrics, PostgresAdapter, type PostgresAdapterOptions, type PriorityItem, PriorityQueue, type PublishOptions, type Queue, type QueueEvent, type QueueOptions, type QueueStats, type RateLimitOptions, type RateLimitResult, RateLimiter, type RateLimiterOptions, RedisAdapter, type RedisAdapterOptions, type SagaDefinition, type ScheduleOptions, Scheduler, type SerializationOptions, SlidingWindowRateLimiter, type StepHandler, type ListOptions as StorageListOptions, type Stream, type StreamInfo, type StreamOptions, type SubscribeOptions, type Subscription, type Duration as TimeDuration, type TimeSeriesMetrics, TokenBucketRateLimiter, type TrackedEvent, type TrimStrategy, Worker, type WorkerOptions, type Workflow, type WorkflowBuilder, type WorkflowContext, type WorkflowEvent, type WorkflowExecution, type WorkflowMetrics, type WorkflowStorage, addDuration, areJobsEquivalent, batch, batchByKey, calculateBackoff, chunk, circuitBreaker, cloneViaSerialization, createFlow, createRateLimiter, createWorker, delayUntil, deserialize, deserializeCompressed, formatDuration, fromMilliseconds, generateDeduplicationKey, generateDeterministicId, generateExecutionId, generateId, generateJobId, generateMessageId, getSerializedSize, hashJob, isFuture, isPast, isSerializable, now, parseDuration, processBatches, serialize, serializeCompressed, serializeSafe, sleep, sleepDuration, timeout, toMilliseconds };