@parsrun/payments 0.1.0

package/dist/schema-C5Zcju_j.d.ts

@@ -0,0 +1,4191 @@
+import { PaymentProviderType } from './types.js';
+import * as drizzle_orm_pg_core from 'drizzle-orm/pg-core';
+
+/**
+ * @parsrun/payments - Dunning Types
+ * Types for dunning automation and payment recovery
+ */
+
+/**
+ * Payment failure reason categories
+ * Used for smart retry logic
+ */
+type PaymentFailureCategory = "card_declined" | "insufficient_funds" | "card_expired" | "invalid_card" | "processing_error" | "authentication_required" | "fraud_suspected" | "velocity_exceeded" | "unknown";
+/**
+ * Payment failure details
+ */
+interface PaymentFailure {
+    /** Unique failure ID */
+    id: string;
+    /** Customer ID */
+    customerId: string;
+    /** Subscription ID */
+    subscriptionId: string;
+    /** Invoice ID (if applicable) */
+    invoiceId?: string;
+    /** Amount that failed (cents) */
+    amount: number;
+    /** Currency */
+    currency: string;
+    /** Failure category */
+    category: PaymentFailureCategory;
+    /** Raw error code from provider */
+    errorCode: string;
+    /** Human-readable error message */
+    errorMessage: string;
+    /** Provider type */
+    provider: PaymentProviderType;
+    /** When the failure occurred */
+    failedAt: Date;
+    /** Number of retry attempts so far */
+    retryCount: number;
+    /** Next scheduled retry (if any) */
+    nextRetryAt?: Date;
+    /** Whether this failure is recoverable */
+    isRecoverable: boolean;
+    /** Metadata */
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Action to take in a dunning step
+ */
+type DunningAction = "notify" | "retry_payment" | "limit_features" | "suspend" | "cancel" | "custom";
+/**
+ * Notification channel
+ */
+type NotificationChannel = "email" | "sms" | "in_app" | "webhook" | "push";
+/**
+ * Dunning step definition
+ */
+interface DunningStep {
+    /** Step ID (unique within sequence) */
+    id: string;
+    /** Step name for display */
+    name: string;
+    /** Days after initial failure (0 = immediately) */
+    daysAfterFailure: number;
+    /** Hours offset within the day (for precise timing) */
+    hoursOffset?: number;
+    /** Actions to take */
+    actions: DunningAction[];
+    /** Notification channels to use */
+    notificationChannels?: NotificationChannel[];
+    /** Notification template ID */
+    notificationTemplateId?: string;
+    /** Whether to retry payment in this step */
+    retryPayment?: boolean;
+    /** Access level to set (for limit_features action) */
+    accessLevel?: "full" | "limited" | "read_only" | "none";
+    /** Whether this step is final (ends the sequence) */
+    isFinal?: boolean;
+    /** Custom action handler */
+    customAction?: (context: DunningContext) => Promise<void>;
+    /** Condition to execute this step */
+    condition?: (context: DunningContext) => boolean | Promise<boolean>;
+    /** Metadata */
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Dunning sequence definition
+ */
+interface DunningSequence {
+    /** Sequence ID */
+    id: string;
+    /** Sequence name */
+    name: string;
+    /** Description */
+    description?: string;
+    /** Steps in order */
+    steps: DunningStep[];
+    /** Maximum days before auto-cancel (if not in steps) */
+    maxDurationDays: number;
+    /** Whether sequence is active */
+    isActive: boolean;
+    /** Metadata */
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Dunning process status
+ */
+type DunningStatus = "active" | "recovered" | "exhausted" | "canceled" | "paused";
+/**
+ * Dunning process state for a customer
+ */
+interface DunningState {
+    /** State ID */
+    id: string;
+    /** Customer ID */
+    customerId: string;
+    /** Subscription ID */
+    subscriptionId: string;
+    /** Sequence ID being executed */
+    sequenceId: string;
+    /** Current step index */
+    currentStepIndex: number;
+    /** Current step ID */
+    currentStepId: string;
+    /** Status */
+    status: DunningStatus;
+    /** Initial failure that started dunning */
+    initialFailure: PaymentFailure;
+    /** All failures during this dunning */
+    failures: PaymentFailure[];
+    /** Steps executed so far */
+    executedSteps: ExecutedStep[];
+    /** When dunning started */
+    startedAt: Date;
+    /** When last step was executed */
+    lastStepAt?: Date;
+    /** When next step is scheduled */
+    nextStepAt?: Date;
+    /** When dunning ended (if ended) */
+    endedAt?: Date;
+    /** End reason */
+    endReason?: "payment_recovered" | "max_retries" | "manually_canceled" | "subscription_canceled";
+    /** Total retry attempts */
+    totalRetryAttempts: number;
+    /** Metadata */
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Executed step record
+ */
+interface ExecutedStep {
+    /** Step ID */
+    stepId: string;
+    /** Step name */
+    stepName: string;
+    /** When executed */
+    executedAt: Date;
+    /** Actions taken */
+    actionsTaken: DunningAction[];
+    /** Whether payment was retried */
+    paymentRetried: boolean;
+    /** Whether payment succeeded (if retried) */
+    paymentSucceeded?: boolean;
+    /** Notifications sent */
+    notificationsSent: NotificationChannel[];
+    /** Any errors during execution */
+    error?: string;
+}
+/**
+ * Context passed to dunning step handlers
+ */
+interface DunningContext {
+    /** Dunning state */
+    state: DunningState;
+    /** Current step being executed */
+    step: DunningStep;
+    /** Latest payment failure */
+    latestFailure: PaymentFailure;
+    /** Customer info */
+    customer: {
+        id: string;
+        email?: string;
+        name?: string;
+        metadata?: Record<string, unknown>;
+    };
+    /** Subscription info */
+    subscription: {
+        id: string;
+        planId?: string;
+        status: string;
+        currentPeriodEnd?: Date;
+    };
+    /** Days since initial failure */
+    daysSinceFailure: number;
+    /** Total amount owed */
+    amountOwed: number;
+    /** Currency */
+    currency: string;
+}
+/**
+ * Retry strategy based on failure category
+ */
+interface RetryStrategy {
+    /** Failure category this applies to */
+    category: PaymentFailureCategory;
+    /** Whether to retry at all */
+    shouldRetry: boolean;
+    /** Delay before first retry (hours) */
+    initialDelayHours: number;
+    /** Maximum retry attempts for this category */
+    maxRetries: number;
+    /** Delay multiplier for subsequent retries */
+    backoffMultiplier: number;
+    /** Maximum delay (hours) */
+    maxDelayHours: number;
+    /** Optimal retry times (hour of day, 0-23) */
+    optimalRetryHours?: number[];
+    /** Optimal retry days (0=Sunday, 1=Monday, etc.) */
+    optimalRetryDays?: number[];
+}
+/**
+ * Payment retry result
+ */
+interface RetryResult {
+    /** Whether retry was successful */
+    success: boolean;
+    /** New failure if retry failed */
+    failure?: PaymentFailure;
+    /** Transaction ID if successful */
+    transactionId?: string;
+    /** When retry was attempted */
+    attemptedAt: Date;
+    /** Provider response */
+    providerResponse?: Record<string, unknown>;
+}
+/**
+ * Dunning notification request
+ */
+interface DunningNotification {
+    /** Channel to send on */
+    channel: NotificationChannel;
+    /** Template ID */
+    templateId: string;
+    /** Recipient */
+    recipient: {
+        customerId: string;
+        email?: string;
+        phone?: string;
+        userId?: string;
+    };
+    /** Template variables */
+    variables: {
+        customerName?: string;
+        amount: number;
+        currency: string;
+        daysSinceFailure: number;
+        daysUntilSuspension?: number;
+        daysUntilCancellation?: number;
+        updatePaymentUrl?: string;
+        invoiceUrl?: string;
+        supportUrl?: string;
+        [key: string]: unknown;
+    };
+    /** Dunning context for reference */
+    context: DunningContext;
+}
+/**
+ * Notification result
+ */
+interface NotificationResult {
+    /** Whether notification was sent */
+    success: boolean;
+    /** Channel used */
+    channel: NotificationChannel;
+    /** External ID (email ID, SMS ID, etc.) */
+    externalId?: string;
+    /** Error if failed */
+    error?: string;
+    /** When sent */
+    sentAt: Date;
+}
+/**
+ * Dunning event types
+ */
+type DunningEventType = "dunning.started" | "dunning.step_executed" | "dunning.payment_retried" | "dunning.payment_recovered" | "dunning.notification_sent" | "dunning.access_limited" | "dunning.suspended" | "dunning.canceled" | "dunning.exhausted" | "dunning.paused" | "dunning.resumed";
+/**
+ * Dunning event
+ */
+interface DunningEvent {
+    /** Event type */
+    type: DunningEventType;
+    /** Customer ID */
+    customerId: string;
+    /** Subscription ID */
+    subscriptionId: string;
+    /** Dunning state ID */
+    dunningStateId: string;
+    /** Event timestamp */
+    timestamp: Date;
+    /** Event-specific data */
+    data: Record<string, unknown>;
+}
+/**
+ * Dunning event handler
+ */
+type DunningEventHandler = (event: DunningEvent) => void | Promise<void>;
+/**
+ * Dunning manager configuration
+ */
+interface DunningManagerConfig {
+    /** Default dunning sequence */
+    defaultSequence: DunningSequence;
+    /** Sequences by plan tier (optional) */
+    sequencesByPlanTier?: Record<number, DunningSequence>;
+    /** Payment retry strategies */
+    retryStrategies?: RetryStrategy[];
+    /** Notification handler */
+    onNotification?: (notification: DunningNotification) => Promise<NotificationResult>;
+    /** Payment retry handler (called to actually retry payment) */
+    onRetryPayment?: (context: DunningContext) => Promise<RetryResult>;
+    /** Access update handler */
+    onAccessUpdate?: (customerId: string, accessLevel: "full" | "limited" | "read_only" | "none") => Promise<void>;
+    /** Subscription cancel handler */
+    onCancelSubscription?: (subscriptionId: string, reason: string) => Promise<void>;
+    /** Event handlers */
+    onEvent?: DunningEventHandler;
+    /** Logger */
+    logger?: DunningLogger;
+    /** URLs for notification templates */
+    urls?: {
+        updatePayment?: string;
+        viewInvoice?: string;
+        support?: string;
+    };
+    /** Timezone for scheduling (default: UTC) */
+    timezone?: string;
+}
+/**
+ * Logger interface
+ */
+interface DunningLogger {
+    debug(message: string, data?: Record<string, unknown>): void;
+    info(message: string, data?: Record<string, unknown>): void;
+    warn(message: string, data?: Record<string, unknown>): void;
+    error(message: string, data?: Record<string, unknown>): void;
+}
+/**
+ * Dunning storage interface
+ */
+interface DunningStorage {
+    getDunningState(customerId: string): Promise<DunningState | null>;
+    getActiveDunningStates(): Promise<DunningState[]>;
+    getDunningStatesByStatus(status: DunningStatus): Promise<DunningState[]>;
+    saveDunningState(state: DunningState): Promise<void>;
+    updateDunningState(id: string, updates: Partial<DunningState>): Promise<void>;
+    recordPaymentFailure(failure: PaymentFailure): Promise<void>;
+    getPaymentFailures(customerId: string, limit?: number): Promise<PaymentFailure[]>;
+    getScheduledSteps(before: Date): Promise<Array<{
+        stateId: string;
+        stepId: string;
+        scheduledAt: Date;
+    }>>;
+    scheduleStep(stateId: string, stepId: string, scheduledAt: Date): Promise<void>;
+    removeScheduledStep(stateId: string, stepId: string): Promise<void>;
+}
+
+/**
+ * @parsrun/payments - Dunning Sequence
+ * Default sequences and step builders for dunning automation
+ */
+
+/**
+ * Fluent builder for dunning steps
+ */
+declare class DunningStepBuilder {
+    private step;
+    constructor(id: string, name: string);
+    /**
+     * Set days after initial failure
+     */
+    afterDays(days: number): this;
+    /**
+     * Set hours offset within the day
+     */
+    atHour(hour: number): this;
+    /**
+     * Add actions to take
+     */
+    withActions(...actions: DunningAction[]): this;
+    /**
+     * Add notification channels
+     */
+    notify(...channels: NotificationChannel[]): this;
+    /**
+     * Set notification template
+     */
+    withTemplate(templateId: string): this;
+    /**
+     * Enable payment retry in this step
+     */
+    retryPayment(retry?: boolean): this;
+    /**
+     * Set access level for this step
+     */
+    setAccessLevel(level: "full" | "limited" | "read_only" | "none"): this;
+    /**
+     * Mark this as the final step
+     */
+    final(isFinal?: boolean): this;
+    /**
+     * Add custom action handler
+     */
+    withCustomAction(handler: (context: DunningContext) => Promise<void>): this;
+    /**
+     * Add condition for this step
+     */
+    when(condition: (context: DunningContext) => boolean | Promise<boolean>): this;
+    /**
+     * Add metadata
+     */
+    withMetadata(metadata: Record<string, unknown>): this;
+    /**
+     * Build the step
+     */
+    build(): DunningStep;
+}
+/**
+ * Create a new dunning step builder
+ */
+declare function step(id: string, name: string): DunningStepBuilder;
+/**
+ * Fluent builder for dunning sequences
+ */
+declare class DunningSequenceBuilder {
+    private sequence;
+    constructor(id: string, name: string);
+    /**
+     * Set description
+     */
+    describe(description: string): this;
+    /**
+     * Add steps
+     */
+    withSteps(...steps: DunningStep[]): this;
+    /**
+     * Set maximum duration before auto-cancel
+     */
+    maxDays(days: number): this;
+    /**
+     * Set active status
+     */
+    active(isActive?: boolean): this;
+    /**
+     * Add metadata
+     */
+    withMetadata(metadata: Record<string, unknown>): this;
+    /**
+     * Build the sequence
+     */
+    build(): DunningSequence;
+}
+/**
+ * Create a new dunning sequence builder
+ */
+declare function sequence(id: string, name: string): DunningSequenceBuilder;
+/**
+ * Standard SaaS dunning sequence (28 days)
+ *
+ * Day 0: Immediate retry + email notification
+ * Day 1: Retry + email reminder
+ * Day 3: Retry + email warning
+ * Day 7: Retry + email + in-app notification, limit features
+ * Day 14: Retry + email, suspend account
+ * Day 21: Final warning email
+ * Day 28: Cancel subscription
+ */
+declare const standardSaasSequence: DunningSequence;
+/**
+ * Aggressive dunning sequence (14 days)
+ * For lower-tier plans or high-risk customers
+ */
+declare const aggressiveSequence: DunningSequence;
+/**
+ * Lenient dunning sequence (45 days)
+ * For enterprise or high-value customers
+ */
+declare const lenientSequence: DunningSequence;
+/**
+ * Minimal dunning sequence (7 days)
+ * For free-to-paid conversions or trials
+ */
+declare const minimalSequence: DunningSequence;
+/**
+ * Default sequences by tier
+ */
+declare const defaultSequences: Record<string, DunningSequence>;
+/**
+ * Get sequence by tier level
+ *
+ * @param tier - Plan tier (0=free, 1=starter, 2=pro, 3=enterprise)
+ * @returns Appropriate dunning sequence
+ */
+declare function getSequenceByTier(tier: number): DunningSequence;
+
+/**
+ * @parsrun/payments - Payment Retry Strategy
+ * Smart retry logic based on payment failure codes
+ */
+
+/**
+ * Map provider error codes to failure categories
+ */
+interface ErrorCodeMapping {
+    provider: string;
+    codes: Record<string, PaymentFailureCategory>;
+}
+/**
+ * Stripe error code mappings
+ */
+declare const stripeErrorCodes: ErrorCodeMapping;
+/**
+ * Paddle error code mappings
+ */
+declare const paddleErrorCodes: ErrorCodeMapping;
+/**
+ * iyzico error code mappings
+ */
+declare const iyzicoErrorCodes: ErrorCodeMapping;
+/**
+ * All provider mappings
+ */
+declare const allErrorCodeMappings: ErrorCodeMapping[];
+/**
+ * Default retry strategies by failure category
+ */
+declare const defaultRetryStrategies: RetryStrategy[];
+/**
+ * Payment retry calculator
+ * Determines optimal retry timing based on failure category
+ */
+declare class PaymentRetryCalculator {
+    private strategies;
+    private errorMappings;
+    private logger?;
+    constructor(strategies?: RetryStrategy[], errorMappings?: ErrorCodeMapping[], logger?: DunningLogger);
+    /**
+     * Map error code to failure category
+     */
+    categorizeError(provider: string, errorCode: string): PaymentFailureCategory;
+    /**
+     * Get retry strategy for failure category
+     */
+    getStrategy(category: PaymentFailureCategory): RetryStrategy;
+    /**
+     * Check if a failure should be retried
+     */
+    shouldRetry(failure: PaymentFailure): boolean;
+    /**
+     * Calculate next retry time
+     */
+    calculateNextRetry(failure: PaymentFailure): Date | null;
+    /**
+     * Optimize retry time based on strategy
+     */
+    private optimizeRetryTime;
+    /**
+     * Find nearest value in array
+     */
+    private findNearestValue;
+    /**
+     * Check if failure is recoverable (can be retried eventually)
+     */
+    isRecoverable(category: PaymentFailureCategory): boolean;
+    /**
+     * Get recommendation message for failure category
+     */
+    getRecommendation(category: PaymentFailureCategory): string;
+}
+/**
+ * Payment retry handler configuration
+ */
+interface PaymentRetrierConfig {
+    /** Retry calculator */
+    calculator?: PaymentRetryCalculator;
+    /** Function to actually retry the payment */
+    retryPayment: (context: DunningContext) => Promise<RetryResult>;
+    /** Logger */
+    logger?: DunningLogger;
+    /** Maximum retries per dunning session */
+    maxSessionRetries?: number;
+}
+/**
+ * Payment retrier
+ * Handles intelligent payment retry logic
+ */
+declare class PaymentRetrier {
+    private calculator;
+    private retryPayment;
+    private logger?;
+    private maxSessionRetries;
+    constructor(config: PaymentRetrierConfig);
+    /**
+     * Attempt to retry a payment
+     */
+    retry(context: DunningContext): Promise<RetryResult>;
+    /**
+     * Get next retry time for a failure
+     */
+    getNextRetryTime(failure: PaymentFailure): Date | null;
+    /**
+     * Check if failure is recoverable
+     */
+    isRecoverable(failure: PaymentFailure): boolean;
+    /**
+     * Categorize an error code
+     */
+    categorizeError(provider: string, errorCode: string): PaymentFailureCategory;
+}
+/**
+ * Create a payment retry calculator
+ */
+declare function createPaymentRetryCalculator(strategies?: RetryStrategy[], errorMappings?: ErrorCodeMapping[], logger?: DunningLogger): PaymentRetryCalculator;
+/**
+ * Create a payment retrier
+ */
+declare function createPaymentRetrier(config: PaymentRetrierConfig): PaymentRetrier;
+
+/**
+ * @parsrun/payments - Dunning Manager
+ * Main orchestrator for dunning state management and step execution
+ */
+
+/**
+ * Dunning Manager
+ * Orchestrates the dunning process including state management and step execution
+ */
+declare class DunningManager {
+    private config;
+    private storage;
+    private eventHandlers;
+    private logger?;
+    constructor(config: DunningManagerConfig, storage: DunningStorage);
+    /**
+     * Start dunning process for a payment failure
+     */
+    startDunning(failure: PaymentFailure): Promise<DunningState>;
+    /**
+     * Execute the next step in dunning sequence
+     */
+    executeStep(stateId: string): Promise<ExecutedStep | null>;
+    /**
+     * Recover from dunning (payment successful)
+     */
+    recoverDunning(stateOrId: DunningState | string, reason?: "payment_recovered"): Promise<void>;
+    /**
+     * Pause dunning process
+     */
+    pauseDunning(stateId: string): Promise<void>;
+    /**
+     * Resume paused dunning
+     */
+    resumeDunning(stateId: string): Promise<void>;
+    /**
+     * Cancel dunning manually
+     */
+    cancelDunning(stateId: string, reason?: string): Promise<void>;
+    /**
+     * Get dunning state by customer ID
+     */
+    getDunningState(customerId: string): Promise<DunningState | null>;
+    /**
+     * Get dunning state by ID
+     */
+    getDunningStateById(stateId: string): Promise<DunningState | null>;
+    /**
+     * Get all active dunning states
+     */
+    getActiveDunningStates(): Promise<DunningState[]>;
+    /**
+     * Get dunning states by status
+     */
+    getDunningStatesByStatus(status: DunningStatus): Promise<DunningState[]>;
+    /**
+     * Get scheduled steps due for execution
+     */
+    getScheduledSteps(before: Date): Promise<Array<{
+        stateId: string;
+        stepId: string;
+        scheduledAt: Date;
+    }>>;
+    /**
+     * Register event handler
+     */
+    onEvent(handler: DunningEventHandler): this;
+    /**
+     * Emit dunning event
+     */
+    private emitEvent;
+    /**
+     * Perform step actions
+     */
+    private performStepActions;
+    /**
+     * Send notifications for a step
+     */
+    private sendNotifications;
+    /**
+     * Advance to next step
+     */
+    private advanceToNextStep;
+    /**
+     * Mark dunning as exhausted (all steps completed without recovery)
+     */
+    private exhaustDunning;
+    /**
+     * Build dunning context for step execution
+     */
+    private buildContext;
+    /**
+     * Calculate when a step should execute
+     */
+    private calculateStepTime;
+    /**
+     * Get sequence for a customer (by tier if configured)
+     */
+    private getSequenceForCustomer;
+    /**
+     * Get sequence by ID
+     */
+    private getSequence;
+    /**
+     * Generate unique ID
+     */
+    private generateId;
+}
+/**
+ * Create a dunning manager
+ */
+declare function createDunningManager(config: DunningManagerConfig, storage: DunningStorage): DunningManager;
+/**
+ * Create default dunning config
+ */
+declare function createDefaultDunningConfig(overrides?: Partial<DunningManagerConfig>): DunningManagerConfig;
+
+/**
+ * @parsrun/payments - Dunning Scheduler
+ * Automated scheduling and execution of dunning steps
+ */
+
+/**
+ * Dunning scheduler configuration
+ */
+interface DunningSchedulerConfig {
+    /** Dunning manager instance */
+    manager: DunningManager;
+    /** Poll interval in milliseconds (default: 60000 = 1 minute) */
+    pollInterval?: number;
+    /** Batch size for processing (default: 50) */
+    batchSize?: number;
+    /** Maximum concurrent executions (default: 5) */
+    maxConcurrent?: number;
+    /** Timezone for scheduling (default: UTC) */
+    timezone?: string;
+    /** Logger */
+    logger?: DunningLogger;
+    /** Error handler */
+    onError?: (error: Error, stateId: string) => void | Promise<void>;
+    /** Before step execution hook */
+    beforeStep?: (stateId: string, stepId: string) => void | Promise<void>;
+    /** After step execution hook */
+    afterStep?: (stateId: string, stepId: string, success: boolean) => void | Promise<void>;
+}
+/**
+ * Dunning Scheduler
+ * Handles automated execution of scheduled dunning steps
+ */
+declare class DunningScheduler {
+    private manager;
+    private pollInterval;
+    private batchSize;
+    private maxConcurrent;
+    private logger?;
+    private onError?;
+    private beforeStep?;
+    private afterStep?;
+    private isRunning;
+    private pollTimer?;
+    private processingStates;
+    /** Timezone for scheduling (reserved for future use) */
+    readonly timezone: string;
+    constructor(config: DunningSchedulerConfig);
+    /**
+     * Start the scheduler
+     */
+    start(): void;
+    /**
+     * Stop the scheduler
+     */
+    stop(): void;
+    /**
+     * Check if scheduler is running
+     */
+    get running(): boolean;
+    /**
+     * Get current processing count
+     */
+    get processingCount(): number;
+    /**
+     * Poll for scheduled steps
+     */
+    private poll;
+    /**
+     * Process all scheduled steps that are due
+     */
+    processScheduledSteps(): Promise<number>;
+    /**
+     * Execute a single scheduled step
+     */
+    private executeScheduledStep;
+    /**
+     * Manually trigger processing (for testing or cron jobs)
+     */
+    trigger(): Promise<number>;
+    /**
+     * Process a specific dunning state immediately
+     */
+    processNow(stateId: string): Promise<boolean>;
+    /**
+     * Split array into chunks
+     */
+    private chunk;
+}
+/**
+ * Create a dunning scheduler
+ */
+declare function createDunningScheduler(config: DunningSchedulerConfig): DunningScheduler;
+/**
+ * Create a cron-compatible handler for dunning processing
+ *
+ * @example
+ * ```typescript
+ * // In a cron job or serverless function
+ * export async function handler() {
+ *   const processor = createDunningCronHandler(manager);
+ *   const result = await processor();
+ *   console.log(`Processed ${result.processed} dunning steps`);
+ * }
+ * ```
+ */
+declare function createDunningCronHandler(manager: DunningManager, options?: {
+    batchSize?: number;
+    maxConcurrent?: number;
+    logger?: DunningLogger;
+}): () => Promise<{
+    processed: number;
+    errors: number;
+}>;
+/**
+ * Create a handler for edge/serverless environments
+ * Processes dunning in a single invocation
+ *
+ * @example
+ * ```typescript
+ * // In a Cloudflare Worker or similar
+ * export default {
+ *   async scheduled(event, env, ctx) {
+ *     const handler = createDunningEdgeHandler(manager, { maxDurationMs: 25000 });
+ *     const result = await handler();
+ *     console.log(result);
+ *   }
+ * }
+ * ```
+ */
+declare function createDunningEdgeHandler(manager: DunningManager, options?: {
+    maxDurationMs?: number;
+    batchSize?: number;
+    logger?: DunningLogger;
+}): () => Promise<{
+    processed: number;
+    errors: number;
+    duration: number;
+    timedOut: boolean;
+}>;
+
+/**
+ * @parsrun/payments - Dunning Memory Storage
+ * In-memory storage implementation for development and testing
+ */
+
+/**
+ * In-memory dunning storage implementation
+ * Use only for development/testing - data is lost on restart
+ */
+declare class MemoryDunningStorage implements DunningStorage {
+    private states;
+    private failures;
+    private scheduledSteps;
+    getDunningState(customerId: string): Promise<DunningState | null>;
+    getActiveDunningStates(): Promise<DunningState[]>;
+    getDunningStatesByStatus(status: DunningStatus): Promise<DunningState[]>;
+    saveDunningState(state: DunningState): Promise<void>;
+    updateDunningState(id: string, updates: Partial<DunningState>): Promise<void>;
+    recordPaymentFailure(failure: PaymentFailure): Promise<void>;
+    getPaymentFailures(customerId: string, limit?: number): Promise<PaymentFailure[]>;
+    getScheduledSteps(before: Date): Promise<Array<{
+        stateId: string;
+        stepId: string;
+        scheduledAt: Date;
+    }>>;
+    scheduleStep(stateId: string, stepId: string, scheduledAt: Date): Promise<void>;
+    removeScheduledStep(stateId: string, stepId: string): Promise<void>;
+    /**
+     * Clear all data (for testing)
+     */
+    clear(): void;
+    /**
+     * Get state by ID
+     */
+    getStateById(id: string): DunningState | undefined;
+    /**
+     * Get all states (for debugging)
+     */
+    getAllStates(): DunningState[];
+    /**
+     * Get all scheduled steps (for debugging)
+     */
+    getAllScheduledSteps(): Array<{
+        stateId: string;
+        stepId: string;
+        scheduledAt: Date;
+    }>;
+}
+/**
+ * Create an in-memory dunning storage instance
+ */
+declare function createMemoryDunningStorage(): MemoryDunningStorage;
+
+/**
+ * @parsrun/payments - Dunning Drizzle Storage
+ * Persistent storage implementation using Drizzle ORM
+ */
+
+type QueryBuilder = Promise<unknown[]> & {
+    where: (condition: unknown) => QueryBuilder;
+    orderBy: (...order: unknown[]) => QueryBuilder;
+    limit: (n: number) => QueryBuilder;
+};
+/**
+ * Drizzle database type (compatible with various drivers)
+ */
+type DrizzleDb = {
+    select: () => {
+        from: (table: unknown) => QueryBuilder;
+    };
+    insert: (table: unknown) => {
+        values: (values: unknown) => {
+            onConflictDoUpdate: (config: unknown) => Promise<unknown>;
+            returning: () => Promise<unknown[]>;
+        } & Promise<unknown>;
+    };
+    update: (table: unknown) => {
+        set: (values: unknown) => {
+            where: (condition: unknown) => Promise<unknown>;
+        };
+    };
+    delete: (table: unknown) => {
+        where: (condition: unknown) => Promise<unknown>;
+    };
+};
+/**
+ * Configuration for Drizzle dunning storage
+ */
+interface DrizzleDunningStorageConfig {
+    /** Drizzle database instance */
+    db: DrizzleDb;
+}
+/**
+ * Drizzle-based dunning storage implementation
+ */
+declare class DrizzleDunningStorage implements DunningStorage {
+    private db;
+    constructor(config: DrizzleDunningStorageConfig);
+    getDunningState(customerId: string): Promise<DunningState | null>;
+    getActiveDunningStates(): Promise<DunningState[]>;
+    getDunningStatesByStatus(status: DunningStatus): Promise<DunningState[]>;
+    saveDunningState(state: DunningState): Promise<void>;
+    updateDunningState(id: string, updates: Partial<DunningState>): Promise<void>;
+    recordPaymentFailure(failure: PaymentFailure): Promise<void>;
+    getPaymentFailures(customerId: string, limit?: number): Promise<PaymentFailure[]>;
+    getScheduledSteps(before: Date): Promise<Array<{
+        stateId: string;
+        stepId: string;
+        scheduledAt: Date;
+    }>>;
+    scheduleStep(stateId: string, stepId: string, scheduledAt: Date): Promise<void>;
+    removeScheduledStep(stateId: string, stepId: string): Promise<void>;
+    private saveExecutedStep;
+    private mapRowToState;
+    private mapRowToFailure;
+}
+/**
+ * Create a Drizzle dunning storage instance
+ */
+declare function createDrizzleDunningStorage(config: DrizzleDunningStorageConfig): DrizzleDunningStorage;
+
+/**
+ * @parsrun/payments - Dunning Database Schema
+ * Drizzle ORM schema for dunning automation tables
+ *
+ * These tables store:
+ * - Dunning sequences and steps
+ * - Dunning states for active processes
+ * - Payment failures
+ * - Executed steps history
+ * - Scheduled steps for automation
+ */
+/**
+ * Dunning sequences table - defines dunning workflows
+ */
+declare const dunningSequences: drizzle_orm_pg_core.PgTableWithColumns<{
+    name: "dunning_sequences";
+    schema: undefined;
+    columns: {
+        id: drizzle_orm_pg_core.PgColumn<{
+            name: "id";
+            tableName: "dunning_sequences";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        name: drizzle_orm_pg_core.PgColumn<{
+            name: "name";
+            tableName: "dunning_sequences";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        description: drizzle_orm_pg_core.PgColumn<{
+            name: "description";
+            tableName: "dunning_sequences";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        maxDurationDays: drizzle_orm_pg_core.PgColumn<{
+            name: "max_duration_days";
+            tableName: "dunning_sequences";
+            dataType: "number";
+            columnType: "PgInteger";
+            data: number;
+            driverParam: string | number;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        isActive: drizzle_orm_pg_core.PgColumn<{
+            name: "is_active";
+            tableName: "dunning_sequences";
+            dataType: "boolean";
+            columnType: "PgBoolean";
+            data: boolean;
+            driverParam: boolean;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        isDefault: drizzle_orm_pg_core.PgColumn<{
+            name: "is_default";
+            tableName: "dunning_sequences";
+            dataType: "boolean";
+            columnType: "PgBoolean";
+            data: boolean;
+            driverParam: boolean;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        planTier: drizzle_orm_pg_core.PgColumn<{
+            name: "plan_tier";
+            tableName: "dunning_sequences";
+            dataType: "number";
+            columnType: "PgInteger";
+            data: number;
+            driverParam: string | number;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        metadata: drizzle_orm_pg_core.PgColumn<{
+            name: "metadata";
+            tableName: "dunning_sequences";
+            dataType: "json";
+            columnType: "PgJsonb";
+            data: Record<string, unknown>;
+            driverParam: unknown;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            $type: Record<string, unknown>;
+        }>;
+        createdAt: drizzle_orm_pg_core.PgColumn<{
+            name: "created_at";
+            tableName: "dunning_sequences";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        updatedAt: drizzle_orm_pg_core.PgColumn<{
+            name: "updated_at";
+            tableName: "dunning_sequences";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+    };
+    dialect: "pg";
+}>;
+/**
+ * Dunning steps table - defines steps within sequences
+ */
+declare const dunningSteps: drizzle_orm_pg_core.PgTableWithColumns<{
+    name: "dunning_steps";
+    schema: undefined;
+    columns: {
+        id: drizzle_orm_pg_core.PgColumn<{
+            name: "id";
+            tableName: "dunning_steps";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        sequenceId: drizzle_orm_pg_core.PgColumn<{
+            name: "sequence_id";
+            tableName: "dunning_steps";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        name: drizzle_orm_pg_core.PgColumn<{
+            name: "name";
+            tableName: "dunning_steps";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        stepOrder: drizzle_orm_pg_core.PgColumn<{
+            name: "step_order";
+            tableName: "dunning_steps";
+            dataType: "number";
+            columnType: "PgInteger";
+            data: number;
+            driverParam: string | number;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        daysAfterFailure: drizzle_orm_pg_core.PgColumn<{
+            name: "days_after_failure";
+            tableName: "dunning_steps";
+            dataType: "number";
+            columnType: "PgInteger";
+            data: number;
+            driverParam: string | number;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        hoursOffset: drizzle_orm_pg_core.PgColumn<{
+            name: "hours_offset";
+            tableName: "dunning_steps";
+            dataType: "number";
+            columnType: "PgInteger";
+            data: number;
+            driverParam: string | number;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        actions: drizzle_orm_pg_core.PgColumn<{
+            name: "actions";
+            tableName: "dunning_steps";
+            dataType: "json";
+            columnType: "PgJsonb";
+            data: string[];
+            driverParam: unknown;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            $type: string[];
+        }>;
+        notificationChannels: drizzle_orm_pg_core.PgColumn<{
+            name: "notification_channels";
+            tableName: "dunning_steps";
+            dataType: "json";
+            columnType: "PgJsonb";
+            data: string[];
+            driverParam: unknown;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            $type: string[];
+        }>;
+        notificationTemplateId: drizzle_orm_pg_core.PgColumn<{
+            name: "notification_template_id";
+            tableName: "dunning_steps";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        accessLevel: drizzle_orm_pg_core.PgColumn<{
+            name: "access_level";
+            tableName: "dunning_steps";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        isFinal: drizzle_orm_pg_core.PgColumn<{
+            name: "is_final";
+            tableName: "dunning_steps";
+            dataType: "boolean";
+            columnType: "PgBoolean";
+            data: boolean;
+            driverParam: boolean;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        metadata: drizzle_orm_pg_core.PgColumn<{
+            name: "metadata";
+            tableName: "dunning_steps";
+            dataType: "json";
+            columnType: "PgJsonb";
+            data: Record<string, unknown>;
+            driverParam: unknown;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            $type: Record<string, unknown>;
+        }>;
+    };
+    dialect: "pg";
+}>;
+/**
+ * Payment failures table - records all payment failures
+ */
+declare const paymentFailures: drizzle_orm_pg_core.PgTableWithColumns<{
+    name: "dunning_payment_failures";
+    schema: undefined;
+    columns: {
+        id: drizzle_orm_pg_core.PgColumn<{
+            name: "id";
+            tableName: "dunning_payment_failures";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        customerId: drizzle_orm_pg_core.PgColumn<{
+            name: "customer_id";
+            tableName: "dunning_payment_failures";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        subscriptionId: drizzle_orm_pg_core.PgColumn<{
+            name: "subscription_id";
+            tableName: "dunning_payment_failures";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        invoiceId: drizzle_orm_pg_core.PgColumn<{
+            name: "invoice_id";
+            tableName: "dunning_payment_failures";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        amount: drizzle_orm_pg_core.PgColumn<{
+            name: "amount";
+            tableName: "dunning_payment_failures";
+            dataType: "number";
+            columnType: "PgInteger";
+            data: number;
+            driverParam: string | number;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        currency: drizzle_orm_pg_core.PgColumn<{
+            name: "currency";
+            tableName: "dunning_payment_failures";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        category: drizzle_orm_pg_core.PgColumn<{
+            name: "category";
+            tableName: "dunning_payment_failures";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        errorCode: drizzle_orm_pg_core.PgColumn<{
+            name: "error_code";
+            tableName: "dunning_payment_failures";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        errorMessage: drizzle_orm_pg_core.PgColumn<{
+            name: "error_message";
+            tableName: "dunning_payment_failures";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        provider: drizzle_orm_pg_core.PgColumn<{
+            name: "provider";
+            tableName: "dunning_payment_failures";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        failedAt: drizzle_orm_pg_core.PgColumn<{
+            name: "failed_at";
+            tableName: "dunning_payment_failures";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        retryCount: drizzle_orm_pg_core.PgColumn<{
+            name: "retry_count";
+            tableName: "dunning_payment_failures";
+            dataType: "number";
+            columnType: "PgInteger";
+            data: number;
+            driverParam: string | number;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        nextRetryAt: drizzle_orm_pg_core.PgColumn<{
+            name: "next_retry_at";
+            tableName: "dunning_payment_failures";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        isRecoverable: drizzle_orm_pg_core.PgColumn<{
+            name: "is_recoverable";
+            tableName: "dunning_payment_failures";
+            dataType: "boolean";
+            columnType: "PgBoolean";
+            data: boolean;
+            driverParam: boolean;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        metadata: drizzle_orm_pg_core.PgColumn<{
+            name: "metadata";
+            tableName: "dunning_payment_failures";
+            dataType: "json";
+            columnType: "PgJsonb";
+            data: Record<string, unknown>;
+            driverParam: unknown;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            $type: Record<string, unknown>;
+        }>;
+    };
+    dialect: "pg";
+}>;
+/**
+ * Dunning states table - tracks active dunning processes
+ */
+declare const dunningStates: drizzle_orm_pg_core.PgTableWithColumns<{
+    name: "dunning_states";
+    schema: undefined;
+    columns: {
+        id: drizzle_orm_pg_core.PgColumn<{
+            name: "id";
+            tableName: "dunning_states";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        customerId: drizzle_orm_pg_core.PgColumn<{
+            name: "customer_id";
+            tableName: "dunning_states";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        subscriptionId: drizzle_orm_pg_core.PgColumn<{
+            name: "subscription_id";
+            tableName: "dunning_states";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        sequenceId: drizzle_orm_pg_core.PgColumn<{
+            name: "sequence_id";
+            tableName: "dunning_states";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        currentStepIndex: drizzle_orm_pg_core.PgColumn<{
+            name: "current_step_index";
+            tableName: "dunning_states";
+            dataType: "number";
+            columnType: "PgInteger";
+            data: number;
+            driverParam: string | number;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        currentStepId: drizzle_orm_pg_core.PgColumn<{
+            name: "current_step_id";
+            tableName: "dunning_states";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        status: drizzle_orm_pg_core.PgColumn<{
+            name: "status";
+            tableName: "dunning_states";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        initialFailureId: drizzle_orm_pg_core.PgColumn<{
+            name: "initial_failure_id";
+            tableName: "dunning_states";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        failureIds: drizzle_orm_pg_core.PgColumn<{
+            name: "failure_ids";
+            tableName: "dunning_states";
+            dataType: "json";
+            columnType: "PgJsonb";
+            data: string[];
+            driverParam: unknown;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            $type: string[];
+        }>;
+        startedAt: drizzle_orm_pg_core.PgColumn<{
+            name: "started_at";
+            tableName: "dunning_states";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        lastStepAt: drizzle_orm_pg_core.PgColumn<{
+            name: "last_step_at";
+            tableName: "dunning_states";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        nextStepAt: drizzle_orm_pg_core.PgColumn<{
+            name: "next_step_at";
+            tableName: "dunning_states";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        endedAt: drizzle_orm_pg_core.PgColumn<{
+            name: "ended_at";
+            tableName: "dunning_states";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        endReason: drizzle_orm_pg_core.PgColumn<{
+            name: "end_reason";
+            tableName: "dunning_states";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        totalRetryAttempts: drizzle_orm_pg_core.PgColumn<{
+            name: "total_retry_attempts";
+            tableName: "dunning_states";
+            dataType: "number";
+            columnType: "PgInteger";
+            data: number;
+            driverParam: string | number;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        metadata: drizzle_orm_pg_core.PgColumn<{
+            name: "metadata";
+            tableName: "dunning_states";
+            dataType: "json";
+            columnType: "PgJsonb";
+            data: Record<string, unknown>;
+            driverParam: unknown;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            $type: Record<string, unknown>;
+        }>;
+    };
+    dialect: "pg";
+}>;
+/**
+ * Executed steps table - history of executed dunning steps
+ */
+declare const executedSteps: drizzle_orm_pg_core.PgTableWithColumns<{
+    name: "dunning_executed_steps";
+    schema: undefined;
+    columns: {
+        id: drizzle_orm_pg_core.PgColumn<{
+            name: "id";
+            tableName: "dunning_executed_steps";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        dunningStateId: drizzle_orm_pg_core.PgColumn<{
+            name: "dunning_state_id";
+            tableName: "dunning_executed_steps";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        stepId: drizzle_orm_pg_core.PgColumn<{
+            name: "step_id";
+            tableName: "dunning_executed_steps";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        stepName: drizzle_orm_pg_core.PgColumn<{
+            name: "step_name";
+            tableName: "dunning_executed_steps";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        executedAt: drizzle_orm_pg_core.PgColumn<{
+            name: "executed_at";
+            tableName: "dunning_executed_steps";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        actionsTaken: drizzle_orm_pg_core.PgColumn<{
+            name: "actions_taken";
+            tableName: "dunning_executed_steps";
+            dataType: "json";
+            columnType: "PgJsonb";
+            data: string[];
+            driverParam: unknown;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            $type: string[];
+        }>;
+        paymentRetried: drizzle_orm_pg_core.PgColumn<{
+            name: "payment_retried";
+            tableName: "dunning_executed_steps";
+            dataType: "boolean";
+            columnType: "PgBoolean";
+            data: boolean;
+            driverParam: boolean;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        paymentSucceeded: drizzle_orm_pg_core.PgColumn<{
+            name: "payment_succeeded";
+            tableName: "dunning_executed_steps";
+            dataType: "boolean";
+            columnType: "PgBoolean";
+            data: boolean;
+            driverParam: boolean;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        notificationsSent: drizzle_orm_pg_core.PgColumn<{
+            name: "notifications_sent";
+            tableName: "dunning_executed_steps";
+            dataType: "json";
+            columnType: "PgJsonb";
+            data: string[];
+            driverParam: unknown;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            $type: string[];
+        }>;
+        error: drizzle_orm_pg_core.PgColumn<{
+            name: "error";
+            tableName: "dunning_executed_steps";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        metadata: drizzle_orm_pg_core.PgColumn<{
+            name: "metadata";
+            tableName: "dunning_executed_steps";
+            dataType: "json";
+            columnType: "PgJsonb";
+            data: Record<string, unknown>;
+            driverParam: unknown;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            $type: Record<string, unknown>;
+        }>;
+    };
+    dialect: "pg";
+}>;
+/**
+ * Scheduled steps table - steps pending execution
+ */
+declare const scheduledSteps: drizzle_orm_pg_core.PgTableWithColumns<{
+    name: "dunning_scheduled_steps";
+    schema: undefined;
+    columns: {
+        id: drizzle_orm_pg_core.PgColumn<{
+            name: "id";
+            tableName: "dunning_scheduled_steps";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        dunningStateId: drizzle_orm_pg_core.PgColumn<{
+            name: "dunning_state_id";
+            tableName: "dunning_scheduled_steps";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        stepId: drizzle_orm_pg_core.PgColumn<{
+            name: "step_id";
+            tableName: "dunning_scheduled_steps";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        scheduledAt: drizzle_orm_pg_core.PgColumn<{
+            name: "scheduled_at";
+            tableName: "dunning_scheduled_steps";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        createdAt: drizzle_orm_pg_core.PgColumn<{
+            name: "created_at";
+            tableName: "dunning_scheduled_steps";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+    };
+    dialect: "pg";
+}>;
+/**
+ * Dunning events table - audit log for all dunning events
+ */
+declare const dunningEvents: drizzle_orm_pg_core.PgTableWithColumns<{
+    name: "dunning_events";
+    schema: undefined;
+    columns: {
+        id: drizzle_orm_pg_core.PgColumn<{
+            name: "id";
+            tableName: "dunning_events";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        type: drizzle_orm_pg_core.PgColumn<{
+            name: "type";
+            tableName: "dunning_events";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        customerId: drizzle_orm_pg_core.PgColumn<{
+            name: "customer_id";
+            tableName: "dunning_events";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        subscriptionId: drizzle_orm_pg_core.PgColumn<{
+            name: "subscription_id";
+            tableName: "dunning_events";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        dunningStateId: drizzle_orm_pg_core.PgColumn<{
+            name: "dunning_state_id";
+            tableName: "dunning_events";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        timestamp: drizzle_orm_pg_core.PgColumn<{
+            name: "timestamp";
+            tableName: "dunning_events";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        data: drizzle_orm_pg_core.PgColumn<{
+            name: "data";
+            tableName: "dunning_events";
+            dataType: "json";
+            columnType: "PgJsonb";
+            data: Record<string, unknown>;
+            driverParam: unknown;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            $type: Record<string, unknown>;
+        }>;
+    };
+    dialect: "pg";
+}>;
+/**
+ * Custom retry strategies table - overrides for default strategies
+ */
+declare const retryStrategies: drizzle_orm_pg_core.PgTableWithColumns<{
+    name: "dunning_retry_strategies";
+    schema: undefined;
+    columns: {
+        id: drizzle_orm_pg_core.PgColumn<{
+            name: "id";
+            tableName: "dunning_retry_strategies";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        category: drizzle_orm_pg_core.PgColumn<{
+            name: "category";
+            tableName: "dunning_retry_strategies";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        shouldRetry: drizzle_orm_pg_core.PgColumn<{
+            name: "should_retry";
+            tableName: "dunning_retry_strategies";
+            dataType: "boolean";
+            columnType: "PgBoolean";
+            data: boolean;
+            driverParam: boolean;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        initialDelayHours: drizzle_orm_pg_core.PgColumn<{
+            name: "initial_delay_hours";
+            tableName: "dunning_retry_strategies";
+            dataType: "number";
+            columnType: "PgInteger";
+            data: number;
+            driverParam: string | number;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        maxRetries: drizzle_orm_pg_core.PgColumn<{
+            name: "max_retries";
+            tableName: "dunning_retry_strategies";
+            dataType: "number";
+            columnType: "PgInteger";
+            data: number;
+            driverParam: string | number;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        backoffMultiplier: drizzle_orm_pg_core.PgColumn<{
+            name: "backoff_multiplier";
+            tableName: "dunning_retry_strategies";
+            dataType: "number";
+            columnType: "PgInteger";
+            data: number;
+            driverParam: string | number;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        maxDelayHours: drizzle_orm_pg_core.PgColumn<{
+            name: "max_delay_hours";
+            tableName: "dunning_retry_strategies";
+            dataType: "number";
+            columnType: "PgInteger";
+            data: number;
+            driverParam: string | number;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        optimalRetryHours: drizzle_orm_pg_core.PgColumn<{
+            name: "optimal_retry_hours";
+            tableName: "dunning_retry_strategies";
+            dataType: "json";
+            columnType: "PgJsonb";
+            data: number[];
+            driverParam: unknown;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            $type: number[];
+        }>;
+        optimalRetryDays: drizzle_orm_pg_core.PgColumn<{
+            name: "optimal_retry_days";
+            tableName: "dunning_retry_strategies";
+            dataType: "json";
+            columnType: "PgJsonb";
+            data: number[];
+            driverParam: unknown;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            $type: number[];
+        }>;
+        metadata: drizzle_orm_pg_core.PgColumn<{
+            name: "metadata";
+            tableName: "dunning_retry_strategies";
+            dataType: "json";
+            columnType: "PgJsonb";
+            data: Record<string, unknown>;
+            driverParam: unknown;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            $type: Record<string, unknown>;
+        }>;
+        updatedAt: drizzle_orm_pg_core.PgColumn<{
+            name: "updated_at";
+            tableName: "dunning_retry_strategies";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+    };
+    dialect: "pg";
+}>;
+type DunningSequenceRow = typeof dunningSequences.$inferSelect;
+type NewDunningSequence = typeof dunningSequences.$inferInsert;
+type DunningStepRow = typeof dunningSteps.$inferSelect;
+type NewDunningStep = typeof dunningSteps.$inferInsert;
+type PaymentFailureRow = typeof paymentFailures.$inferSelect;
+type NewPaymentFailure = typeof paymentFailures.$inferInsert;
+type DunningStateRow = typeof dunningStates.$inferSelect;
+type NewDunningState = typeof dunningStates.$inferInsert;
+type ExecutedStepRow = typeof executedSteps.$inferSelect;
+type NewExecutedStep = typeof executedSteps.$inferInsert;
+type ScheduledStepRow = typeof scheduledSteps.$inferSelect;
+type NewScheduledStep = typeof scheduledSteps.$inferInsert;
+type DunningEventRow = typeof dunningEvents.$inferSelect;
+type NewDunningEvent = typeof dunningEvents.$inferInsert;
+type RetryStrategyRow = typeof retryStrategies.$inferSelect;
+type NewRetryStrategy = typeof retryStrategies.$inferInsert;
+/**
+ * All dunning schema tables
+ */
+declare const dunningSchema: {
+    dunningSequences: drizzle_orm_pg_core.PgTableWithColumns<{
+        name: "dunning_sequences";
+        schema: undefined;
+        columns: {
+            id: drizzle_orm_pg_core.PgColumn<{
+                name: "id";
+                tableName: "dunning_sequences";
+                dataType: "string";
+                columnType: "PgText";
+                data: string;
+                driverParam: string;
+                notNull: true;
+                hasDefault: false;
+                isPrimaryKey: true;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: [string, ...string[]];
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
+            name: drizzle_orm_pg_core.PgColumn<{
+                name: "name";
+                tableName: "dunning_sequences";
+                dataType: "string";
+                columnType: "PgText";
+                data: string;
+                driverParam: string;
+                notNull: true;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: [string, ...string[]];
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
+            description: drizzle_orm_pg_core.PgColumn<{
+                name: "description";
+                tableName: "dunning_sequences";
+                dataType: "string";
+                columnType: "PgText";
+                data: string;
+                driverParam: string;
+                notNull: false;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: [string, ...string[]];
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
+            maxDurationDays: drizzle_orm_pg_core.PgColumn<{
+                name: "max_duration_days";
+                tableName: "dunning_sequences";
+                dataType: "number";
+                columnType: "PgInteger";
+                data: number;
+                driverParam: string | number;
+                notNull: true;
+                hasDefault: true;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: undefined;
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
+            isActive: drizzle_orm_pg_core.PgColumn<{
+                name: "is_active";
+                tableName: "dunning_sequences";
+                dataType: "boolean";
+                columnType: "PgBoolean";
+                data: boolean;
+                driverParam: boolean;
+                notNull: true;
+                hasDefault: true;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: undefined;
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
+            isDefault: drizzle_orm_pg_core.PgColumn<{
+                name: "is_default";
+                tableName: "dunning_sequences";
+                dataType: "boolean";
+                columnType: "PgBoolean";
+                data: boolean;
+                driverParam: boolean;
+                notNull: true;
+                hasDefault: true;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: undefined;
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
+            planTier: drizzle_orm_pg_core.PgColumn<{
+                name: "plan_tier";
+                tableName: "dunning_sequences";
+                dataType: "number";
+                columnType: "PgInteger";
+                data: number;
+                driverParam: string | number;
+                notNull: false;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: undefined;
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
+            metadata: drizzle_orm_pg_core.PgColumn<{
+                name: "metadata";
+                tableName: "dunning_sequences";
+                dataType: "json";
+                columnType: "PgJsonb";
+                data: Record<string, unknown>;
+                driverParam: unknown;
+                notNull: false;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: undefined;
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {
+                $type: Record<string, unknown>;
+            }>;
+            createdAt: drizzle_orm_pg_core.PgColumn<{
+                name: "created_at";
+                tableName: "dunning_sequences";
+                dataType: "date";
+                columnType: "PgTimestamp";
+                data: Date;
+                driverParam: string;
+                notNull: true;
+                hasDefault: true;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: undefined;
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
+            updatedAt: drizzle_orm_pg_core.PgColumn<{
+                name: "updated_at";
+                tableName: "dunning_sequences";
+                dataType: "date";
+                columnType: "PgTimestamp";
+                data: Date;
+                driverParam: string;
+                notNull: true;
+                hasDefault: true;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: undefined;
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
+        };
+        dialect: "pg";
+    }>;
+    dunningSteps: drizzle_orm_pg_core.PgTableWithColumns<{
+        name: "dunning_steps";
+        schema: undefined;
+        columns: {
+            id: drizzle_orm_pg_core.PgColumn<{
+                name: "id";
+                tableName: "dunning_steps";
+                dataType: "string";
+                columnType: "PgText";
+                data: string;
+                driverParam: string;
+                notNull: true;
+                hasDefault: false;
+                isPrimaryKey: true;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: [string, ...string[]];
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
+            sequenceId: drizzle_orm_pg_core.PgColumn<{
+                name: "sequence_id";
+                tableName: "dunning_steps";
+                dataType: "string";
+                columnType: "PgText";
+                data: string;
+                driverParam: string;
+                notNull: true;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: [string, ...string[]];
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
+            name: drizzle_orm_pg_core.PgColumn<{
+                name: "name";
+                tableName: "dunning_steps";
+                dataType: "string";
+                columnType: "PgText";
+                data: string;
+                driverParam: string;
+                notNull: true;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: [string, ...string[]];
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
+            stepOrder: drizzle_orm_pg_core.PgColumn<{
+                name: "step_order";
+                tableName: "dunning_steps";
+                dataType: "number";
+                columnType: "PgInteger";
+                data: number;
+                driverParam: string | number;
+                notNull: true;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: undefined;
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
+            daysAfterFailure: drizzle_orm_pg_core.PgColumn<{
+                name: "days_after_failure";
+                tableName: "dunning_steps";
+                dataType: "number";
+                columnType: "PgInteger";
+                data: number;
+                driverParam: string | number;
+                notNull: true;
+                hasDefault: true;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: undefined;
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
+            hoursOffset: drizzle_orm_pg_core.PgColumn<{
+                name: "hours_offset";
+                tableName: "dunning_steps";
+                dataType: "number";
+                columnType: "PgInteger";
+                data: number;
+                driverParam: string | number;
+                notNull: false;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: undefined;
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
+            actions: drizzle_orm_pg_core.PgColumn<{
+                name: "actions";
+                tableName: "dunning_steps";
+                dataType: "json";
+                columnType: "PgJsonb";
+                data: string[];
+                driverParam: unknown;
+                notNull: true;
+                hasDefault: true;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: undefined;
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {
+                $type: string[];
+            }>;
+            notificationChannels: drizzle_orm_pg_core.PgColumn<{
+                name: "notification_channels";
+                tableName: "dunning_steps";
+                dataType: "json";
+                columnType: "PgJsonb";
+                data: string[];
+                driverParam: unknown;
+                notNull: false;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: undefined;
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {
+                $type: string[];
+            }>;
+            notificationTemplateId: drizzle_orm_pg_core.PgColumn<{
+                name: "notification_template_id";
+                tableName: "dunning_steps";
+                dataType: "string";
+                columnType: "PgText";
+                data: string;
+                driverParam: string;
+                notNull: false;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: [string, ...string[]];
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
+            accessLevel: drizzle_orm_pg_core.PgColumn<{
+                name: "access_level";
+                tableName: "dunning_steps";
+                dataType: "string";
+                columnType: "PgText";
+                data: string;
+                driverParam: string;
+                notNull: false;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: [string, ...string[]];
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
+            isFinal: drizzle_orm_pg_core.PgColumn<{
+                name: "is_final";
+                tableName: "dunning_steps";
+                dataType: "boolean";
+                columnType: "PgBoolean";
+                data: boolean;
+                driverParam: boolean;
+                notNull: true;
+                hasDefault: true;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: undefined;
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
+            metadata: drizzle_orm_pg_core.PgColumn<{
+                name: "metadata";
+                tableName: "dunning_steps";
+                dataType: "json";
+                columnType: "PgJsonb";
+                data: Record<string, unknown>;
+                driverParam: unknown;
+                notNull: false;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: undefined;
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {
+                $type: Record<string, unknown>;
+            }>;
+        };
+        dialect: "pg";
+    }>;
+    paymentFailures: drizzle_orm_pg_core.PgTableWithColumns<{
+        name: "dunning_payment_failures";
+        schema: undefined;
+        columns: {
+            id: drizzle_orm_pg_core.PgColumn<{
+                name: "id";
+                tableName: "dunning_payment_failures";
+                dataType: "string";
+                columnType: "PgText";
+                data: string;
+                driverParam: string;
+                notNull: true;
+                hasDefault: false;
+                isPrimaryKey: true;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: [string, ...string[]];
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
+            customerId: drizzle_orm_pg_core.PgColumn<{
+                name: "customer_id";
+                tableName: "dunning_payment_failures";
+                dataType: "string";
+                columnType: "PgText";
+                data: string;
+                driverParam: string;
+                notNull: true;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: [string, ...string[]];
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
+            subscriptionId: drizzle_orm_pg_core.PgColumn<{
+                name: "subscription_id";
+                tableName: "dunning_payment_failures";
+                dataType: "string";
+                columnType: "PgText";
+                data: string;
+                driverParam: string;
+                notNull: true;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: [string, ...string[]];
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
+            invoiceId: drizzle_orm_pg_core.PgColumn<{
+                name: "invoice_id";
+                tableName: "dunning_payment_failures";
+                dataType: "string";
+                columnType: "PgText";
+                data: string;
+                driverParam: string;
+                notNull: false;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: [string, ...string[]];
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
+            amount: drizzle_orm_pg_core.PgColumn<{
+                name: "amount";
+                tableName: "dunning_payment_failures";
+                dataType: "number";
+                columnType: "PgInteger";
+                data: number;
+                driverParam: string | number;
+                notNull: true;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: undefined;
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
+            currency: drizzle_orm_pg_core.PgColumn<{
+                name: "currency";
+                tableName: "dunning_payment_failures";
+                dataType: "string";
+                columnType: "PgText";
+                data: string;
+                driverParam: string;
+                notNull: true;
+                hasDefault: true;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: [string, ...string[]];
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
+            category: drizzle_orm_pg_core.PgColumn<{
+                name: "category";
+                tableName: "dunning_payment_failures";
+                dataType: "string";
+                columnType: "PgText";
+                data: string;
+                driverParam: string;
+                notNull: true;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: [string, ...string[]];
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
+            errorCode: drizzle_orm_pg_core.PgColumn<{
+                name: "error_code";
+                tableName: "dunning_payment_failures";
+                dataType: "string";
+                columnType: "PgText";
+                data: string;
+                driverParam: string;
+                notNull: true;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: [string, ...string[]];
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
+            errorMessage: drizzle_orm_pg_core.PgColumn<{
+                name: "error_message";
+                tableName: "dunning_payment_failures";
+                dataType: "string";
+                columnType: "PgText";
+                data: string;
+                driverParam: string;
+                notNull: true;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: [string, ...string[]];
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
+            provider: drizzle_orm_pg_core.PgColumn<{
+                name: "provider";
+                tableName: "dunning_payment_failures";
+                dataType: "string";
+                columnType: "PgText";
+                data: string;
+                driverParam: string;
+                notNull: true;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: [string, ...string[]];
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
+            failedAt: drizzle_orm_pg_core.PgColumn<{
+                name: "failed_at";
+                tableName: "dunning_payment_failures";
+                dataType: "date";
+                columnType: "PgTimestamp";
+                data: Date;
+                driverParam: string;
+                notNull: true;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: undefined;
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
+            retryCount: drizzle_orm_pg_core.PgColumn<{
+                name: "retry_count";
+                tableName: "dunning_payment_failures";
+                dataType: "number";
+                columnType: "PgInteger";
+                data: number;
+                driverParam: string | number;
+                notNull: true;
+                hasDefault: true;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: undefined;
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
+            nextRetryAt: drizzle_orm_pg_core.PgColumn<{
+                name: "next_retry_at";
+                tableName: "dunning_payment_failures";
+                dataType: "date";
+                columnType: "PgTimestamp";
+                data: Date;
+                driverParam: string;
+                notNull: false;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: undefined;
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
+            isRecoverable: drizzle_orm_pg_core.PgColumn<{
+                name: "is_recoverable";
+                tableName: "dunning_payment_failures";
+                dataType: "boolean";
+                columnType: "PgBoolean";
+                data: boolean;
+                driverParam: boolean;
+                notNull: true;
+                hasDefault: true;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: undefined;
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
+            metadata: drizzle_orm_pg_core.PgColumn<{
+                name: "metadata";
+                tableName: "dunning_payment_failures";
+                dataType: "json";
+                columnType: "PgJsonb";
+                data: Record<string, unknown>;
+                driverParam: unknown;
+                notNull: false;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: undefined;
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {
+                $type: Record<string, unknown>;
+            }>;
+        };
+        dialect: "pg";
+    }>;
+    dunningStates: drizzle_orm_pg_core.PgTableWithColumns<{
+        name: "dunning_states";
+        schema: undefined;
+        columns: {
+            id: drizzle_orm_pg_core.PgColumn<{
+                name: "id";
+                tableName: "dunning_states";
+                dataType: "string";
+                columnType: "PgText";
+                data: string;
+                driverParam: string;
+                notNull: true;
+                hasDefault: false;
+                isPrimaryKey: true;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: [string, ...string[]];
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
+            customerId: drizzle_orm_pg_core.PgColumn<{
+                name: "customer_id";
+                tableName: "dunning_states";
+                dataType: "string";
+                columnType: "PgText";
+                data: string;
+                driverParam: string;
+                notNull: true;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: [string, ...string[]];
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
+            subscriptionId: drizzle_orm_pg_core.PgColumn<{
+                name: "subscription_id";
+                tableName: "dunning_states";
+                dataType: "string";
+                columnType: "PgText";
+                data: string;
+                driverParam: string;
+                notNull: true;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: [string, ...string[]];
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
+            sequenceId: drizzle_orm_pg_core.PgColumn<{
+                name: "sequence_id";
+                tableName: "dunning_states";
+                dataType: "string";
+                columnType: "PgText";
+                data: string;
+                driverParam: string;
+                notNull: true;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: [string, ...string[]];
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
+            currentStepIndex: drizzle_orm_pg_core.PgColumn<{
+                name: "current_step_index";
+                tableName: "dunning_states";
+                dataType: "number";
+                columnType: "PgInteger";
+                data: number;
+                driverParam: string | number;
+                notNull: true;
+                hasDefault: true;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: undefined;
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
+            currentStepId: drizzle_orm_pg_core.PgColumn<{
+                name: "current_step_id";
+                tableName: "dunning_states";
+                dataType: "string";
+                columnType: "PgText";
+                data: string;
+                driverParam: string;
+                notNull: true;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: [string, ...string[]];
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
+            status: drizzle_orm_pg_core.PgColumn<{
+                name: "status";
+                tableName: "dunning_states";
+                dataType: "string";
+                columnType: "PgText";
+                data: string;
+                driverParam: string;
+                notNull: true;
+                hasDefault: true;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: [string, ...string[]];
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
+            initialFailureId: drizzle_orm_pg_core.PgColumn<{
+                name: "initial_failure_id";
+                tableName: "dunning_states";
+                dataType: "string";
+                columnType: "PgText";
+                data: string;
+                driverParam: string;
+                notNull: true;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: [string, ...string[]];
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
+            failureIds: drizzle_orm_pg_core.PgColumn<{
+                name: "failure_ids";
+                tableName: "dunning_states";
+                dataType: "json";
+                columnType: "PgJsonb";
+                data: string[];
+                driverParam: unknown;
+                notNull: true;
+                hasDefault: true;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: undefined;
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {
+                $type: string[];
+            }>;
+            startedAt: drizzle_orm_pg_core.PgColumn<{
+                name: "started_at";
+                tableName: "dunning_states";
+                dataType: "date";
+                columnType: "PgTimestamp";
+                data: Date;
+                driverParam: string;
+                notNull: true;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: undefined;
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
+            lastStepAt: drizzle_orm_pg_core.PgColumn<{
+                name: "last_step_at";
+                tableName: "dunning_states";
+                dataType: "date";
+                columnType: "PgTimestamp";
+                data: Date;
+                driverParam: string;
+                notNull: false;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: undefined;
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
+            nextStepAt: drizzle_orm_pg_core.PgColumn<{
+                name: "next_step_at";
+                tableName: "dunning_states";
+                dataType: "date";
+                columnType: "PgTimestamp";
+                data: Date;
+                driverParam: string;
+                notNull: false;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: undefined;
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
+            endedAt: drizzle_orm_pg_core.PgColumn<{
+                name: "ended_at";
+                tableName: "dunning_states";
+                dataType: "date";
+                columnType: "PgTimestamp";
+                data: Date;
+                driverParam: string;
+                notNull: false;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: undefined;
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
+            endReason: drizzle_orm_pg_core.PgColumn<{
+                name: "end_reason";
+                tableName: "dunning_states";
+                dataType: "string";
+                columnType: "PgText";
+                data: string;
+                driverParam: string;
+                notNull: false;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: [string, ...string[]];
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
+            totalRetryAttempts: drizzle_orm_pg_core.PgColumn<{
+                name: "total_retry_attempts";
+                tableName: "dunning_states";
+                dataType: "number";
+                columnType: "PgInteger";
+                data: number;
+                driverParam: string | number;
+                notNull: true;
+                hasDefault: true;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: undefined;
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
+            metadata: drizzle_orm_pg_core.PgColumn<{
+                name: "metadata";
+                tableName: "dunning_states";
+                dataType: "json";
+                columnType: "PgJsonb";
+                data: Record<string, unknown>;
+                driverParam: unknown;
+                notNull: false;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: undefined;
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {
+                $type: Record<string, unknown>;
+            }>;
+        };
+        dialect: "pg";
+    }>;
+    executedSteps: drizzle_orm_pg_core.PgTableWithColumns<{
+        name: "dunning_executed_steps";
+        schema: undefined;
+        columns: {
+            id: drizzle_orm_pg_core.PgColumn<{
+                name: "id";
+                tableName: "dunning_executed_steps";
+                dataType: "string";
+                columnType: "PgText";
+                data: string;
+                driverParam: string;
+                notNull: true;
+                hasDefault: false;
+                isPrimaryKey: true;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: [string, ...string[]];
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
+            dunningStateId: drizzle_orm_pg_core.PgColumn<{
+                name: "dunning_state_id";
+                tableName: "dunning_executed_steps";
+                dataType: "string";
+                columnType: "PgText";
+                data: string;
+                driverParam: string;
+                notNull: true;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: [string, ...string[]];
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
+            stepId: drizzle_orm_pg_core.PgColumn<{
+                name: "step_id";
+                tableName: "dunning_executed_steps";
+                dataType: "string";
+                columnType: "PgText";
+                data: string;
+                driverParam: string;
+                notNull: true;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: [string, ...string[]];
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
+            stepName: drizzle_orm_pg_core.PgColumn<{
+                name: "step_name";
+                tableName: "dunning_executed_steps";
+                dataType: "string";
+                columnType: "PgText";
+                data: string;
+                driverParam: string;
+                notNull: true;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: [string, ...string[]];
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
+            executedAt: drizzle_orm_pg_core.PgColumn<{
+                name: "executed_at";
+                tableName: "dunning_executed_steps";
+                dataType: "date";
+                columnType: "PgTimestamp";
+                data: Date;
+                driverParam: string;
+                notNull: true;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: undefined;
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
+            actionsTaken: drizzle_orm_pg_core.PgColumn<{
+                name: "actions_taken";
+                tableName: "dunning_executed_steps";
+                dataType: "json";
+                columnType: "PgJsonb";
+                data: string[];
+                driverParam: unknown;
+                notNull: true;
+                hasDefault: true;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: undefined;
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {
+                $type: string[];
+            }>;
+            paymentRetried: drizzle_orm_pg_core.PgColumn<{
+                name: "payment_retried";
+                tableName: "dunning_executed_steps";
+                dataType: "boolean";
+                columnType: "PgBoolean";
+                data: boolean;
+                driverParam: boolean;
+                notNull: true;
+                hasDefault: true;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: undefined;
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
+            paymentSucceeded: drizzle_orm_pg_core.PgColumn<{
+                name: "payment_succeeded";
+                tableName: "dunning_executed_steps";
+                dataType: "boolean";
+                columnType: "PgBoolean";
+                data: boolean;
+                driverParam: boolean;
+                notNull: false;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: undefined;
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
+            notificationsSent: drizzle_orm_pg_core.PgColumn<{
+                name: "notifications_sent";
+                tableName: "dunning_executed_steps";
+                dataType: "json";
+                columnType: "PgJsonb";
+                data: string[];
+                driverParam: unknown;
+                notNull: true;
+                hasDefault: true;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: undefined;
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {
+                $type: string[];
+            }>;
+            error: drizzle_orm_pg_core.PgColumn<{
+                name: "error";
+                tableName: "dunning_executed_steps";
+                dataType: "string";
+                columnType: "PgText";
+                data: string;
+                driverParam: string;
+                notNull: false;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: [string, ...string[]];
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
+            metadata: drizzle_orm_pg_core.PgColumn<{
+                name: "metadata";
+                tableName: "dunning_executed_steps";
+                dataType: "json";
+                columnType: "PgJsonb";
+                data: Record<string, unknown>;
+                driverParam: unknown;
+                notNull: false;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: undefined;
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {
+                $type: Record<string, unknown>;
+            }>;
+        };
+        dialect: "pg";
+    }>;
+    scheduledSteps: drizzle_orm_pg_core.PgTableWithColumns<{
+        name: "dunning_scheduled_steps";
+        schema: undefined;
+        columns: {
+            id: drizzle_orm_pg_core.PgColumn<{
+                name: "id";
+                tableName: "dunning_scheduled_steps";
+                dataType: "string";
+                columnType: "PgText";
+                data: string;
+                driverParam: string;
+                notNull: true;
+                hasDefault: false;
+                isPrimaryKey: true;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: [string, ...string[]];
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
+            dunningStateId: drizzle_orm_pg_core.PgColumn<{
+                name: "dunning_state_id";
+                tableName: "dunning_scheduled_steps";
+                dataType: "string";
+                columnType: "PgText";
+                data: string;
+                driverParam: string;
+                notNull: true;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: [string, ...string[]];
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
+            stepId: drizzle_orm_pg_core.PgColumn<{
+                name: "step_id";
+                tableName: "dunning_scheduled_steps";
+                dataType: "string";
+                columnType: "PgText";
+                data: string;
+                driverParam: string;
+                notNull: true;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: [string, ...string[]];
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
+            scheduledAt: drizzle_orm_pg_core.PgColumn<{
+                name: "scheduled_at";
+                tableName: "dunning_scheduled_steps";
+                dataType: "date";
+                columnType: "PgTimestamp";
+                data: Date;
+                driverParam: string;
+                notNull: true;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: undefined;
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
+            createdAt: drizzle_orm_pg_core.PgColumn<{
+                name: "created_at";
+                tableName: "dunning_scheduled_steps";
+                dataType: "date";
+                columnType: "PgTimestamp";
+                data: Date;
+                driverParam: string;
+                notNull: true;
+                hasDefault: true;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: undefined;
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
+        };
+        dialect: "pg";
+    }>;
+    dunningEvents: drizzle_orm_pg_core.PgTableWithColumns<{
+        name: "dunning_events";
+        schema: undefined;
+        columns: {
+            id: drizzle_orm_pg_core.PgColumn<{
+                name: "id";
+                tableName: "dunning_events";
+                dataType: "string";
+                columnType: "PgText";
+                data: string;
+                driverParam: string;
+                notNull: true;
+                hasDefault: false;
+                isPrimaryKey: true;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: [string, ...string[]];
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
+            type: drizzle_orm_pg_core.PgColumn<{
+                name: "type";
+                tableName: "dunning_events";
+                dataType: "string";
+                columnType: "PgText";
+                data: string;
+                driverParam: string;
+                notNull: true;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: [string, ...string[]];
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
+            customerId: drizzle_orm_pg_core.PgColumn<{
+                name: "customer_id";
+                tableName: "dunning_events";
+                dataType: "string";
+                columnType: "PgText";
+                data: string;
+                driverParam: string;
+                notNull: true;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: [string, ...string[]];
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
+            subscriptionId: drizzle_orm_pg_core.PgColumn<{
+                name: "subscription_id";
+                tableName: "dunning_events";
+                dataType: "string";
+                columnType: "PgText";
+                data: string;
+                driverParam: string;
+                notNull: true;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: [string, ...string[]];
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
+            dunningStateId: drizzle_orm_pg_core.PgColumn<{
+                name: "dunning_state_id";
+                tableName: "dunning_events";
+                dataType: "string";
+                columnType: "PgText";
+                data: string;
+                driverParam: string;
+                notNull: true;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: [string, ...string[]];
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
+            timestamp: drizzle_orm_pg_core.PgColumn<{
+                name: "timestamp";
+                tableName: "dunning_events";
+                dataType: "date";
+                columnType: "PgTimestamp";
+                data: Date;
+                driverParam: string;
+                notNull: true;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: undefined;
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
+            data: drizzle_orm_pg_core.PgColumn<{
+                name: "data";
+                tableName: "dunning_events";
+                dataType: "json";
+                columnType: "PgJsonb";
+                data: Record<string, unknown>;
+                driverParam: unknown;
+                notNull: true;
+                hasDefault: true;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: undefined;
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {
+                $type: Record<string, unknown>;
+            }>;
+        };
+        dialect: "pg";
+    }>;
+    retryStrategies: drizzle_orm_pg_core.PgTableWithColumns<{
+        name: "dunning_retry_strategies";
+        schema: undefined;
+        columns: {
+            id: drizzle_orm_pg_core.PgColumn<{
+                name: "id";
+                tableName: "dunning_retry_strategies";
+                dataType: "string";
+                columnType: "PgText";
+                data: string;
+                driverParam: string;
+                notNull: true;
+                hasDefault: false;
+                isPrimaryKey: true;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: [string, ...string[]];
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
+            category: drizzle_orm_pg_core.PgColumn<{
+                name: "category";
+                tableName: "dunning_retry_strategies";
+                dataType: "string";
+                columnType: "PgText";
+                data: string;
+                driverParam: string;
+                notNull: true;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: [string, ...string[]];
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
+            shouldRetry: drizzle_orm_pg_core.PgColumn<{
+                name: "should_retry";
+                tableName: "dunning_retry_strategies";
+                dataType: "boolean";
+                columnType: "PgBoolean";
+                data: boolean;
+                driverParam: boolean;
+                notNull: true;
+                hasDefault: true;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: undefined;
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
+            initialDelayHours: drizzle_orm_pg_core.PgColumn<{
+                name: "initial_delay_hours";
+                tableName: "dunning_retry_strategies";
+                dataType: "number";
+                columnType: "PgInteger";
+                data: number;
+                driverParam: string | number;
+                notNull: true;
+                hasDefault: true;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: undefined;
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
+            maxRetries: drizzle_orm_pg_core.PgColumn<{
+                name: "max_retries";
+                tableName: "dunning_retry_strategies";
+                dataType: "number";
+                columnType: "PgInteger";
+                data: number;
+                driverParam: string | number;
+                notNull: true;
+                hasDefault: true;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: undefined;
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
+            backoffMultiplier: drizzle_orm_pg_core.PgColumn<{
+                name: "backoff_multiplier";
+                tableName: "dunning_retry_strategies";
+                dataType: "number";
+                columnType: "PgInteger";
+                data: number;
+                driverParam: string | number;
+                notNull: true;
+                hasDefault: true;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: undefined;
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
+            maxDelayHours: drizzle_orm_pg_core.PgColumn<{
+                name: "max_delay_hours";
+                tableName: "dunning_retry_strategies";
+                dataType: "number";
+                columnType: "PgInteger";
+                data: number;
+                driverParam: string | number;
+                notNull: true;
+                hasDefault: true;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: undefined;
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
+            optimalRetryHours: drizzle_orm_pg_core.PgColumn<{
+                name: "optimal_retry_hours";
+                tableName: "dunning_retry_strategies";
+                dataType: "json";
+                columnType: "PgJsonb";
+                data: number[];
+                driverParam: unknown;
+                notNull: false;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: undefined;
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {
+                $type: number[];
+            }>;
+            optimalRetryDays: drizzle_orm_pg_core.PgColumn<{
+                name: "optimal_retry_days";
+                tableName: "dunning_retry_strategies";
+                dataType: "json";
+                columnType: "PgJsonb";
+                data: number[];
+                driverParam: unknown;
+                notNull: false;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: undefined;
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {
+                $type: number[];
+            }>;
+            metadata: drizzle_orm_pg_core.PgColumn<{
+                name: "metadata";
+                tableName: "dunning_retry_strategies";
+                dataType: "json";
+                columnType: "PgJsonb";
+                data: Record<string, unknown>;
+                driverParam: unknown;
+                notNull: false;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: undefined;
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {
+                $type: Record<string, unknown>;
+            }>;
+            updatedAt: drizzle_orm_pg_core.PgColumn<{
+                name: "updated_at";
+                tableName: "dunning_retry_strategies";
+                dataType: "date";
+                columnType: "PgTimestamp";
+                data: Date;
+                driverParam: string;
+                notNull: true;
+                hasDefault: true;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: undefined;
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
+        };
+        dialect: "pg";
+    }>;
+};
+
+export { type PaymentRetrierConfig as $, createDrizzleDunningStorage as A, dunningSchema as B, type PaymentFailureCategory as C, DunningManager as D, type PaymentFailure as E, type DunningAction as F, type DunningStep as G, type DunningSequence as H, type DunningStatus as I, type DunningState as J, type ExecutedStep as K, type DunningContext as L, MemoryDunningStorage as M, type NotificationChannel as N, type RetryResult as O, PaymentRetryCalculator as P, type DunningNotification as Q, type RetryStrategy as R, type NotificationResult as S, type DunningEventType as T, type DunningEvent as U, type DunningEventHandler as V, type DunningManagerConfig as W, type DunningLogger as X, type DunningStorage as Y, type DunningSchedulerConfig as Z, type ErrorCodeMapping as _, createDefaultDunningConfig as a, type DrizzleDunningStorageConfig as a0, type DunningSequenceRow as a1, type NewDunningSequence as a2, type DunningStepRow as a3, type NewDunningStep as a4, type PaymentFailureRow as a5, type NewPaymentFailure as a6, type DunningStateRow as a7, type NewDunningState as a8, type ExecutedStepRow as a9, type NewExecutedStep as aa, type ScheduledStepRow as ab, type NewScheduledStep as ac, type DunningEventRow as ad, type NewDunningEvent as ae, type RetryStrategyRow as af, type NewRetryStrategy as ag, type DrizzleDb as ah, dunningSequences as ai, dunningSteps as aj, paymentFailures as ak, dunningStates as al, executedSteps as am, scheduledSteps as an, dunningEvents as ao, retryStrategies as ap, DunningScheduler as b, createDunningManager as c, createDunningScheduler as d, createDunningCronHandler as e, createDunningEdgeHandler as f, DunningStepBuilder as g, DunningSequenceBuilder as h, sequence as i, standardSaasSequence as j, aggressiveSequence as k, lenientSequence as l, minimalSequence as m, defaultSequences as n, getSequenceByTier as o, PaymentRetrier as p, createPaymentRetryCalculator as q, createPaymentRetrier as r, step as s, defaultRetryStrategies as t, stripeErrorCodes as u, paddleErrorCodes as v, iyzicoErrorCodes as w, allErrorCodeMappings as x, createMemoryDunningStorage as y, DrizzleDunningStorage as z };