reqon-dsl 0.2.0 → 0.3.0

package/CHANGELOG.md

@@ -0,0 +1,7 @@
+# Changelog
+
+The changelog has moved to the documentation site:
+
+**[https://reqon.mcclowes.com/changelog](https://reqon.mcclowes.com/changelog)**
+
+This keeps the changelog alongside the rest of the documentation and ensures it stays up to date.

package/README.md

@@ -191,6 +191,28 @@ run Step1 then Step2 then Step3
 run [Step1, Step2] then Step3  // Step1 and Step2 run in parallel, then Step3
 ```
 
+### Durability Features
+
+```vague
+mission DurablePipeline {
+  // Checkpoint after each step for resume-on-failure
+  checkpoint: afterStep  // or onFailure
+
+  // Enable time-travel debugging
+  trace: full  // or minimal
+
+  action WaitForApproval {
+    // Resource-free pause (days/weeks without holding resources)
+    pause {
+      duration: "7d",
+      resumeOn: timeout | webhook "/approved"
+    }
+  }
+
+  run WaitForApproval
+}
+```
+
 ## OpenAPI Integration
 
 Reqon can consume OpenAPI specs directly, eliminating the need for handwritten SDK code:

package/dist/ast/nodes.d.ts

@@ -1,5 +1,19 @@
+/**
+ * ---
+ * purpose: AST node type definitions for Reqon programs
+ * exports:
+ *   - ReqonProgram, Statement - top-level types
+ *   - MissionDefinition, ActionDefinition - pipeline structure
+ *   - SourceDefinition, StoreDefinition - resource declarations
+ *   - FetchStep, ForStep, MapStep, ValidateStep, etc. - action steps
+ * related:
+ *   - ../parser/parser.ts - produces these AST nodes
+ *   - ../interpreter/executor.ts - executes AST
+ *   - vague-lang - Expression, SchemaDefinition from parent DSL
+ * ---
+ */
 import type { Expression, SchemaDefinition, Statement as VagueStatement } from 'vague-lang';
-export type Statement = VagueStatement | MissionDefinition | SourceDefinition | StoreDefinition | ActionDefinition;
+export type Statement = VagueStatement | MissionDefinition | SourceDefinition | StoreDefinition | ActionDefinition | TransformDefinition;
 export interface ReqonProgram {
     type: 'ReqonProgram';
     statements: Statement[];
@@ -39,7 +53,7 @@ export interface AuthConfig {
 export interface StoreDefinition {
     type: 'StoreDefinition';
     name: string;
-    storeType: 'nosql' | 'sql' | 'memory';
+    storeType: 'nosql' | 'sql' | 'memory' | 'file' | 'postgrest';
     target: string;
 }
 export interface ScheduleDefinition {
@@ -61,13 +75,32 @@ export interface ScheduleRetryConfig {
     maxRetries: number;
     delaySeconds: number;
 }
+export interface CheckpointConfig {
+    type: 'CheckpointConfig';
+    /** When to create checkpoints */
+    mode: 'after-step' | 'on-failure';
+    /** Optional: custom store for checkpoint data (defaults to FileStore) */
+    store?: string;
+}
+export interface TraceConfig {
+    type: 'TraceConfig';
+    /** Trace mode - 'full' captures state at each step */
+    mode: 'full' | 'minimal';
+    /** Optional: custom store for trace data */
+    store?: string;
+}
 export interface MissionDefinition {
     type: 'MissionDefinition';
     name: string;
     schedule?: ScheduleDefinition;
+    /** Checkpoint configuration for durable execution */
+    checkpoint?: CheckpointConfig;
+    /** Trace configuration for time-travel debugging */
+    trace?: TraceConfig;
     sources: SourceDefinition[];
     stores: StoreDefinition[];
     schemas: SchemaDefinition[];
+    transforms: TransformDefinition[];
     actions: ActionDefinition[];
     pipeline: PipelineDefinition;
 }
@@ -76,7 +109,7 @@ export interface ActionDefinition {
     name: string;
     steps: ActionStep[];
 }
-export type ActionStep = FetchStep | ForStep | MapStep | ValidateStep | StoreStep | MatchStep | LetStep | WebhookStep;
+export type ActionStep = FetchStep | ForStep | MapStep | ValidateStep | StoreStep | MatchStep | LetStep | ApplyStep | WebhookStep | PauseStep;
 export interface LetStep {
     type: 'LetStep';
     name: string;
@@ -103,6 +136,22 @@ export interface WebhookStorageConfig {
     /** Expression for extracting key from webhook payload */
     key?: Expression;
 }
+export interface PauseStep {
+    type: 'PauseStep';
+    /** Duration to pause (e.g., "7d", "1h", "30m", 86400000) */
+    duration: string | number;
+    /** Store to persist pause state (defaults to FileStore) */
+    persist?: string;
+    /** Resume triggers - timeout (default) and/or webhook */
+    resumeOn?: PauseResumeTrigger[];
+}
+export type PauseResumeTrigger = {
+    type: 'timeout';
+} | {
+    type: 'webhook';
+    path: string;
+    eventFilter?: Expression;
+};
 export type FlowDirective = {
     type: 'continue';
 } | {
@@ -129,6 +178,8 @@ export interface MatchStep {
 export interface MatchArm {
     /** Schema name to match against, or '_' for wildcard */
     schema: string;
+    /** Optional guard condition (when using 'where' clause) */
+    guard?: Expression;
     /** Steps to execute if matched */
     steps?: ActionStep[];
     /** Flow control directive (if no steps) */
@@ -152,8 +203,10 @@ export interface SinceConfig {
     type: 'lastSync' | 'expression';
     /** Custom checkpoint key (defaults to source:endpoint) */
     key?: string;
-    /** Query parameter name for the since value (default: varies by API) */
+    /** Query parameter name for the since value (default: 'since') */
     param?: string;
+    /** Header name for the since value (e.g., 'If-Modified-Since'). Mutually exclusive with param. */
+    header?: string;
     /** Date format for the since value */
     format?: 'iso' | 'unix' | 'unix-ms' | 'date-only';
     /** Expression to evaluate for 'expression' type */
@@ -194,6 +247,32 @@ export interface FieldMapping {
     field: string;
     expression: Expression;
 }
+export interface TransformDefinition {
+    type: 'TransformDefinition';
+    name: string;
+    variants: TransformVariant[];
+}
+export interface TransformVariant {
+    /** Source schema name, or '_' for wildcard/default */
+    sourceSchema: string | '_';
+    /** Target schema name */
+    targetSchema: string;
+    /** Optional guard condition for additional matching */
+    guard?: Expression;
+    /** Field mappings for this variant */
+    mappings: FieldMapping[];
+}
+export interface ApplyStep {
+    type: 'ApplyStep';
+    transform: string;
+    source: Expression;
+    /** Optional: bind result to a variable instead of response */
+    as?: string;
+}
+export interface TryExpression {
+    type: 'TryExpression';
+    expressions: Expression[];
+}
 export interface ValidateStep {
     type: 'ValidateStep';
     target: Expression;

package/dist/ast/nodes.js

@@ -1,3 +1,17 @@
+/**
+ * ---
+ * purpose: AST node type definitions for Reqon programs
+ * exports:
+ *   - ReqonProgram, Statement - top-level types
+ *   - MissionDefinition, ActionDefinition - pipeline structure
+ *   - SourceDefinition, StoreDefinition - resource declarations
+ *   - FetchStep, ForStep, MapStep, ValidateStep, etc. - action steps
+ * related:
+ *   - ../parser/parser.ts - produces these AST nodes
+ *   - ../interpreter/executor.ts - executes AST
+ *   - vague-lang - Expression, SchemaDefinition from parent DSL
+ * ---
+ */
 /** Helper to check if a stage is parallel */
 export function isParallelStage(stage) {
     return Array.isArray(stage.actions) && stage.actions.length > 0;

package/dist/auth/circuit-breaker.js

@@ -9,13 +9,14 @@
  * - OPEN: Circuit tripped, requests fail immediately
  * - HALF_OPEN: Testing if service recovered, limited requests allowed
  */
+import { CIRCUIT_BREAKER_DEFAULTS } from '../config/index.js';
 const DEFAULT_CONFIG = {
-    failureThreshold: 5,
-    resetTimeout: 30000,
-    successThreshold: 2,
-    failureWindow: 60000,
-    failureStatusCodes: [500, 501, 502, 503, 504],
-    countNetworkErrors: true,
+    failureThreshold: CIRCUIT_BREAKER_DEFAULTS.FAILURE_THRESHOLD,
+    resetTimeout: CIRCUIT_BREAKER_DEFAULTS.RESET_TIMEOUT_MS,
+    successThreshold: CIRCUIT_BREAKER_DEFAULTS.SUCCESS_THRESHOLD,
+    failureWindow: CIRCUIT_BREAKER_DEFAULTS.FAILURE_WINDOW_MS,
+    failureStatusCodes: [...CIRCUIT_BREAKER_DEFAULTS.FAILURE_STATUS_CODES],
+    countNetworkErrors: CIRCUIT_BREAKER_DEFAULTS.COUNT_NETWORK_ERRORS,
 };
 /**
  * Error thrown when circuit breaker is open

package/dist/auth/rate-limiter.d.ts

@@ -16,6 +16,10 @@ export declare class RateLimitError extends Error {
     resetAt?: Date | undefined;
     constructor(source: string, resetAt?: Date | undefined);
 }
+/**
+ * Adaptive rate limiter that learns from response headers
+ * Supports pause, throttle, and fail strategies
+ */
 export declare class AdaptiveRateLimiter implements RateLimiter {
     private defaultConfig;
     private state;

package/dist/auth/rate-limiter.js

@@ -1,15 +1,10 @@
 import { sleep } from '../utils/async.js';
-/** Max age for stale entries (default: 1 hour) */
-const DEFAULT_MAX_STALE_AGE_MS = 60 * 60 * 1000;
-/** Cleanup interval (default: 5 minutes) */
-const CLEANUP_INTERVAL_MS = 5 * 60 * 1000;
-/** Max number of entries before forced cleanup */
-const MAX_ENTRIES_BEFORE_CLEANUP = 1000;
+import { RATE_LIMIT_DEFAULTS } from '../config/index.js';
 const DEFAULT_CONFIG = {
-    strategy: 'pause',
-    maxWait: 300,
-    notifyAt: 10,
-    fallbackRpm: 60,
+    strategy: RATE_LIMIT_DEFAULTS.STRATEGY,
+    maxWait: RATE_LIMIT_DEFAULTS.MAX_WAIT_SECONDS,
+    notifyAt: RATE_LIMIT_DEFAULTS.NOTIFY_AT_SECONDS,
+    fallbackRpm: RATE_LIMIT_DEFAULTS.FALLBACK_RPM,
 };
 /**
  * Rate limit timeout error - thrown when maxWait is exceeded
@@ -44,8 +39,6 @@ export class RateLimitError extends Error {
  * Adaptive rate limiter that learns from response headers
  * Supports pause, throttle, and fail strategies
  */
-/** Number of responses between cleanup checks */
-const CLEANUP_CHECK_INTERVAL = 100;
 export class AdaptiveRateLimiter {
     defaultConfig;
     state = new Map();
@@ -56,7 +49,7 @@ export class AdaptiveRateLimiter {
     responsesSinceCleanup = 0;
     constructor(defaultConfig = {}, options = {}) {
         this.defaultConfig = defaultConfig;
-        this.maxStaleAgeMs = options.maxStaleAgeMs ?? DEFAULT_MAX_STALE_AGE_MS;
+        this.maxStaleAgeMs = options.maxStaleAgeMs ?? RATE_LIMIT_DEFAULTS.MAX_STALE_AGE_MS;
     }
     /**
      * Clean up stale entries from the state map to prevent memory leaks
@@ -64,8 +57,8 @@ export class AdaptiveRateLimiter {
     cleanup() {
         const now = Date.now();
         // Skip if cleanup was done recently and we're under the entry limit
-        if (now - this.lastCleanup < CLEANUP_INTERVAL_MS &&
-            this.state.size < MAX_ENTRIES_BEFORE_CLEANUP) {
+        if (now - this.lastCleanup < RATE_LIMIT_DEFAULTS.CLEANUP_INTERVAL_MS &&
+            this.state.size < RATE_LIMIT_DEFAULTS.MAX_ENTRIES_BEFORE_CLEANUP) {
             return;
         }
         this.lastCleanup = now;
@@ -260,7 +253,7 @@ export class AdaptiveRateLimiter {
         this.state.set(key, state);
         // Periodically clean up stale entries (every N responses)
         this.responsesSinceCleanup++;
-        if (this.responsesSinceCleanup >= CLEANUP_CHECK_INTERVAL) {
+        if (this.responsesSinceCleanup >= RATE_LIMIT_DEFAULTS.CLEANUP_CHECK_INTERVAL) {
             this.responsesSinceCleanup = 0;
             this.cleanup();
         }

package/dist/cli.d.ts

@@ -1,2 +1,15 @@
 #!/usr/bin/env node
+/**
+ * ---
+ * purpose: CLI entry point - parses args and runs missions
+ * inputs:
+ *   - file.reqon or folder path
+ *   - --dry-run, --verbose, --auth, --env, --output, --daemon, --webhook, --debug
+ * related:
+ *   - ./index.ts - library APIs used by CLI
+ *   - ./scheduler/index.ts - daemon mode scheduling
+ *   - ./webhook/index.ts - webhook server for wait steps
+ *   - ./debug/cli-debugger.ts - interactive debugging
+ * ---
+ */
 export {};

package/dist/cli.js

@@ -1,10 +1,24 @@
 #!/usr/bin/env node
+/**
+ * ---
+ * purpose: CLI entry point - parses args and runs missions
+ * inputs:
+ *   - file.reqon or folder path
+ *   - --dry-run, --verbose, --auth, --env, --output, --daemon, --webhook, --debug
+ * related:
+ *   - ./index.ts - library APIs used by CLI
+ *   - ./scheduler/index.ts - daemon mode scheduling
+ *   - ./webhook/index.ts - webhook server for wait steps
+ *   - ./debug/cli-debugger.ts - interactive debugging
+ * ---
+ */
 import { readFile, writeFile, mkdir } from 'node:fs/promises';
 import { resolve, dirname } from 'node:path';
 import { fromPath, Scheduler, loadMission } from './index.js';
 import { ReqonError } from './errors/index.js';
 import { loadEnv, loadCredentials } from './auth/credentials.js';
 import { WebhookServer } from './webhook/index.js';
+import { ControlServer } from './control/index.js';
 async function main() {
     const args = process.argv.slice(2);
     if (args.length === 0 || args.includes('--help') || args.includes('-h')) {
@@ -25,6 +39,10 @@ Options:
   --webhook            Enable webhook server for 'wait' steps
   --webhook-port <n>   Port for webhook server (default: 3000)
   --webhook-url <url>  Base URL for webhook endpoints (default: http://localhost:3000)
+  --control            Enable control server for pause/resume and status queries
+  --control-port <n>   Port for control server (default: 3001)
+  --debug              Enable step-through debugging
+  --resume <id>        Resume a paused or failed execution by ID
   --help, -h           Show this help message
 
 Environment Variables:
@@ -44,6 +62,15 @@ Examples:
   reqon sync-invoices.reqon --output ./output.json
   reqon sync-invoices.reqon --daemon --verbose
   reqon sync-invoices.reqon --webhook --webhook-port 8080 --verbose
+  reqon sync-invoices.reqon --control --verbose   # enable control server
+  reqon sync-invoices.reqon --resume exec_abc123  # resume paused execution
+
+Control Server:
+  When --control is enabled, the server exposes these endpoints:
+    POST /pause    Request graceful pause at next safe point
+    POST /resume   Clear pause request
+    GET  /status   Get current execution state and progress
+    GET  /health   Health check
 `);
         process.exit(0);
     }
@@ -53,6 +80,8 @@ Examples:
     const daemon = args.includes('--daemon');
     const once = args.includes('--once');
     const webhookEnabled = args.includes('--webhook');
+    const debugEnabled = args.includes('--debug');
+    const controlEnabled = args.includes('--control');
     // Parse webhook options
     let webhookPort = 3000;
     const webhookPortIndex = args.indexOf('--webhook-port');
@@ -64,6 +93,18 @@ Examples:
     if (webhookUrlIndex !== -1 && args[webhookUrlIndex + 1]) {
         webhookUrl = args[webhookUrlIndex + 1];
     }
+    // Parse control server options
+    let controlPort = 3001;
+    const controlPortIndex = args.indexOf('--control-port');
+    if (controlPortIndex !== -1 && args[controlPortIndex + 1]) {
+        controlPort = parseInt(args[controlPortIndex + 1], 10);
+    }
+    // Parse resume option
+    let resumeFrom;
+    const resumeIndex = args.indexOf('--resume');
+    if (resumeIndex !== -1 && args[resumeIndex + 1]) {
+        resumeFrom = args[resumeIndex + 1];
+    }
     // Load .env file(s)
     let envFile;
     const envIndex = args.indexOf('--env');
@@ -112,14 +153,43 @@ Examples:
         await webhookServer.start();
         console.log(`Webhook server started on port ${webhookPort}`);
     }
+    // Start control server if enabled
+    let controlServer;
+    if (controlEnabled) {
+        controlServer = new ControlServer({ port: controlPort, verbose });
+        await controlServer.start();
+        console.log(`Control server started on port ${controlPort}`);
+        console.log(`  POST http://localhost:${controlPort}/pause  - request pause`);
+        console.log(`  GET  http://localhost:${controlPort}/status - check status`);
+    }
+    // Initialize debug controller if enabled
+    let debugController;
+    if (debugEnabled) {
+        const { CLIDebugger } = await import('./debug/cli-debugger.js');
+        debugController = new CLIDebugger();
+        console.log('Debug mode enabled. Commands: c(ontinue), s(tep), si(step-into), so(step-over), q(uit)');
+        console.log('Type "help" at the debug prompt for more commands.\n');
+    }
     try {
         const result = await fromPath(filePath, {
             dryRun,
             verbose,
             auth: auth,
             webhookServer,
+            debugController,
+            controlServer,
+            resumeFrom,
         });
-        if (result.success) {
+        // Check if execution was paused
+        const isPaused = result.state?.status === 'paused';
+        if (isPaused) {
+            console.log(`\n⏸ Mission paused`);
+            console.log(`  Duration: ${result.duration}ms`);
+            console.log(`  Actions run: ${result.actionsRun.join(' → ')}`);
+            console.log(`  Execution ID: ${result.executionId}`);
+            console.log(`\n  To resume: reqon ${filePath} --resume ${result.executionId}`);
+        }
+        else if (result.success) {
             console.log(`\n✓ Mission completed successfully`);
             console.log(`  Duration: ${result.duration}ms`);
             console.log(`  Actions run: ${result.actionsRun.join(' → ')}`);
@@ -127,7 +197,7 @@ Examples:
             const storeData = {};
             for (const [name, store] of result.stores) {
                 const items = await store.list();
-                console.log(`  Store "${name}": ${items.length} items`);
+                console.log(`  Store "${name}": ${items.length} ${items.length === 1 ? 'item' : 'items'}`);
                 storeData[name] = items;
             }
             // Export to JSON if requested
@@ -142,6 +212,10 @@ Examples:
             for (const error of result.errors) {
                 console.error(`  [${error.action}/${error.step}] ${error.message}`);
             }
+            if (result.executionId) {
+                console.log(`\n  Execution ID: ${result.executionId}`);
+                console.log(`  To resume: reqon ${filePath} --resume ${result.executionId}`);
+            }
             process.exit(1);
         }
     }
@@ -159,16 +233,22 @@ Examples:
         if (webhookServer) {
             await webhookServer.stop();
         }
+        // Stop control server if it was started
+        if (controlServer) {
+            await controlServer.stop();
+        }
+        // Close debug controller if it was started
+        if (debugController?.close) {
+            debugController.close();
+        }
     }
 }
 async function runDaemon(filePath, options) {
     const absolutePath = resolve(filePath);
     let program;
-    let baseDir;
     try {
         const result = await loadMission(absolutePath);
         program = result.program;
-        baseDir = result.baseDir;
     }
     catch (error) {
         if (error instanceof ReqonError) {

package/dist/config/constants.d.ts

@@ -0,0 +1,141 @@
+/**
+ * Centralized Configuration Constants
+ *
+ * This module contains all default values and configuration constants used
+ * throughout the Reqon framework. Centralizing these values makes it easier
+ * to understand, tune, and override defaults.
+ */
+/**
+ * Default retry configuration for HTTP requests
+ */
+export declare const HTTP_RETRY_DEFAULTS: {
+    /** Maximum number of retry attempts */
+    readonly MAX_ATTEMPTS: 3;
+    /** Initial delay between retries in milliseconds */
+    readonly INITIAL_DELAY_MS: 1000;
+    /** Maximum delay between retries in milliseconds */
+    readonly MAX_DELAY_MS: 30000;
+    /** Backoff strategy: 'exponential', 'linear', or 'constant' */
+    readonly BACKOFF: "exponential";
+};
+/**
+ * Default HTTP headers
+ */
+export declare const HTTP_DEFAULT_HEADERS: {
+    readonly CONTENT_TYPE: "application/json";
+    readonly ACCEPT: "application/json";
+};
+/**
+ * Default rate limiter configuration
+ */
+export declare const RATE_LIMIT_DEFAULTS: {
+    /** Default strategy when rate limited: 'pause', 'throttle', or 'fail' */
+    readonly STRATEGY: "pause";
+    /** Maximum wait time in seconds before timing out */
+    readonly MAX_WAIT_SECONDS: 300;
+    /** Seconds before starting to notify about ongoing waits */
+    readonly NOTIFY_AT_SECONDS: 10;
+    /** Fallback requests per minute when no rate limit info available */
+    readonly FALLBACK_RPM: 60;
+    /** Maximum age for stale rate limit entries (1 hour in ms) */
+    readonly MAX_STALE_AGE_MS: number;
+    /** Cleanup interval for stale entries (5 minutes in ms) */
+    readonly CLEANUP_INTERVAL_MS: number;
+    /** Number of responses between cleanup checks */
+    readonly CLEANUP_CHECK_INTERVAL: 100;
+    /** Maximum entries before forced cleanup */
+    readonly MAX_ENTRIES_BEFORE_CLEANUP: 1000;
+};
+/**
+ * Default circuit breaker configuration
+ */
+export declare const CIRCUIT_BREAKER_DEFAULTS: {
+    /** Number of failures before opening circuit */
+    readonly FAILURE_THRESHOLD: 5;
+    /** Time in milliseconds before attempting recovery */
+    readonly RESET_TIMEOUT_MS: 30000;
+    /** Number of successful requests in half-open to close circuit */
+    readonly SUCCESS_THRESHOLD: 2;
+    /** Time window in milliseconds for counting failures */
+    readonly FAILURE_WINDOW_MS: 60000;
+    /** HTTP status codes to count as failures */
+    readonly FAILURE_STATUS_CODES: readonly number[];
+    /** Whether to count network errors as failures */
+    readonly COUNT_NETWORK_ERRORS: true;
+};
+/**
+ * Default webhook server configuration
+ */
+export declare const WEBHOOK_DEFAULTS: {
+    /** Default port for webhook server */
+    readonly PORT: 3000;
+    /** Default host binding */
+    readonly HOST: "0.0.0.0";
+    /** Default timeout for wait steps (5 minutes in ms) */
+    readonly DEFAULT_TIMEOUT_MS: 300000;
+    /** Cleanup interval for expired registrations (1 minute in ms) */
+    readonly CLEANUP_INTERVAL_MS: 60000;
+};
+/**
+ * Default store configuration
+ */
+export declare const STORE_DEFAULTS: {
+    /** Default base directory for file stores */
+    readonly DATA_DIR: ".reqon-data";
+    /** Default subdirectory for executions */
+    readonly EXECUTIONS_DIR: "executions";
+    /** Default subdirectory for sync state */
+    readonly SYNC_DIR: "sync";
+};
+/**
+ * Default scheduler configuration
+ */
+export declare const SCHEDULER_DEFAULTS: {
+    /** Default retry configuration for failed scheduled missions */
+    readonly MAX_RETRIES: 3;
+    /** Default delay between retries in seconds */
+    readonly RETRY_DELAY_SECONDS: 60;
+};
+/**
+ * Default execution configuration
+ */
+export declare const EXECUTION_DEFAULTS: {
+    /** Whether development mode is enabled by default (uses file stores) */
+    readonly DEVELOPMENT_MODE: true;
+    /** Whether to persist execution state by default */
+    readonly PERSIST_STATE: false;
+};
+/** Type for rate limit strategy */
+export type RateLimitStrategy = 'pause' | 'throttle' | 'fail';
+/** Type for retry backoff strategy */
+export type BackoffStrategy = 'exponential' | 'linear' | 'constant';
+/**
+ * Merged configuration type utilities
+ */
+export type HttpRetryConfig = {
+    maxAttempts?: number;
+    initialDelay?: number;
+    maxDelay?: number;
+    backoff?: BackoffStrategy;
+};
+export type RateLimitConfig = {
+    strategy?: RateLimitStrategy;
+    maxWait?: number;
+    notifyAt?: number;
+    fallbackRpm?: number;
+};
+export type CircuitBreakerConfig = {
+    failureThreshold?: number;
+    resetTimeout?: number;
+    successThreshold?: number;
+    failureWindow?: number;
+    failureStatusCodes?: number[];
+    countNetworkErrors?: boolean;
+};
+export type WebhookConfig = {
+    port?: number;
+    host?: string;
+    baseUrl?: string;
+    defaultTimeout?: number;
+    verbose?: boolean;
+};