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 };