import { g as ProviderStrategyConfig, k as BillingLogger, f as RegionDetectionContext, p as ProviderSelection, d as BillingRegion, F as FallbackConfig, h as FallbackOperation } from '../billing-service-LsAFesou.js';
export { o as BillingCustomer, a as BillingError, q as BillingErrorCode, b as BillingErrorCodes, B as BillingService, j as BillingServiceConfig, n as BillingSubscription, C as CancelOptions, m as CancelResult, i as FallbackContext, G as GetSubscriptionOptions, P as ProviderRoutingRule, R as RegionDetectionResult, e as RegionDetector, S as SubscribeOptions, l as SubscribeResult, c as createBillingService } from '../billing-service-LsAFesou.js';
import { PaymentProviderType, PaymentProvider } from '../types.js';
import '../webhooks/index.js';
import '@parsrun/types';

/**
 * @parsrun/payments - Provider Strategy
 * Region-based provider routing and selection
 */

/**
 * Provider Strategy
 * Handles region-based provider routing and selection
 */
declare class ProviderStrategy {
    private readonly defaultProvider;
    private readonly regionProviders;
    private readonly rules;
    private readonly regionDetector;
    private readonly logger;
    constructor(config: ProviderStrategyConfig, logger?: BillingLogger);
    /**
     * Select provider for given context
     */
    selectProvider(context: RegionDetectionContext, forceProvider?: PaymentProviderType): Promise<ProviderSelection>;
    /**
     * Detect region from context
     */
    detectRegion(context: RegionDetectionContext): Promise<BillingRegion>;
    /**
     * Get all configured providers
     */
    getAllProviders(): PaymentProvider[];
    /**
     * Get provider by type
     */
    getProviderByType(type: PaymentProviderType): PaymentProvider | undefined;
    /**
     * Get default provider
     */
    getDefaultProvider(): PaymentProvider;
    /**
     * Get provider for region
     */
    getProviderForRegion(region: BillingRegion): PaymentProvider;
    /**
     * Check if region is supported
     */
    isRegionSupported(region: BillingRegion): boolean;
    /**
     * Get supported regions
     */
    getSupportedRegions(): BillingRegion[];
    /**
     * Find provider by type across all configured providers
     */
    private findProviderByType;
}
/**
 * Create provider strategy
 */
declare function createProviderStrategy(config: ProviderStrategyConfig, logger?: BillingLogger): ProviderStrategy;

/**
 * @parsrun/payments - Fallback Executor
 * Handles provider fallback with safety controls
 */

/**
 * Fallback Executor
 * Handles provider fallback with safety controls and logging
 */
declare class FallbackExecutor {
    private readonly config;
    private readonly logger;
    constructor(config: FallbackConfig, logger?: BillingLogger);
    /**
     * Check if fallback is enabled
     */
    get isEnabled(): boolean;
    /**
     * Execute operation with fallback support
     *
     * @param operation - Operation name for safety checks
     * @param primaryProvider - Primary provider to try first
     * @param fallbackProviders - Fallback providers in order of preference
     * @param execute - Function that executes the operation on a provider
     */
    execute<T>(operation: FallbackOperation, primaryProvider: PaymentProvider, fallbackProviders: PaymentProvider[], execute: (provider: PaymentProvider) => Promise<T>): Promise<{
        result: T;
        provider: PaymentProvider;
        usedFallback: boolean;
    }>;
    /**
     * Check if fallback is allowed for operation
     */
    canFallback(operation: FallbackOperation): boolean;
    /**
     * Check if error is retryable
     */
    isRetryableError(error: Error): boolean;
    /**
     * Notify fallback callback
     */
    private notifyFallback;
    /**
     * Notify all failed callback
     */
    private notifyAllFailed;
}
/**
 * Create a disabled fallback executor (default behavior)
 */
declare function createDisabledFallback(): FallbackExecutor;
/**
 * Create fallback executor
 */
declare function createFallbackExecutor(config: FallbackConfig, logger?: BillingLogger): FallbackExecutor;

export { BillingLogger, BillingRegion, FallbackConfig, FallbackExecutor, FallbackOperation, ProviderSelection, ProviderStrategy, ProviderStrategyConfig, RegionDetectionContext, createDisabledFallback, createFallbackExecutor, createProviderStrategy };