kotak-payment-gateway/index.d.ts

Kotak Bank Payment Gateway - Automated payment verification using bank statement scraping

declare module 'kotak-payment-gateway' {
  import { EventEmitter } from 'events';
  
  export interface PaymentGatewayOptions {
    kotakUsername: string;
    kotakPassword: string;
    email: string;
    emailPassword: string;
    mongoUrl: string;
    autoUpdate?: boolean;
    updateFrequency?: 'hourly' | 'daily' | '6hours' | '30min' | '15min' | '5min' | '1min';
    headless?: boolean;
    defaultPaymentTimeout?: number;
  }
  
  export interface PaymentData {
    orderId: string;
    amount: number;
    customerInfo?: Record<string, any>;
    metadata?: Record<string, any>;
    timeout?: number;
  }
  
  export interface Payment {
    orderId: string;
    amount: number;
    status: 'pending' | 'verified' | 'expired' | 'cancelled' | 'failed';
    customerInfo: Record<string, any>;
    metadata: Record<string, any>;
    createdAt: Date;
    expiresAt: Date;
    verificationAttempts: number;
    lastVerificationAt?: Date;
    verifiedAt?: Date;
  }
  
  export interface Transaction {
    _id: string;
    transactionDate: Date;
    valueDate: Date;
    description: string;
    refNo: string;
    amount: number;
    type: 'DR' | 'CR';
    balance: number;
    balanceType: 'DR' | 'CR';
    orderId: string | null;
    accountNo: string;
    createdAt: Date;
    updatedAt: Date;
  }
  
  export interface VerificationResult {
    verified: boolean;
    orderId: string;
    amount: number;
    transaction: Transaction | null;
    transactionId?: string;
    source: 'database' | 'fresh_download' | 'not_found' | 'database_by_transaction_id' | 'concurrent_download_by_transaction_id' | 'fresh_download_by_transaction_id' | 'concurrent_download';
    verificationMethod?: 'order_id' | 'transaction_id';
  }
  
  export interface UpdateResult {
    success: boolean;
    transactionsProcessed?: number;
    timestamp?: Date;
    processedAt?: Date;
    error?: string;
  }
  
  export interface TransactionFilters {
    orderId?: string;
    amount?: number;
    type?: 'DR' | 'CR';
    dateFrom?: Date | string;
    dateTo?: Date | string;
    limit?: number;
  }
  
  export interface PaymentStats {
    totalPayments: number;
    pendingPayments: number;
    verifiedPayments: number;
    expiredPayments: number;
    totalTransactions: number;
    successRate: string;
    pendingInMemory?: number;
  }
  
  export interface TransactionProcessedEvent {
    count: number;
    transactions: Transaction[];
    processedAt: Date;
  }
  
  export interface PaymentStatusChangeEvent {
    orderId: string;
    oldStatus: string;
    newStatus: string;
    timestamp: Date;
    metadata?: Record<string, any>;
  }
  
  export interface PaymentVerificationEvent {
    orderId: string;
    amount: number;
    verified: boolean;
    transaction?: Transaction;
    timestamp: Date;
    verificationMethod?: string;
  }
  
  export default class KotakPaymentGateway extends EventEmitter {
    constructor(options: PaymentGatewayOptions);
    
    init(): Promise<void>;
    
    createPayment(paymentData: PaymentData): Promise<Payment>;
    
    verifyPayment(orderId: string, amount: number, transactionId?: string): Promise<VerificationResult>;
    
    getPaymentStatus(orderId: string): Promise<Payment | null>;
    
    cancelPayment(orderId: string): Promise<boolean>;
    
    getPendingPayments(): Payment[];
    
    downloadStatements(): Promise<boolean>;
    
    processLatestCSV(): Promise<number>;
    
    getTransactionHistory(filters?: TransactionFilters): Promise<Transaction[]>;
    
    forceUpdate(): Promise<UpdateResult>;
    
    getStats(): Promise<PaymentStats | null>;
    
    startAutoUpdate(): void;
    
    stopAutoUpdate(): void;
    
    close(): Promise<void>;
    
    // Additional utility methods
    getPendingCount?(): number;
    isInitialized?(): boolean;
    getConfig?(): Partial<PaymentGatewayOptions>;
    
    // Event definitions
    on(event: 'ready', listener: () => void): this;
    on(event: 'payment.created', listener: (payment: Payment) => void): this;
    on(event: 'payment.verified', listener: (data: PaymentVerificationEvent) => void): this;
    on(event: 'payment.expired', listener: (data: PaymentStatusChangeEvent) => void): this;
    on(event: 'payment.cancelled', listener: (data: PaymentStatusChangeEvent) => void): this;
    on(event: 'payment.status_changed', listener: (data: PaymentStatusChangeEvent) => void): this;
    on(event: 'transactions.processed', listener: (data: TransactionProcessedEvent) => void): this;
    
    emit(event: 'ready'): boolean;
    emit(event: 'payment.created', payment: Payment): boolean;
    emit(event: 'payment.verified', data: PaymentVerificationEvent): boolean;
    emit(event: 'payment.expired', data: PaymentStatusChangeEvent): boolean;
    emit(event: 'payment.cancelled', data: PaymentStatusChangeEvent): boolean;
    emit(event: 'payment.status_changed', data: PaymentStatusChangeEvent): boolean;
    emit(event: 'transactions.processed', data: TransactionProcessedEvent): boolean;
  }
}