@plyaz/types 1.11.4 → 1.12.1

package/dist/payments/provider/payment-provider/types.d.ts

@@ -0,0 +1,269 @@
+import type { ProviderHealthStatus } from '../../../features';
+import type { CURRENCY } from '../../currency';
+import type { PaymentResult, ProcessPaymentRequest } from '../../request';
+import type { FeeBreakdown, Money } from '../../transaction';
+import type { CreateCustomerParams, CustomerResult, FeeCalculationOptions, PaymentProviderConfig, PaymentStatusResult, RefundParams, RefundResult, SavedPaymentMethodResult, SavePaymentMethodParams, TransactionHistory, TransactionHistoryParams, WebhookPayload, WebhookResult } from '../core';
+import type { PAYMENTMETHOD, PAYMENTPROVIDERTYPE } from '../provider-capability';
+/**
+ * Core interface that all payment providers must implement.
+ * This interface ensures consistent behavior across all providers
+ * while allowing for provider-specific capabilities and optimizations.
+ *
+ * Implementation Requirements:
+ * - All methods must be implemented (use NotImplementedError for unsupported features)
+ * - All operations must be idempotent where possible
+ * - All sensitive data must be handled according to PCI compliance
+ * - All errors must be properly typed and include provider context
+ */
+export interface PaymentProvider {
+    /** Unique identifier for this payment provider */
+    readonly name: PAYMENTPROVIDERTYPE;
+    /** Payment methods supported by this provider */
+    readonly supportedMethods: PAYMENTMETHOD[];
+    /** Currencies supported by this provider */
+    readonly supportedCurrencies: CURRENCY[];
+    /** Detailed capabilities of this provider */
+    readonly capabilities: ProviderCapabilities;
+    /** Provider configuration and metadata */
+    readonly config: ProviderConfiguration;
+    /**
+     * Initialize the provider with configuration and validate connectivity.
+     * This method should:
+     * - Validate all required configuration parameters
+     * - Test connectivity to provider APIs
+     * - Set up webhook endpoints if required
+     * - Initialize any required provider SDKs
+     *
+     * @param config - Provider-specific configuration
+     * @throws ProviderConfigurationError if configuration is invalid
+     * @throws ProviderConnectionError if unable to connect to provider
+     */
+    initialize(config: PaymentProviderConfig): Promise<void>;
+    /**
+     * Shutdown the provider and clean up resources.
+     * This method should:
+     * - Close any open connections
+     * - Cancel any pending operations
+     * - Clean up temporary resources
+     */
+    shutdown(): Promise<void>;
+    /**
+     * Create a new payment transaction.
+     * This method should:
+     * - Validate payment parameters
+     * - Create transaction with provider
+     * - Return payment result with next steps
+     * - Handle provider-specific error cases
+     *
+     * @param params - Payment creation parameters
+     * @returns Payment result with status and next steps
+     * @throws PaymentValidationError for invalid parameters
+     * @throws PaymentProcessingError for provider errors
+     */
+    createPayment(params: ProcessPaymentRequest): Promise<PaymentResult>;
+    /**
+     * Process a refund for an existing transaction.
+     * This method should:
+     * - Validate refund parameters and permissions
+     * - Check if refund is possible for this transaction
+     * - Process refund with provider
+     * - Return refund result with status
+     *
+     * @param params - Refund processing parameters
+     * @returns Refund result with status and details
+     * @throws RefundValidationError for invalid refund requests
+     * @throws RefundProcessingError for provider errors
+     */
+    processRefund(params: RefundParams): Promise<RefundResult>;
+    /**
+     * Get current status of a payment transaction.
+     * This method should:
+     * - Query provider for current transaction status
+     * - Normalize provider status to our standard statuses
+     * - Include any relevant status details
+     *
+     * @param transactionId - Provider's transaction identifier
+     * @returns Current normalized payment status
+     * @throws TransactionNotFoundError if transaction doesn't exist
+     */
+    getPaymentStatus(transactionId: string): Promise<PaymentStatusResult>;
+    /**
+     * Process incoming webhook from provider.
+     * This method should:
+     * - Verify webhook signature for security
+     * - Parse and validate webhook payload
+     * - Normalize webhook data to our event format
+     * - Return processing result
+     *
+     * @param payload - Raw webhook payload from provider
+     * @returns Webhook processing result
+     * @throws WebhookVerificationError for invalid signatures
+     * @throws WebhookProcessingError for processing failures
+     */
+    processWebhook(payload: WebhookPayload): Promise<WebhookResult>;
+    /**
+     * Verify webhook signature for security.
+     * This method should:
+     * - Validate webhook signature using provider's method
+     * - Return true if signature is valid, false otherwise
+     * - Handle different signature algorithms
+     *
+     * @param payload - Raw webhook body
+     * @param signature - Webhook signature header
+     * @param secret - Webhook secret for verification
+     * @returns True if signature is valid
+     */
+    verifyWebhookSignature(payload: string, signature: string, secret?: string): boolean;
+    /**
+     * Calculate fees for a potential transaction.
+     * This method should:
+     * - Calculate all applicable fees for the transaction
+     * - Include provider fees, platform fees, and additional charges
+     * - Consider user location, currency, and payment method
+     *
+     * @param amount - Transaction amount
+     * @param method - Payment method to be used
+     * @param options - Additional calculation options
+     * @returns Detailed fee breakdown
+     */
+    calculateFees(amount: Money, method: PAYMENTMETHOD, options?: FeeCalculationOptions): Promise<FeeBreakdown>;
+    /**
+     * Check provider health and availability.
+     * This method should:
+     * - Test connectivity to provider APIs
+     * - Check service status and response times
+     * - Return detailed health information
+     *
+     * @returns Provider health status and metrics
+     */
+    healthCheck(): Promise<ProviderHealthStatus>;
+    /**
+     * Create a customer profile with the provider (optional).
+     * Only implement if provider supports customer management.
+     */
+    createCustomer?(params: CreateCustomerParams): Promise<CustomerResult>;
+    /**
+     * Save a payment method for future use (optional).
+     * Only implement if provider supports saved payment methods.
+     */
+    savePaymentMethod?(params: SavePaymentMethodParams): Promise<SavedPaymentMethodResult>;
+    /**
+     * Delete a saved payment method (optional).
+     * Only implement if provider supports payment method management.
+     */
+    deletePaymentMethod?(paymentMethodId: string): Promise<void>;
+    /**
+     * Get transaction history from provider (optional).
+     * Only implement if provider supports historical transaction queries.
+     */
+    getTransactionHistory?(params: TransactionHistoryParams): Promise<TransactionHistory>;
+}
+/**
+ * Detailed provider capabilities interface.
+ * This interface allows the system to understand what each provider
+ * can and cannot do, enabling intelligent routing and feature availability.
+ */
+export interface ProviderCapabilities {
+    /** Supports recurring/subscription payments */
+    supportsSubscriptions: boolean;
+    /** Supports full refunds */
+    supportsRefunds: boolean;
+    /** Supports partial refunds */
+    supportsPartialRefunds: boolean;
+    /** Supports payment preauthorization (capture later) */
+    supportsPreauthorization: boolean;
+    /** Supports payment cancellation before capture */
+    supportsCancellation: boolean;
+    /** Supports 3D Secure verification */
+    supports3DSecure: boolean;
+    /** Provides fraud detection and scoring */
+    supportsFraudDetection: boolean;
+    /** Supports multi-factor authentication */
+    supportsMultiFactorAuth: boolean;
+    /** Provides real-time webhook notifications */
+    supportsWebhooks: boolean;
+    /** Supports customer profile management */
+    supportsCustomerProfiles: boolean;
+    /** Supports saved payment methods */
+    supportsSavedPaymentMethods: boolean;
+    /** Supports transaction history queries */
+    supportsTransactionHistory: boolean;
+    /** Supports multiple currencies */
+    supportsMultiCurrency: boolean;
+    /** Supports automatic currency conversion */
+    supportsCurrencyConversion: boolean;
+    /** Supports cryptocurrency payments */
+    supportsCryptocurrency: boolean;
+    /** Supports cross-border transactions */
+    supportsCrossBorderPayments: boolean;
+    /** Supports instant payouts to recipients */
+    supportsInstantPayouts: boolean;
+    /** Supports scheduled payouts */
+    supportsScheduledPayouts: boolean;
+    /** Supports marketplace/split payments */
+    supportsMarketplacePayments: boolean;
+    /** Supports chargeback/dispute management */
+    supportsDisputeManagement: boolean;
+    /** Provides dispute evidence submission */
+    supportsDisputeEvidence: boolean;
+    /** Minimum transaction amount per payment method */
+    minimumAmounts: Record<PAYMENTMETHOD, Money>;
+    /** Maximum transaction amount per payment method */
+    maximumAmounts: Record<PAYMENTMETHOD, Money>;
+    /** Supported countries/regions */
+    supportedRegions: string[];
+    /** Processing time estimates per payment method */
+    processingTimes: Record<PAYMENTMETHOD, ProcessingTimeEstimate>;
+    /** Settlement time estimates per payment method */
+    settlementTimes: Record<PAYMENTMETHOD, SettlementTimeEstimate>;
+}
+/**
+ * Provider configuration interface for initialization.
+ */
+export interface ProviderConfiguration<TSettings extends object = object, TFeatures extends Record<string, boolean> = Record<string, boolean>, TCredentials extends Record<string, string> = Record<string, string>> {
+    /** Provider name for logging and identification */
+    name: string;
+    /** Environment (sandbox, staging, production) */
+    environment: 'sandbox' | 'staging' | 'production';
+    /** Provider-specific configuration parameters */
+    credentials: TCredentials;
+    /** Webhook configuration */
+    webhookConfig?: {
+        /** Webhook endpoint URL */
+        endpointUrl: string;
+        /** Webhook secret for signature verification */
+        secret: string;
+        /** Events to subscribe to */
+        subscribedEvents: string[];
+    };
+    /** Feature flags for this provider */
+    features: TFeatures;
+    /** Custom provider settings (strongly typed via generic) */
+    settings: TSettings;
+}
+/**
+ * Processing time estimate interface.
+ */
+export interface ProcessingTimeEstimate {
+    /** Minimum processing time in minutes */
+    minimumMinutes: number;
+    /** Maximum processing time in minutes */
+    maximumMinutes: number;
+    /** Typical processing time in minutes */
+    typicalMinutes: number;
+    /** Factors that affect processing time */
+    factors: string[];
+}
+/**
+ * Settlement time estimate interface.
+ */
+export interface SettlementTimeEstimate {
+    /** Minimum settlement time in business days */
+    minimumDays: number;
+    /** Maximum settlement time in business days */
+    maximumDays: number;
+    /** Typical settlement time in business days */
+    typicalDays: number;
+    /** Whether weekends and holidays affect settlement */
+    affectedByHolidays: boolean;
+}

package/dist/payments/provider/provider-capability/enums.d.ts

@@ -0,0 +1,116 @@
+/**
+ * Enumeration of all supported payment providers in the Plyaz ecosystem.
+ */
+export declare enum PAYMENTPROVIDERTYPE {
+    Stripe = "stripe",
+    Paypal = "paypal",
+    CheckoutCom = "checkout_com",
+    Adyen = "adyen",
+    Moonpay = "moonpay",
+    CoinbaseCommerce = "coinbase_commerce",
+    BlockchainBridge = "blockchain_bridge",
+    Pix = "pix",
+    Boleto = "boleto",
+    Sepa = "sepa",
+    Ideal = "ideal",
+    Sofort = "sofort",
+    Alipay = "alipay",
+    WechatPay = "wechat_pay",
+    MockProvider = "mock_provider"
+}
+/**
+ * Enumeration of payment methods supported across all providers.
+ */
+export declare enum PAYMENTMETHOD {
+    CreditCard = "credit_card",
+    DebitCard = "debit_card",
+    BankTransfer = "bank_transfer",
+    PaypalAccount = "paypal_account",
+    CryptoBitcoin = "crypto_bitcoin",
+    CryptoEthereum = "crypto_ethereum",
+    CryptoPolygon = "crypto_polygon",
+    CryptoOptimism = "crypto_optimism",
+    CryptoUsdc = "crypto_usdc",
+    CryptoUsdt = "crypto_usdt",
+    CryptoNativeToken = "crypto_native_token",
+    PixInstant = "pix_instant",
+    BoletoBancario = "boleto_bancario",
+    SepaDirectDebit = "sepa_direct_debit",
+    IdealBank = "ideal_bank",
+    SofortBanking = "sofort_banking",
+    AlipayDigital = "alipay_digital",
+    WechatPayDigital = "wechat_pay_digital",
+    ApplePay = "apple_pay",
+    GooglePay = "google_pay",
+    SamsungPay = "samsung_pay"
+}
+/**
+ * Comprehensive payment status enumeration.
+ */
+export declare enum PAYMENTSTATUS {
+    Initiated = "initiated",
+    Pending = "pending",
+    Processing = "processing",
+    RequiresAction = "requires_action",
+    RequiresConfirmation = "requires_confirmation",
+    RequiresPaymentMethod = "requires_payment_method",
+    Completed = "completed",
+    Settled = "settled",
+    Failed = "failed",
+    Declined = "declined",
+    Cancelled = "cancelled",
+    Expired = "expired",
+    Refunded = "refunded",
+    PartiallyRefunded = "partially_refunded",
+    Disputed = "disputed",
+    Chargeback = "chargeback",
+    ChargebackResolved = "chargeback_resolved",
+    Held = "held",
+    Authorized = "authorized",
+    Captured = "captured"
+}
+/**
+ * Transaction type enumeration.
+ */
+export declare enum TRANSACTIONTYPE {
+    Payment = "payment",
+    Refund = "refund",
+    PartialRefund = "partial_refund",
+    Withdrawal = "withdrawal",
+    Donation = "donation",
+    Subscription = "subscription",
+    SubscriptionRenewal = "subscription_renewal",
+    Fee = "fee",
+    Chargeback = "chargeback",
+    Adjustment = "adjustment",
+    Reward = "reward",
+    Penalty = "penalty",
+    Transfer = "transfer"
+}
+/**
+ * User type enumeration.
+ */
+export declare enum USERTYPE {
+    Fan = "fan",
+    Athlete = "athlete",
+    Club = "club",
+    Agent = "agent",
+    Scout = "scout",
+    Admin = "admin",
+    System = "system"
+}
+/**
+ * Product type enumeration.
+ */
+export declare enum PRODUCTTYPE {
+    Campaign = "campaign",
+    Subscription = "subscription",
+    Nft = "nft",
+    Merchandise = "merchandise",
+    EventTicket = "event_ticket",
+    PremiumContent = "premium_content",
+    TrainingSession = "training_session",
+    Consultation = "consultation",
+    DigitalProduct = "digital_product",
+    PhysicalProduct = "physical_product"
+}

package/dist/payments/provider/provider-capability/index.d.ts

@@ -0,0 +1 @@
+export * from './enums';

package/dist/payments/request/enums.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Enumeration of action types that users might need to complete.
+ */
+export declare enum REQUIREDACTIONTYPE {
+    /** Redirect to external page (3D Secure, bank auth, etc.) */
+    Redirect = "redirect",
+    /** Enter SMS or email verification code */
+    OtpVerification = "otp_verification",
+    /** Upload identity or financial documents */
+    DocumentUpload = "document_upload",
+    /** Provide additional payment information */
+    AdditionalPaymentInfo = "additional_payment_info",
+    /** Confirm payment via mobile app or email */
+    PaymentConfirmation = "payment_confirmation",
+    /** Contact customer support for manual verification */
+    ManualVerification = "manual_verification",
+    /** Wait for bank transfer or other delayed method */
+    WaitForCompletion = "wait_for_completion"
+}

package/dist/payments/request/index.d.ts

@@ -0,0 +1,2 @@
+export * from './enums';
+export type * from './types';

package/dist/payments/request/types.d.ts

@@ -0,0 +1,221 @@
+import type { PAYMENTMETHOD, PAYMENTPROVIDERTYPE, PAYMENTSTATUS, PRODUCTTYPE, USERTYPE } from '../provider';
+import type { ReceiptData, SavedPaymentMethodInfo } from '../provider/core';
+import type { FeeBreakdown, Money } from '../transaction';
+import type { REQUIREDACTIONTYPE } from './enums';
+/**
+ * Comprehensive payment request interface that supports all payment types
+ * and providers while maintaining type safety and validation requirements.
+ *
+ * Design Goals:
+ * - Single interface for all payment types
+ * - Extensible for new payment methods
+ * - Strong validation support
+ * - Audit trail requirements built-in
+ */
+export interface ProcessPaymentRequest<TCustomMetadata extends Record<string, string | number | boolean> = Record<string, never>> {
+    /** Payment amount and currency information */
+    amount: Money;
+    /** Selected payment method from supported options */
+    paymentMethod: PAYMENTMETHOD;
+    /**
+     * Optional provider override for advanced use cases
+     * If not specified, optimal provider will be auto-selected
+     */
+    provider?: PAYMENTPROVIDERTYPE;
+    /** User making the payment - must be authenticated */
+    userId: string;
+    /** Type of user making the payment for limit enforcement */
+    userType: USERTYPE;
+    /** Product or service being purchased */
+    productId: string;
+    /** Type of product for business rule application */
+    productType: PRODUCTTYPE;
+    /**
+     * Human-readable description for receipts and statements
+     * Should be descriptive but concise (max 255 characters)
+     */
+    description?: string;
+    /**
+     * Additional structured metadata for transaction tracking
+     * Useful for analytics, debugging, and business intelligence
+     */
+    metadata?: {
+        /** Campaign-specific information */
+        campaignInfo?: {
+            campaignId: string;
+            campaignTitle: string;
+            athleteId: string;
+            fundingGoal?: Money;
+        };
+        /** Subscription-specific information */
+        subscriptionInfo?: {
+            planId: string;
+            billingCycle: 'monthly' | 'quarterly' | 'yearly';
+            trialPeriod?: number;
+        };
+        /** Geographic and device information */
+        geoInfo?: {
+            country: string;
+            region?: string;
+            city?: string;
+            timezone?: string;
+        };
+        /** Custom metadata fields */
+        custom?: TCustomMetadata;
+    };
+    /** URL to redirect user after successful payment completion */
+    returnUrl?: string;
+    /** URL to redirect user after payment cancellation */
+    cancelUrl?: string;
+    /**
+     * Idempotency key to prevent duplicate payment processing
+     * Should be unique per payment attempt, recommended: UUID v4
+     */
+    idempotencyKey?: string;
+    /**
+     * Whether to save payment method for future use
+     * Requires user consent and provider support
+     */
+    savePaymentMethod?: boolean;
+    /**
+     * Existing saved payment method ID to use
+     * Alternative to entering new payment details
+     */
+    savedPaymentMethodId?: string;
+    /**
+     * Payment scheduling information for future payments
+     * Used for subscription setup and delayed charges
+     */
+    scheduling?: {
+        /** Whether this payment should be processed immediately */
+        processImmediately: boolean;
+        /** Scheduled processing time for future payments */
+        scheduledFor?: Date;
+        /** Recurring payment configuration */
+        recurring?: {
+            frequency: 'daily' | 'weekly' | 'monthly' | 'quarterly' | 'yearly';
+            interval: number;
+            endDate?: Date;
+            maxOccurrences?: number;
+        };
+    };
+    /**
+     * Risk assessment override information
+     * Used for manual risk assessment adjustments
+     */
+    riskAssessment?: {
+        /** Manual risk level override */
+        riskLevel?: 'low' | 'medium' | 'high';
+        /** Risk assessment notes */
+        notes?: string;
+        /** Skip automated fraud checks (admin only) */
+        skipFraudChecks?: boolean;
+    };
+    /**
+     * Processing preferences for payment handling
+     * Allows customization of payment processing behavior
+     */
+    processingPreferences?: {
+        /** Preferred processing speed */
+        speed: 'standard' | 'fast' | 'instant';
+        /** Whether to attempt 3D Secure verification */
+        attempt3DS?: boolean;
+        /** Maximum acceptable processing time (minutes) */
+        maxProcessingTime?: number;
+        /** Fallback behavior if primary method fails */
+        fallbackBehavior?: 'retry' | 'fail' | 'alternative_method';
+    };
+}
+/**
+ * Comprehensive payment result interface providing complete information
+ * about payment processing outcomes and next steps.
+ */
+export interface PaymentResult<TProviderResponse extends object = {}> {
+    /** Unique transaction identifier in Plyaz system */
+    transactionId: string;
+    /** Provider's transaction identifier for reference */
+    providerTransactionId?: string;
+    /** Current payment status */
+    status: PAYMENTSTATUS;
+    /**
+     * URL for redirect-based payment flows (Stripe Checkout, PayPal, etc.)
+     * Client should redirect user to this URL to complete payment
+     */
+    redirectUrl?: string;
+    /**
+     * Client secret for client-side payment confirmation
+     * Used with Stripe Payment Intents and similar flows
+     */
+    clientSecret?: string;
+    /** Generated receipt data if payment completed */
+    receipt?: ReceiptData;
+    /** Detailed breakdown of all fees charged */
+    fees?: FeeBreakdown;
+    /** Estimated settlement date for funds availability */
+    estimatedSettlement?: Date;
+    /**
+     * Actions required from user to complete payment
+     * Common for 3D Secure, bank verification, etc.
+     */
+    requiredActions?: RequiredAction[];
+    /**
+     * Payment method information if saved during transaction
+     * Only includes safe display information, no sensitive data
+     */
+    savedPaymentMethod?: SavedPaymentMethodInfo;
+    /**
+     * Provider-specific metadata and additional information
+     * Useful for debugging and advanced integrations
+     */
+    metadata?: {
+        /** Provider-specific response data */
+        providerResponse?: TProviderResponse;
+        /** Processing performance metrics */
+        performanceMetrics?: {
+            providerResponseTime: number;
+            totalProcessingTime: number;
+            dbWriteTime?: number;
+        };
+        /** Security validation results */
+        securityChecks?: {
+            fraudScore?: number;
+            riskLevel?: 'low' | 'medium' | 'high';
+            securityFlags?: string[];
+        };
+    };
+    /** Time taken to process payment in milliseconds */
+    processingTime?: number;
+    /**
+     * Next steps for user or system
+     * Provides guidance on what should happen next
+     */
+    nextSteps?: {
+        /** What the user should do next */
+        userAction?: 'redirect' | 'wait' | 'retry' | 'contact_support';
+        /** System actions to be taken */
+        systemAction?: 'webhook_pending' | 'manual_review' | 'auto_retry';
+        /** Expected timeframe for next update */
+        expectedUpdateIn?: number;
+    };
+}
+/**
+ * Interface for actions required from user to complete payment.
+ * Supports various verification and confirmation flows.
+ */
+export interface RequiredAction<TActionData extends Record<string, unknown> = Record<string, never>> {
+    /** Type of action required from user */
+    type: REQUIREDACTIONTYPE;
+    /** URL or endpoint for completing the action */
+    actionUrl?: string;
+    /**
+     * Additional data needed for the action
+     * Format depends on action type
+     */
+    actionData?: TActionData;
+    /** When this action expires and payment will be cancelled */
+    expiresAt?: Date;
+    /** Human-readable instructions for the user */
+    instructions?: string;
+    /** Whether this action is optional or required */
+    required: boolean;
+}

package/dist/payments/service/index.d.ts

@@ -0,0 +1 @@
+export type * from './types';

package/dist/payments/service/types.d.ts

@@ -0,0 +1,48 @@
+import type { ValidationResult } from '../../common';
+import type { PAYMENTPROVIDERTYPE, PAYMENTSTATUS } from '../provider';
+import type { PaymentAdapter } from '../provider/adapter';
+import type { PaymentResult, ProcessPaymentRequest } from '../request';
+import type { Money } from '../transaction';
+/**
+ * Core payment service interface that defines the main payment operations.
+ * This interface ensures all payment services implement consistent methods
+ * for processing payments, checking status, and handling refunds.
+ * Used as dependency injection to provide type-safe service contracts.
+ */
+export interface PaymentServiceInterface {
+    /** Process a new payment transaction with full business logic validation */
+    processPayment(request: ProcessPaymentRequest): Promise<PaymentResult>;
+    /** Get current status of any payment transaction */
+    getPaymentStatus(transactionId: string): Promise<PAYMENTSTATUS>;
+    /** Process refunds with authorization and business rule validation */
+    /** Validate payment limits before processing */
+    validatePaymentLimits(userId: string, amount: Money): Promise<boolean>;
+}
+/**
+ * Factory service for creating provider-specific payment adapters.
+ * Implements the Factory pattern to dynamically create
+ * payment provider instances based on routing decisions and configuration.
+ */
+export interface PaymentAdapterFactory {
+    /** Create adapter instance for specific provider */
+    createAdapter(provider: PAYMENTPROVIDERTYPE): Promise<PaymentAdapter>;
+    /** Get list of currently available and healthy providers */
+    getAvailableProviders(): PAYMENTPROVIDERTYPE[];
+    /** Validate provider configuration before creating adapter */
+    validateProviderConfig(provider: PAYMENTPROVIDERTYPE): boolean;
+    /** Get adapter with automatic provider selection based on routing rules */
+    getOptimalAdapter(request: ProcessPaymentRequest): Promise<PaymentAdapter>;
+}
+/**
+ * High-level orchestration service that coordinates payment workflows.
+ * Handles business logic coordination between multiple services while
+ * maintaining transaction consistency and event emission.
+ */
+export interface PaymentOrchestrationService {
+    /** Main orchestration method that handles complete payment workflow */
+    orchestratePayment(request: ProcessPaymentRequest): Promise<PaymentResult>;
+    /** Handle post-payment workflows (notifications, analytics, etc.) */
+    handlePaymentWorkflow(transactionId: string): Promise<void>;
+    /** Execute business rules validation before payment processing */
+    executeBusinessRules(request: ProcessPaymentRequest): Promise<ValidationResult>;
+}

package/dist/payments/transaction/index.d.ts

@@ -0,0 +1 @@
+export type * from './types';