@bloonio/lokotro-pay 1.0.0

package/index.d.ts

@@ -0,0 +1,1640 @@
+import * as i0 from '@angular/core';
+import { OnInit, OnDestroy, EventEmitter, ModuleWithProviders, InjectionToken } from '@angular/core';
+import * as i1 from '@angular/common';
+import * as i2 from '@angular/common/http';
+import { HttpClient } from '@angular/common/http';
+import * as i3 from '@angular/forms';
+import { FormGroup, FormBuilder, ControlValueAccessor, Validator, AbstractControl, ValidationErrors } from '@angular/forms';
+import { Observable } from 'rxjs';
+
+/**
+ * Lokotro Pay - Enums
+ * Angular version of the Flutter Lokotro Pay plugin enums
+ */
+/**
+ * Payment channel types supported by Lokotro Pay
+ */
+declare enum LokotroPayChannel {
+    None = "none",
+    All = "all",
+    EFlash = "eflash",
+    EWallet = "ewallet",
+    Card = "card",
+    MobileMoney = "mobileMoney",
+    EWalletOtp = "ewalletOtp",
+    LokotroWallet = "lokotroWallet",
+    VirtualCard = "virtualCard",
+    BankTransfer = "bankTransfer"
+}
+/**
+ * Payment channel display names and icons
+ */
+declare const LokotroPayChannelInfo: Record<LokotroPayChannel, {
+    displayName: string;
+    iconPath: string;
+}>;
+/**
+ * Form filling information status
+ */
+declare enum LokotroPayFillingInfo {
+    None = "none",
+    Full = "full",
+    Partial = "partial"
+}
+/**
+ * Local screen navigation states for enhanced UI flow
+ */
+declare enum LokotroPayScreenNavigation {
+    DefaultScreen = "defaultScreen",
+    LoadingScreen = "loadingScreen",
+    PaymentMethodSelectionScreen = "paymentMethodSelectionScreen",
+    PaymentFormScreen = "paymentFormScreen",
+    EWalletFormScreen = "ewalletFormScreen",
+    MobileMoneyFormScreen = "mobilemoneyFormScreen",
+    CardFormScreen = "cardFormScreen",
+    BankTransferFormScreen = "bankTransferFormScreen",
+    FlashFormScreen = "flashFormScreen",
+    PaymentConfirmationScreen = "paymentConfirmationScreen",
+    ProcessingScreen = "processingScreen",
+    MobileMoneyProcessingScreen = "mobileMoneyProcessingScreen",
+    EWalletOtpScreen = "ewalletOtpScreen",
+    SuccessScreen = "successScreen",
+    ErrorScreen = "errorScreen",
+    WarningScreen = "warningScreen",
+    InfoScreen = "infoScreen"
+}
+/**
+ * Screen navigation display names
+ */
+declare const LokotroPayScreenNavigationInfo: Record<LokotroPayScreenNavigation, string>;
+/**
+ * API result processing screen types
+ */
+declare enum LokotroPayResultScreen {
+    SuccessScreen = "successScreen",
+    ErrorScreen = "errorScreen",
+    WarningScreen = "warningScreen",
+    InfoScreen = "infoScreen"
+}
+/**
+ * Payment status enumeration
+ */
+declare enum LokotroPaymentStatus {
+    Pending = "pending",
+    Processing = "processing",
+    Approved = "approved",
+    Declined = "declined",
+    Failed = "failed",
+    Cancelled = "cancelled",
+    Expired = "expired",
+    Refunded = "refunded",
+    PendingBankProofUpload = "pending_bank_proof_upload"
+}
+/**
+ * API response status codes
+ */
+declare enum LokotroPayApiResponseCode {
+    LOK000 = "LOK000",// Success
+    LOK001 = "LOK001",// General error
+    LOK002 = "LOK002",// Invalid parameters
+    LOK003 = "LOK003",// Authentication failed
+    LOK004 = "LOK004",// Payment method not available
+    LOK005 = "LOK005",// Insufficient funds
+    LOK006 = "LOK006",// Transaction limit exceeded
+    LOK007 = "LOK007",// Network error
+    LOK008 = "LOK008",// Timeout
+    LOK009 = "LOK009"
+}
+/**
+ * API response code helper functions
+ */
+declare const LokotroPayApiResponseCodeInfo: {
+    getMessage(code: LokotroPayApiResponseCode): string;
+    isSuccess(code: LokotroPayApiResponseCode): boolean;
+    fromString(code: string): LokotroPayApiResponseCode;
+};
+/**
+ * Supported languages for Lokotro Pay
+ */
+declare enum LokotroPayLanguage {
+    English = "en",
+    French = "fr",
+    German = "de",
+    Spanish = "es",
+    Italian = "it",
+    Russian = "ru",
+    Hindi = "hi",
+    Japanese = "ja",
+    Chinese = "zh",
+    Lingala = "ln"
+}
+/**
+ * Language info with display names and flag assets
+ */
+declare const LokotroPayLanguageInfo: Record<LokotroPayLanguage, {
+    displayName: string;
+    nativeName: string;
+    flagAsset: string;
+}>;
+
+/**
+ * Lokotro Pay - Country Models
+ * Models for country data and phone number validation
+ */
+/**
+ * Phone number prefix model
+ */
+interface LokotroPhonePrefix {
+    id: string;
+    prefix: string;
+}
+/**
+ * Country code model
+ */
+interface LokotroCountryCode {
+    id: string;
+    countryCode: string;
+}
+/**
+ * Reference country model with flag and phone constraints
+ */
+interface LokotroRefCountry {
+    id: string;
+    name: string;
+    countryFlag: string;
+    minPhoneNumberChars: number;
+    maxPhoneNumberChars: number;
+}
+/**
+ * Complete country model with all related data
+ */
+interface LokotroCountry {
+    refCountry: LokotroRefCountry;
+    countryCodes: LokotroCountryCode[];
+    phoneNumberPrefixes: LokotroPhonePrefix[];
+}
+/**
+ * Country helper utilities
+ */
+declare class LokotroCountryUtils {
+    /**
+     * Get the primary country code (first in the list)
+     */
+    static getPrimaryCountryCode(country: LokotroCountry): string;
+    /**
+     * Get the country flag emoji
+     */
+    static getFlag(country: LokotroCountry): string;
+    /**
+     * Get all valid phone prefixes as strings
+     */
+    static getValidPrefixes(country: LokotroCountry): string[];
+    /**
+     * Get min phone chars
+     */
+    static getMinPhoneChars(country: LokotroCountry): number;
+    /**
+     * Get max phone chars
+     */
+    static getMaxPhoneChars(country: LokotroCountry): number;
+    /**
+     * Check if a phone number has a valid prefix for this country
+     */
+    static hasValidPrefix(country: LokotroCountry, phoneNumber: string): boolean;
+    /**
+     * Check if phone number length is valid
+     */
+    static isValidPhoneLength(country: LokotroCountry, phoneNumber: string): boolean;
+    /**
+     * Validate phone number completely
+     */
+    static validatePhoneNumber(country: LokotroCountry, phoneNumber: string): {
+        isValid: boolean;
+        errorType?: 'empty' | 'invalidPrefix' | 'tooShort' | 'tooLong';
+    };
+    /**
+     * Parse country from API response
+     */
+    static fromJson(json: Record<string, unknown>): LokotroCountry;
+}
+
+/**
+ * Bank entity (city) model
+ */
+interface LokotroBankEntity {
+    id: string;
+    name: string;
+    countryFlag?: string;
+}
+/**
+ * Bank currency model
+ */
+interface LokotroBankCurrency {
+    id: string;
+    name: string;
+    code: string;
+    symbol?: string;
+}
+/**
+ * Bank account model
+ */
+interface LokotroBankAccount {
+    id: string;
+    identifier: string;
+    accountNumber: string;
+    accountLabel: string;
+    createdAt?: string;
+    refBank?: LokotroBank;
+    refCurrency?: LokotroBankCurrency;
+}
+/**
+ * Bank model
+ */
+interface LokotroBank {
+    id: string;
+    name: string;
+    abreviation: string;
+    bankLogoUrl: string;
+    hasRibNomenclatureConstraint: boolean;
+    ribAccountNumberFormatStr: string;
+    bankAccounts: LokotroBankAccount[];
+    entityAvailables: LokotroBankEntity[];
+}
+
+/**
+ * Lokotro Pay - Core Models and Interfaces
+ * Angular version of the Flutter Lokotro Pay plugin
+ */
+
+/**
+ * Configuration for Lokotro Pay
+ */
+interface LokotroPayConfig {
+    /** API authentication token (app-key) */
+    token: string;
+    /** Whether to use production environment */
+    isProduction?: boolean;
+    /** Custom API URL (optional) */
+    customApiUrl?: string;
+    /** Request timeout in milliseconds */
+    timeout?: number;
+    /** Accept-Language header for API requests */
+    acceptLanguage?: string;
+}
+/**
+ * Payment body for Lokotro Pay - All-in-one request
+ */
+interface LokotroPaymentBody {
+    customerReference: string;
+    amount: string;
+    currency: string;
+    paymentMethod?: string;
+    userInfo?: 'full' | 'partial' | 'none';
+    paymentMethodInfo?: 'full' | 'partial' | 'none';
+    feeCoveredBy?: 'buyer' | 'seller';
+    deliveryBehaviour?: 'direct_delivery' | 'escrow';
+    notifyUrl?: string;
+    successRedirectUrl?: string;
+    failRedirectUrl?: string;
+    firstName?: string;
+    lastName?: string;
+    phoneNumber?: string;
+    email?: string;
+    walletNumber?: string;
+    walletPin?: string;
+    mobileMoneyPhoneNumber?: string;
+    flashNumber?: string;
+    flashPin?: string;
+    cardNumber?: string;
+    cardExpiryDate?: string;
+    cardCvv?: string;
+    cardHolderName?: string;
+    merchant?: LokotroMerchantInfo;
+    mastercardPaymentMethod?: 'HOSTED_SESSION' | 'DIRECT_CAPTURE';
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Merchant information
+ */
+interface LokotroMerchantInfo {
+    id: string;
+    name: string;
+    logoUrl?: string;
+    website?: string;
+    description?: string;
+}
+/**
+ * Main payment response model
+ */
+interface LokotroPayResponse {
+    message: string;
+    title: string;
+    customRef: string;
+    amount: number;
+    apiResponseCode: LokotroPayApiResponseCode;
+    currency: string;
+    paymentStatus: LokotroPaymentStatus;
+    systemRef: string;
+    transactionId?: string;
+    identifier?: string;
+    successRedirectUrl?: string;
+    failRedirectUrl?: string;
+    timestamp?: Date;
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Error response model
+ */
+interface LokotroPayError {
+    message: string;
+    title: string;
+    errorCode?: LokotroPayApiResponseCode;
+    details?: string;
+    successRedirectUrl?: string;
+    failRedirectUrl?: string;
+    timestamp: Date;
+}
+/**
+ * Payment information model
+ */
+interface LokotroPaymentInfo {
+    id: string;
+    amount: number;
+    currency: string;
+    description: string;
+    merchantName: string;
+    merchantId: string;
+    availablePaymentMethods: LokotroPaymentMethod[];
+    createdAt: Date;
+    expiresAt?: Date;
+    metadata?: Record<string, unknown>;
+    paymentUrl?: string;
+    showUserInfoForm: boolean;
+    showPaymentMethodForm: boolean;
+    fillingInfo?: string;
+}
+/**
+ * Payment method model
+ */
+interface LokotroPaymentMethod {
+    id: string;
+    name: string;
+    displayName: string;
+    channel: LokotroPayChannel;
+    iconUrl: string;
+    isEnabled: boolean;
+    configuration?: Record<string, unknown>;
+    supportedCurrencies?: string[];
+}
+/**
+ * Payment method list item for UI display
+ */
+interface LokotroPaymentMethodListItem {
+    id: string;
+    name: string;
+    displayName: string;
+    channel: LokotroPayChannel;
+    iconUrl: string;
+    isEnabled: boolean;
+    isSelected: boolean;
+    configuration?: Record<string, unknown>;
+}
+/**
+ * Payment form data model
+ */
+interface LokotroPaymentFormData {
+    paymentMethodId: string;
+    channel: LokotroPayChannel;
+    formData: Record<string, unknown>;
+    timestamp: Date;
+}
+/**
+ * Response callback for successful payments
+ */
+interface LokotroPayOnResponse {
+    message: string;
+    title: string;
+    customRef: string;
+    customerReference?: string;
+    amount: number;
+    apiResponseCode: LokotroPayApiResponseCode;
+    currency: string;
+    paymentStatus: LokotroPaymentStatus;
+    systemRef: string;
+    transactionId?: string;
+    identifier?: string;
+    successRedirectUrl?: string;
+    failRedirectUrl?: string;
+    timestamp: Date;
+}
+/**
+ * Error callback for failed payments
+ */
+interface LokotroPayOnError {
+    message: string;
+    title: string;
+    errorCode?: LokotroPayApiResponseCode;
+    identifier?: string;
+    customerReference?: string;
+    systemReference?: string;
+    amount?: number;
+    currency?: string;
+    successRedirectUrl?: string;
+    failRedirectUrl?: string;
+    timestamp: Date;
+}
+/**
+ * HTTP Response wrapper
+ */
+interface LokotroHttpResponse<T> {
+    data?: T;
+    message: string;
+    statusCode: number;
+    isSuccess: boolean;
+    apiResponseCode?: LokotroPayApiResponseCode;
+    timestamp: Date;
+}
+/**
+ * Transaction details model
+ */
+interface LokotroTransactionDetails {
+    transactionId: string;
+    amount: number;
+    currency: string;
+    status: LokotroPaymentStatus;
+    paymentMethod: string;
+    customerReference: string;
+    systemReference: string;
+    createdAt: Date;
+    updatedAt?: Date;
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Payment submit request
+ */
+interface LokotroPaymentSubmitRequest {
+    transactionId: string;
+    paymentMethod: string;
+    walletNumber?: string;
+    walletPin?: string;
+    mobileMoneyPhoneNumber?: string;
+    flashNumber?: string;
+    flashPin?: string;
+    cardNumber?: string;
+    cardExpiryDate?: string;
+    cardCvv?: string;
+    cardHolderName?: string;
+    bankTransferAccountId?: string;
+}
+/**
+ * Payment submit response
+ */
+interface LokotroPaymentSubmitResponse {
+    success: boolean;
+    message: string;
+    transactionId: string;
+    status: LokotroPaymentStatus;
+    requiresOtp: boolean;
+    otpDestination?: string;
+    redirectUrl?: string;
+}
+/**
+ * OTP verification request
+ */
+interface LokotroOtpVerifyRequest {
+    transactionId: string;
+    otp: string;
+}
+/**
+ * OTP verification response
+ */
+interface LokotroOtpVerifyResponse {
+    success: boolean;
+    message: string;
+    transactionId: string;
+    status: LokotroPaymentStatus;
+}
+/**
+ * OTP resend request
+ */
+interface LokotroOtpResendRequest {
+    transactionId: string;
+}
+/**
+ * Theme configuration
+ */
+interface LokotroPayThemeConfig {
+    primaryColor?: string;
+    secondaryColor?: string;
+    accentColor?: string;
+    backgroundColor?: string;
+    textColor?: string;
+    errorColor?: string;
+    successColor?: string;
+    warningColor?: string;
+    borderRadius?: string;
+    fontFamily?: string;
+}
+/**
+ * Checkout component input configuration
+ */
+interface LokotroCheckoutConfig {
+    title?: string;
+    titleStyle?: Record<string, string>;
+    titleBackgroundColor?: string;
+    configs: LokotroPayConfig;
+    paymentBody: LokotroPaymentBody;
+    enableHapticFeedback?: boolean;
+    backgroundColor?: string;
+    padding?: string;
+    themeConfig?: LokotroPayThemeConfig;
+    language?: string;
+}
+
+/**
+ * HTTP Client configuration
+ */
+interface LokotroHttpClientConfig {
+    appKey?: string;
+    acceptLanguage?: string;
+    customHeaders?: Record<string, string>;
+}
+/**
+ * Enhanced HTTP client for Lokotro Pay with modern error handling and logging
+ */
+declare class LokotroHttpClientService {
+    private http;
+    private appKey?;
+    private acceptLanguage;
+    private customHeaders;
+    constructor(http: HttpClient);
+    /**
+     * Configure the HTTP client
+     */
+    configure(config: LokotroHttpClientConfig): void;
+    /**
+     * Set app-key for Lokotro Gateway authentication
+     */
+    setAppKey(appKey: string): void;
+    /**
+     * Remove app-key
+     */
+    clearAppKey(): void;
+    /**
+     * Set accept-language header
+     */
+    setAcceptLanguage(language: string): void;
+    /**
+     * Clear accept-language header
+     */
+    clearAcceptLanguage(): void;
+    /**
+     * Build request headers
+     */
+    private buildHeaders;
+    /**
+     * Build full URL
+     */
+    private buildUrl;
+    /**
+     * GET request with enhanced error handling
+     */
+    get<T>(path: string, queryParams?: Record<string, string>): Observable<LokotroHttpResponse<T>>;
+    /**
+     * POST request with enhanced error handling
+     */
+    post<T>(path: string, data?: unknown, queryParams?: Record<string, string>): Observable<LokotroHttpResponse<T>>;
+    /**
+     * PUT request with enhanced error handling
+     */
+    put<T>(path: string, data?: unknown, queryParams?: Record<string, string>): Observable<LokotroHttpResponse<T>>;
+    /**
+     * DELETE request with enhanced error handling
+     */
+    delete<T>(path: string, queryParams?: Record<string, string>): Observable<LokotroHttpResponse<T>>;
+    /**
+     * Handle successful response
+     */
+    private handleSuccess;
+    /**
+     * Handle error response
+     */
+    private handleError;
+    /**
+     * Map HTTP status code to API response code
+     */
+    private getApiResponseCodeFromStatus;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LokotroHttpClientService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<LokotroHttpClientService>;
+}
+
+/**
+ * Payment state for reactive updates
+ */
+interface LokotroPaymentState {
+    isLoading: boolean;
+    currentScreen: LokotroPayScreenNavigation;
+    transactionId?: string;
+    paymentInfo?: LokotroPaymentInfo;
+    selectedPaymentMethod?: LokotroPaymentMethod;
+    error?: LokotroPayError;
+    response?: LokotroPayResponse;
+}
+declare class LokotroPaymentService {
+    private httpClient;
+    private stateSubject;
+    state$: Observable<LokotroPaymentState>;
+    constructor(httpClient: LokotroHttpClientService);
+    /**
+     * Get current state
+     */
+    get currentState(): LokotroPaymentState;
+    /**
+     * Update state
+     */
+    private updateState;
+    /**
+     * Reset state to initial
+     */
+    resetState(): void;
+    /**
+     * Set app-key for authentication
+     */
+    setAppKey(appKey: string): void;
+    /**
+     * Set accept language
+     */
+    setAcceptLanguage(language: string): void;
+    /**
+     * Step 1: Create payment transaction
+     * POST /payments/collect
+     */
+    createPayment(paymentBody: LokotroPaymentBody): Observable<LokotroHttpResponse<CreatePaymentResponse>>;
+    /**
+     * Step 2: Get transaction details
+     * GET /payments/transaction/{transaction_id}
+     */
+    getTransactionDetails(transactionId: string): Observable<LokotroHttpResponse<TransactionDetailsResponse>>;
+    /**
+     * Step 3: Submit payment details
+     * POST /payments/submit
+     */
+    submitPaymentDetails(request: LokotroPaymentSubmitRequest): Observable<LokotroHttpResponse<PaymentSubmitResponse>>;
+    /**
+     * Step 4: Verify OTP (for e-wallet and flash payments)
+     * POST /payments/verify-otp
+     */
+    verifyOtp(request: LokotroOtpVerifyRequest): Observable<LokotroHttpResponse<OtpVerifyResponse>>;
+    /**
+     * Step 5: Resend OTP (if needed)
+     * POST /payments/resend-otp
+     */
+    resendOtp(request: LokotroOtpResendRequest): Observable<LokotroHttpResponse<OtpResendResponse>>;
+    /**
+     * Fetch available banks configuration
+     * GET /payments/get-config-bank
+     */
+    fetchAvailableBanks(): Observable<LokotroHttpResponse<LokotroBank[]>>;
+    /**
+     * Select payment method
+     */
+    selectPaymentMethod(method: LokotroPaymentMethod): void;
+    /**
+     * Navigate to screen
+     */
+    navigateToScreen(screen: LokotroPayScreenNavigation): void;
+    /**
+     * Handle payment success
+     */
+    private handlePaymentSuccess;
+    /**
+     * Handle payment failure
+     */
+    private handlePaymentFailure;
+    /**
+     * Get form screen for payment channel
+     */
+    private getFormScreenForChannel;
+    /**
+     * Convert payment body to API request format
+     */
+    private convertPaymentBodyToRequest;
+    /**
+     * Convert submit request to API format
+     */
+    private convertSubmitRequestToData;
+    /**
+     * Parse payment info from API response
+     */
+    private parsePaymentInfo;
+    /**
+     * Parse payment method from API response
+     */
+    private parsePaymentMethod;
+    /**
+     * Parse submit response from API
+     */
+    private parseSubmitResponse;
+    /**
+     * Parse bank from API response
+     */
+    private parseBank;
+    /**
+     * Parse bank account
+     */
+    private parseBankAccount;
+    /**
+     * Parse bank entity
+     */
+    private parseBankEntity;
+    /**
+     * Parse bank currency
+     */
+    private parseBankCurrency;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LokotroPaymentService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<LokotroPaymentService>;
+}
+interface CreatePaymentResponse {
+    transaction_id?: string;
+    amount?: string;
+    currency?: string;
+    description?: string;
+    merchant_name?: string;
+    merchant_id?: string;
+    available_payment_methods?: Record<string, unknown>[];
+    created_at?: string;
+    expires_at?: string;
+    metadata?: Record<string, unknown>;
+    payment_url?: string;
+    show_user_info_form?: boolean;
+    show_payment_method_form?: boolean;
+    filling_info?: string;
+}
+interface TransactionDetailsResponse {
+    identifier?: string;
+    transaction_id?: string;
+    amount?: number | string;
+    currency_str?: string;
+    currency?: string;
+    status?: string;
+    payment_method?: string;
+    customer_reference?: string;
+    system_reference?: string;
+    created_at?: string;
+    updated_at?: string;
+    metadata?: Record<string, unknown>;
+}
+interface PaymentSubmitResponse {
+    success?: boolean;
+    message?: string;
+    transaction_id?: string;
+    status?: string;
+    requires_otp?: boolean;
+    otp_destination?: string;
+    redirect_url?: string;
+    [key: string]: unknown;
+}
+interface OtpVerifyResponse {
+    success?: boolean;
+    message?: string;
+    transaction_id?: string;
+    status?: string;
+    [key: string]: unknown;
+}
+interface OtpResendResponse {
+    success?: boolean;
+    message?: string;
+    otp_destination?: string;
+}
+
+/**
+ * Translation keys interface
+ */
+interface LokotroTranslations {
+    loading: string;
+    error: string;
+    success: string;
+    cancel: string;
+    confirm: string;
+    continue: string;
+    back: string;
+    close: string;
+    retry: string;
+    done: string;
+    selectPaymentMethod: string;
+    paymentDetails: string;
+    confirmPayment: string;
+    processing: string;
+    paymentSuccessful: string;
+    paymentFailed: string;
+    card: string;
+    mobileMoneyPayment: string;
+    eWallet: string;
+    lokotroWallet: string;
+    bankTransfer: string;
+    eFlash: string;
+    virtualCard: string;
+    cardNumber: string;
+    cardHolderName: string;
+    expiryDate: string;
+    cvv: string;
+    phoneNumber: string;
+    walletNumber: string;
+    pin: string;
+    email: string;
+    firstName: string;
+    lastName: string;
+    required: string;
+    invalidCardNumber: string;
+    invalidExpiryDate: string;
+    invalidCvv: string;
+    invalidPhoneNumber: string;
+    invalidEmail: string;
+    enterOtp: string;
+    otpSentTo: string;
+    resendOtp: string;
+    verifyOtp: string;
+    otpVerificationFailed: string;
+    paymentPending: string;
+    paymentProcessing: string;
+    paymentApproved: string;
+    paymentDeclined: string;
+    paymentCancelled: string;
+    paymentExpired: string;
+    paymentStatus: string;
+    checkingPaymentStatus: string;
+    paymentPendingMessage: string;
+    paymentSuccessMessage: string;
+    paymentFailedMessage: string;
+    paymentCancelledMessage: string;
+    paymentExpiredMessage: string;
+    checkingForUpdates: string;
+    paymentId: string;
+    networkError: string;
+    timeoutError: string;
+    serverError: string;
+    paymentNotFound: string;
+    authenticationError: string;
+    invalidRequest: string;
+    amount: string;
+    fee: string;
+    total: string;
+    currency: string;
+    selectCountry: string;
+    invalidPhonePrefix: string;
+    phoneTooShort: string;
+    phoneTooLong: string;
+    validPrefixes: string;
+    more: string;
+    personalInfo: string;
+    personalPhone: string;
+    mobileMoneyPhone: string;
+    mobileMoneyDetails: string;
+    bankDetails: string;
+    selectCity: string;
+    selectBank: string;
+    selectBankAccount: string;
+    bankAccountSummary: string;
+    accountLabel: string;
+    bankTransferProofInstructions: string;
+    confirmBankTransfer: string;
+}
+declare class LokotroLocalizationService {
+    private currentLanguageSubject;
+    private translationsSubject;
+    /**
+     * Current language observable
+     */
+    currentLanguage$: Observable<LokotroPayLanguage>;
+    /**
+     * Current translations observable
+     */
+    translations$: Observable<LokotroTranslations>;
+    /**
+     * Get current language
+     */
+    get currentLanguage(): LokotroPayLanguage;
+    /**
+     * Get current translations
+     */
+    get translations(): LokotroTranslations;
+    /**
+     * Set language
+     */
+    setLanguage(language: LokotroPayLanguage): void;
+    /**
+     * Set language by code
+     */
+    setLanguageByCode(code: string): void;
+    /**
+     * Get translation by key
+     */
+    translate(key: keyof LokotroTranslations): string;
+    /**
+     * Get all supported languages
+     */
+    getSupportedLanguages(): Array<{
+        code: LokotroPayLanguage;
+        name: string;
+        nativeName: string;
+    }>;
+    /**
+     * Detect browser language and set if supported
+     */
+    detectAndSetLanguage(): void;
+    /**
+     * Add custom translations
+     */
+    addTranslations(language: LokotroPayLanguage, translations: Partial<LokotroTranslations>): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LokotroLocalizationService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<LokotroLocalizationService>;
+}
+
+/**
+ * Lokotro Pay - Checkout Component
+ * Main checkout widget with clean, theme-based design
+ */
+
+declare class LokotroPayCheckoutComponent implements OnInit, OnDestroy {
+    private paymentService;
+    localization: LokotroLocalizationService;
+    title?: string;
+    titleStyle?: Record<string, string>;
+    titleBackgroundColor?: string;
+    configs: LokotroPayConfig;
+    paymentBody: LokotroPaymentBody;
+    enableHapticFeedback: boolean;
+    backgroundColor?: string;
+    padding?: string;
+    themeConfig?: LokotroPayThemeConfig;
+    language?: string;
+    response: EventEmitter<LokotroPayOnResponse>;
+    error: EventEmitter<LokotroPayOnError>;
+    closed: EventEmitter<void>;
+    state?: LokotroPaymentState;
+    isDarkTheme: boolean;
+    private stateSubscription?;
+    constructor(paymentService: LokotroPaymentService, localization: LokotroLocalizationService);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    private initializeEnvironment;
+    private initializeLocalization;
+    private subscribeToState;
+    private initializePayment;
+    get currentScreen(): string;
+    get isPaymentFormScreen(): boolean;
+    get isProcessingScreen(): boolean;
+    get canGoBack(): boolean;
+    get containerStyle(): string;
+    get titleStyleString(): string;
+    private camelToKebab;
+    onPaymentMethodSelected(method: any): void;
+    onFormSubmitted(formData: any): void;
+    onOtpVerified(otp: string): void;
+    onResendOtp(): void;
+    onBack(): void;
+    onCancel(): void;
+    onClose(): void;
+    onRetry(): void;
+    onDone(): void;
+    onContinue(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LokotroPayCheckoutComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<LokotroPayCheckoutComponent, "lokotro-pay-checkout", never, { "title": { "alias": "title"; "required": false; }; "titleStyle": { "alias": "titleStyle"; "required": false; }; "titleBackgroundColor": { "alias": "titleBackgroundColor"; "required": false; }; "configs": { "alias": "configs"; "required": false; }; "paymentBody": { "alias": "paymentBody"; "required": false; }; "enableHapticFeedback": { "alias": "enableHapticFeedback"; "required": false; }; "backgroundColor": { "alias": "backgroundColor"; "required": false; }; "padding": { "alias": "padding"; "required": false; }; "themeConfig": { "alias": "themeConfig"; "required": false; }; "language": { "alias": "language"; "required": false; }; }, { "response": "response"; "error": "error"; "closed": "closed"; }, never, never, true, never>;
+}
+
+/**
+ * Lokotro Pay - Payment Method Selection Component
+ */
+
+declare class LokotroPaymentMethodSelectionComponent {
+    localization: LokotroLocalizationService;
+    paymentMethods: LokotroPaymentMethod[];
+    selectedMethod?: LokotroPaymentMethod;
+    methodSelected: EventEmitter<LokotroPaymentMethod>;
+    constructor(localization: LokotroLocalizationService);
+    selectMethod(method: LokotroPaymentMethod): void;
+    onContinue(): void;
+    getMethodIcon(channel: LokotroPayChannel): string;
+    getMethodDescription(channel: LokotroPayChannel): string;
+    onImageError(event: Event, channel: LokotroPayChannel): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LokotroPaymentMethodSelectionComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<LokotroPaymentMethodSelectionComponent, "lokotro-payment-method-selection", never, { "paymentMethods": { "alias": "paymentMethods"; "required": false; }; "selectedMethod": { "alias": "selectedMethod"; "required": false; }; }, { "methodSelected": "methodSelected"; }, never, never, true, never>;
+}
+
+/**
+ * Lokotro Pay - Payment Form Component
+ * Handles different payment form types based on channel
+ */
+
+declare class LokotroPaymentFormComponent implements OnInit {
+    private fb;
+    localization: LokotroLocalizationService;
+    channel?: LokotroPayChannel;
+    transactionId?: string;
+    showUserInfoForm: boolean;
+    formSubmitted: EventEmitter<Record<string, unknown>>;
+    cancel: EventEmitter<void>;
+    ewalletForm: FormGroup;
+    mobileMoneyForm: FormGroup;
+    cardForm: FormGroup;
+    flashForm: FormGroup;
+    selectedMobileMoneyCountry?: LokotroCountry;
+    fullMobileMoneyPhoneNumber: string;
+    constructor(fb: FormBuilder, localization: LokotroLocalizationService);
+    ngOnInit(): void;
+    private initializeForms;
+    get isEWalletForm(): boolean;
+    get isMobileMoneyForm(): boolean;
+    get isCardForm(): boolean;
+    get isFlashForm(): boolean;
+    formatCardNumber(event: Event): void;
+    formatExpiryDate(event: Event): void;
+    submitEWalletForm(): void;
+    submitMobileMoneyForm(): void;
+    onCountryChanged(country: LokotroCountry): void;
+    onPhoneChanged(event: {
+        phoneNumber: string;
+        fullNumber: string;
+        country: LokotroCountry | null;
+    }): void;
+    submitCardForm(): void;
+    submitFlashForm(): void;
+    onCancel(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LokotroPaymentFormComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<LokotroPaymentFormComponent, "lokotro-payment-form", never, { "channel": { "alias": "channel"; "required": false; }; "transactionId": { "alias": "transactionId"; "required": false; }; "showUserInfoForm": { "alias": "showUserInfoForm"; "required": false; }; }, { "formSubmitted": "formSubmitted"; "cancel": "cancel"; }, never, never, true, never>;
+}
+
+/**
+ * Lokotro Pay - OTP Verification Component
+ */
+
+declare class LokotroOtpVerificationComponent implements OnInit, OnDestroy {
+    localization: LokotroLocalizationService;
+    transactionId?: string;
+    otpDestination?: string;
+    otpLength: number;
+    otpVerified: EventEmitter<string>;
+    resendOtp: EventEmitter<void>;
+    cancel: EventEmitter<void>;
+    otpDigits: string[];
+    resendTimer: number;
+    private timerInterval?;
+    constructor(localization: LokotroLocalizationService);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    get isOtpComplete(): boolean;
+    get otpValue(): string;
+    private startResendTimer;
+    onOtpInput(event: Event, index: number): void;
+    onOtpKeydown(event: KeyboardEvent, index: number): void;
+    onOtpPaste(event: ClipboardEvent): void;
+    onVerify(): void;
+    onResend(): void;
+    onCancelClick(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LokotroOtpVerificationComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<LokotroOtpVerificationComponent, "lokotro-otp-verification", never, { "transactionId": { "alias": "transactionId"; "required": false; }; "otpDestination": { "alias": "otpDestination"; "required": false; }; "otpLength": { "alias": "otpLength"; "required": false; }; }, { "otpVerified": "otpVerified"; "resendOtp": "resendOtp"; "cancel": "cancel"; }, never, never, true, never>;
+}
+
+declare class LokotroProcessingComponent {
+    localization: LokotroLocalizationService;
+    type: 'default' | 'mobileMoney';
+    message?: string;
+    currentStep: number;
+    constructor(localization: LokotroLocalizationService);
+    static ɵfac: i0.ɵɵFactoryDeclaration<LokotroProcessingComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<LokotroProcessingComponent, "lokotro-processing", never, { "type": { "alias": "type"; "required": false; }; "message": { "alias": "message"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Lokotro Pay - Result Component
+ * Success, Error, Warning, Info screens
+ */
+
+type ResultType = 'success' | 'error' | 'warning' | 'info';
+declare class LokotroResultComponent {
+    localization: LokotroLocalizationService;
+    type: ResultType;
+    title: string;
+    message?: string;
+    amount?: number;
+    currency?: string;
+    transactionId?: string;
+    primaryActionLabel?: string;
+    secondaryActionLabel?: string;
+    primaryAction: EventEmitter<void>;
+    secondaryAction: EventEmitter<void>;
+    constructor(localization: LokotroLocalizationService);
+    formatAmount(amount: number, currency?: string): string;
+    onPrimaryClick(): void;
+    onSecondaryClick(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LokotroResultComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<LokotroResultComponent, "lokotro-result", never, { "type": { "alias": "type"; "required": false; }; "title": { "alias": "title"; "required": false; }; "message": { "alias": "message"; "required": false; }; "amount": { "alias": "amount"; "required": false; }; "currency": { "alias": "currency"; "required": false; }; "transactionId": { "alias": "transactionId"; "required": false; }; "primaryActionLabel": { "alias": "primaryActionLabel"; "required": false; }; "secondaryActionLabel": { "alias": "secondaryActionLabel"; "required": false; }; }, { "primaryAction": "primaryAction"; "secondaryAction": "secondaryAction"; }, never, never, true, never>;
+}
+
+declare class LokotroLoadingComponent {
+    message?: string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LokotroLoadingComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<LokotroLoadingComponent, "lokotro-loading", never, { "message": { "alias": "message"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Service for fetching and caching country data
+ */
+declare class LokotroCountryService {
+    private httpClient;
+    private countriesCache?;
+    private countriesSubject;
+    private loadingRequest?;
+    /** Cache validity duration: 30 minutes */
+    private readonly cacheValidityMs;
+    /** Observable of countries list */
+    countries$: Observable<LokotroCountry[]>;
+    constructor(httpClient: LokotroHttpClientService);
+    /**
+     * Fetch countries from API with caching
+     */
+    fetchCountries(forceRefresh?: boolean): Observable<LokotroCountry[]>;
+    /**
+     * Check if cache is still valid
+     */
+    private isCacheValid;
+    /**
+     * Get cached countries synchronously
+     */
+    getCachedCountries(): LokotroCountry[];
+    /**
+     * Get country by country code (e.g., "243")
+     */
+    getCountryByCode(countryCode: string): LokotroCountry | undefined;
+    /**
+     * Get country by ID
+     */
+    getCountryById(id: string): LokotroCountry | undefined;
+    /**
+     * Get default country (DRC or first available)
+     */
+    getDefaultCountry(): LokotroCountry | undefined;
+    /**
+     * Clear the cache
+     */
+    clearCache(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LokotroCountryService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<LokotroCountryService>;
+}
+
+/**
+ * Lokotro Pay - Mobile Money Phone Input Component
+ * Phone input with country code selector and prefix validation
+ */
+
+declare class LokotroMobileMoneyPhoneInputComponent implements OnInit, OnDestroy, ControlValueAccessor, Validator {
+    private countryService;
+    localization: LokotroLocalizationService;
+    label?: string;
+    placeholder: string;
+    initialCountryCode: string;
+    showPrefixHints: boolean;
+    disabled: boolean;
+    countryChanged: EventEmitter<LokotroCountry>;
+    phoneChanged: EventEmitter<{
+        phoneNumber: string;
+        fullNumber: string;
+        country: LokotroCountry | null;
+    }>;
+    countries: LokotroCountry[];
+    selectedCountry?: LokotroCountry;
+    phoneNumber: string;
+    isLoading: boolean;
+    showCountryPicker: boolean;
+    prefixError?: string;
+    hasError: boolean;
+    private subscription?;
+    private onChange;
+    onTouched: () => void;
+    constructor(countryService: LokotroCountryService, localization: LokotroLocalizationService);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    private loadCountries;
+    getFlag(country: LokotroCountry): string;
+    getPrimaryCode(country: LokotroCountry): string;
+    getValidPrefixes(country: LokotroCountry): string[];
+    getVisiblePrefixes(country: LokotroCountry): string[];
+    getMaxChars(country: LokotroCountry): number;
+    toggleCountryPicker(): void;
+    closeCountryPicker(): void;
+    selectCountry(country: LokotroCountry, emitChange?: boolean): void;
+    onPhoneInput(event: Event): void;
+    private validatePhoneNumber;
+    private emitPhoneChange;
+    getFullPhoneNumber(): string;
+    writeValue(value: string): void;
+    registerOnChange(fn: (value: string) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    validate(control: AbstractControl): ValidationErrors | null;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LokotroMobileMoneyPhoneInputComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<LokotroMobileMoneyPhoneInputComponent, "lokotro-mobile-money-phone-input", never, { "label": { "alias": "label"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "initialCountryCode": { "alias": "initialCountryCode"; "required": false; }; "showPrefixHints": { "alias": "showPrefixHints"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; }, { "countryChanged": "countryChanged"; "phoneChanged": "phoneChanged"; }, never, never, true, never>;
+}
+
+/**
+ * Lokotro Pay - Bank Transfer Form Component
+ */
+
+declare class LokotroBankTransferFormComponent implements OnInit {
+    private fb;
+    localization: LokotroLocalizationService;
+    private paymentService;
+    showUserInfoForm: boolean;
+    formSubmitted: EventEmitter<Record<string, unknown>>;
+    cancel: EventEmitter<void>;
+    bankTransferForm: FormGroup;
+    isLoading: boolean;
+    allBanks: LokotroBank[];
+    cities: LokotroBankEntity[];
+    filteredBanks: LokotroBank[];
+    accounts: LokotroBankAccount[];
+    selectedCity: LokotroBankEntity | null;
+    selectedBank: LokotroBank | null;
+    selectedAccount: LokotroBankAccount | null;
+    constructor(fb: FormBuilder, localization: LokotroLocalizationService, paymentService: LokotroPaymentService);
+    ngOnInit(): void;
+    private initForm;
+    private fetchBanks;
+    private extractCities;
+    onCityChange(): void;
+    onBankChange(): void;
+    onAccountChange(): void;
+    onSubmit(): void;
+    onCancel(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LokotroBankTransferFormComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<LokotroBankTransferFormComponent, "lokotro-bank-transfer-form", never, { "showUserInfoForm": { "alias": "showUserInfoForm"; "required": false; }; }, { "formSubmitted": "formSubmitted"; "cancel": "cancel"; }, never, never, true, never>;
+}
+
+/**
+ * Environment configuration interface
+ */
+interface LokotroEnvConfig {
+    baseUrl: string;
+    appKey: string;
+}
+/**
+ * Configuration tokens for Lokotro Pay
+ */
+declare const LOKOTRO_PAY_CONFIG: InjectionToken<LokotroPayConfig>;
+declare const LOKOTRO_ENV_CONFIG: InjectionToken<LokotroEnvConfig>;
+/**
+ * LokotroPayModule - Main module for the Lokotro Pay Angular library
+ *
+ * This module can be used in two ways:
+ *
+ * 1. Import individual standalone components directly in your components
+ * 2. Import this module in your app module for non-standalone applications
+ *
+ * @example
+ * // Using standalone components (recommended for Angular 17+)
+ * import { LokotroCheckoutComponent } from '@lokotro/pay';
+ *
+ * @Component({
+ *   standalone: true,
+ *   imports: [LokotroCheckoutComponent],
+ *   template: `<lokotro-checkout [config]="config" (paymentComplete)="onComplete($event)" />`
+ * })
+ * export class MyComponent {}
+ *
+ * @example
+ * // Using module import
+ * import { LokotroPayModule } from '@lokotro/pay';
+ *
+ * @NgModule({
+ *   imports: [LokotroPayModule.forRoot({
+ *     env: { baseUrl: 'https://api.lokotro.com', appKey: 'your-key' }
+ *   })]
+ * })
+ * export class AppModule {}
+ */
+declare class LokotroPayModule {
+    /**
+     * Configure the Lokotro Pay module with environment and default settings
+     *
+     * @param config - Configuration object containing environment settings
+     * @returns ModuleWithProviders for the configured module
+     */
+    static forRoot(config?: Partial<{
+        env: LokotroEnvConfig;
+        defaultConfig: Partial<LokotroPayConfig>;
+    }>): ModuleWithProviders<LokotroPayModule>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LokotroPayModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<LokotroPayModule, never, [typeof i1.CommonModule, typeof i2.HttpClientModule, typeof i3.ReactiveFormsModule, typeof i3.FormsModule, typeof LokotroPayCheckoutComponent, typeof LokotroPaymentMethodSelectionComponent, typeof LokotroPaymentFormComponent, typeof LokotroOtpVerificationComponent, typeof LokotroProcessingComponent, typeof LokotroResultComponent, typeof LokotroLoadingComponent, typeof LokotroMobileMoneyPhoneInputComponent, typeof LokotroBankTransferFormComponent], [typeof LokotroPayCheckoutComponent, typeof LokotroPaymentMethodSelectionComponent, typeof LokotroPaymentFormComponent, typeof LokotroOtpVerificationComponent, typeof LokotroProcessingComponent, typeof LokotroResultComponent, typeof LokotroLoadingComponent, typeof LokotroMobileMoneyPhoneInputComponent, typeof LokotroBankTransferFormComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<LokotroPayModule>;
+}
+
+/**
+ * Lokotro Pay - Color Constants
+ * Angular version of the Flutter Lokotro Pay plugin colors
+ */
+/**
+ * Color scheme for Lokotro Pay - matching Lokotroo App design
+ */
+declare const LokotroPayColors: {
+    primary: string;
+    primaryDark: string;
+    primaryLight: string;
+    primaryVariant: string;
+    secondary: string;
+    secondaryDark: string;
+    secondaryLight: string;
+    secondaryVariant: string;
+    accent: string;
+    accentDark: string;
+    accentLight: string;
+    success: string;
+    successDark: string;
+    successLight: string;
+    error: string;
+    errorDark: string;
+    errorLight: string;
+    warning: string;
+    warningDark: string;
+    warningLight: string;
+    info: string;
+    infoDark: string;
+    infoLight: string;
+    white: string;
+    black: string;
+    grey: string;
+    greyLight: string;
+    greyDark: string;
+    textPrimaryLight: string;
+    textSecondaryLight: string;
+    textTertiaryLight: string;
+    textDisabledLight: string;
+    textPrimaryDark: string;
+    textSecondaryDark: string;
+    textTertiaryDark: string;
+    textDisabledDark: string;
+    backgroundLight: string;
+    surfaceLight: string;
+    cardLight: string;
+    backgroundDark: string;
+    surfaceDark: string;
+    cardDark: string;
+    glassLight: string;
+    glassDark: string;
+    glassBlur: string;
+    borderLight: string;
+    borderDark: string;
+    dividerLight: string;
+    dividerDark: string;
+    shadowLight: string;
+    shadowMedium: string;
+    shadowDark: string;
+    overlayLight: string;
+    overlayDark: string;
+    transactionSent: string;
+    transactionReceived: string;
+    transactionPending: string;
+    transactionFailed: string;
+};
+
+/**
+ * Environment configuration helper
+ */
+declare class LokotroPayEnv {
+    private static _config;
+    private static _isInitialized;
+    private static _customApiUrl?;
+    /**
+     * Initialize the environment configuration
+     */
+    static initialize(isProduction?: boolean, customApiUrl?: string): void;
+    /**
+     * Get current environment
+     */
+    static get environment(): string;
+    /**
+     * Check if running in production
+     */
+    static get isProduction(): boolean;
+    /**
+     * Check if running in development
+     */
+    static get isDevelopment(): boolean;
+    /**
+     * Get API base URL
+     */
+    static get apiBaseUrl(): string;
+    /**
+     * Get payment API version
+     */
+    static get paymentApiVersion(): string;
+    /**
+     * Get full payment API URL
+     */
+    static get paymentApiUrl(): string;
+    /**
+     * Check if debug mode is enabled
+     */
+    static get debugMode(): boolean;
+    /**
+     * Get log level
+     */
+    static get logLevel(): string;
+    /**
+     * Get request timeout in seconds
+     */
+    static get timeoutSeconds(): number;
+    /**
+     * Get request timeout in milliseconds
+     */
+    static get timeoutMs(): number;
+    /**
+     * API endpoints
+     */
+    static get endpoints(): {
+        collect: string;
+        transaction: string;
+        submit: string;
+        verifyOtp: string;
+        resendOtp: string;
+        fetchPaymentInfo: string;
+        processPayment: string;
+        verifyPayment: string;
+        cancelPayment: string;
+    };
+    /**
+     * Build full endpoint URL
+     */
+    static buildEndpoint(endpoint: string): string;
+    /**
+     * Default headers for API requests
+     */
+    static get defaultHeaders(): Record<string, string>;
+    /**
+     * Build headers with authorization token
+     */
+    static buildAuthHeaders(token: string): Record<string, string>;
+    /**
+     * Validate environment configuration
+     */
+    static validateConfiguration(): boolean;
+    /**
+     * Get configuration summary for debugging
+     */
+    static getConfigSummary(): Record<string, unknown>;
+    /**
+     * Reset configuration
+     */
+    static reset(): void;
+}
+
+/**
+ * Lokotro Pay - Payment Status Component
+ * Entry point for tracking payment status by payment ID only
+ * This component is used when payment was already initiated and we need to track its status
+ */
+
+/**
+ * Configuration for payment status tracking
+ */
+interface LokotroPaymentStatusConfig {
+    /** Payment ID to track */
+    paymentId: string;
+    /** API configuration */
+    config: LokotroPayConfig;
+    /** Polling interval in milliseconds (default: 5000) */
+    pollingInterval?: number;
+    /** Maximum polling attempts (default: 60 = 5 minutes with 5s interval) */
+    maxPollingAttempts?: number;
+    /** Language for translations */
+    language?: LokotroPayLanguage;
+    /** Auto-start polling on init (default: true) */
+    autoStart?: boolean;
+}
+/**
+ * Payment status response from API
+ */
+interface LokotroPaymentStatusResponse {
+    code: number;
+    message: string;
+    paymentId: string;
+    transactionId?: string;
+    status: LokotroPaymentStatus;
+    amount?: number;
+    currency?: string;
+    merchantReference?: string;
+    customerReference?: string;
+    completedAt?: string;
+    createdAt?: string;
+    metadata?: Record<string, unknown>;
+    successRedirectUrl?: string;
+    failRedirectUrl?: string;
+    notifyUrl?: string;
+}
+/**
+ * Internal screen states
+ */
+type PaymentStatusScreen = 'loading' | 'pending' | 'processing' | 'otp' | 'success' | 'error' | 'cancelled' | 'expired';
+declare class LokotroPaymentStatusComponent implements OnInit, OnDestroy {
+    private paymentService;
+    localization: LokotroLocalizationService;
+    private httpClient;
+    /**
+     * Payment status configuration
+     */
+    statusConfig: LokotroPaymentStatusConfig;
+    /**
+     * Show header with title
+     */
+    showHeader: boolean;
+    /**
+     * Show close button in header
+     */
+    showCloseButton: boolean;
+    /**
+     * Emitted when payment status changes
+     */
+    statusChange: EventEmitter<LokotroPaymentStatusResponse>;
+    /**
+     * Emitted when payment is completed successfully
+     */
+    paymentComplete: EventEmitter<LokotroPaymentStatusResponse>;
+    /**
+     * Emitted when payment fails
+     */
+    paymentFailed: EventEmitter<LokotroPaymentStatusResponse>;
+    /**
+     * Emitted when close button is clicked or done is pressed
+     */
+    onClose: EventEmitter<void>;
+    /**
+     * Emitted when user clicks done after successful payment
+     */
+    onDoneEvent: EventEmitter<LokotroPaymentStatusResponse>;
+    currentScreen: PaymentStatusScreen;
+    paymentDetails: LokotroPaymentStatusResponse | null;
+    errorMessage: string;
+    /** OTP verification state */
+    otpDestination: string;
+    rawStatus: string;
+    isVerifyingOtp: boolean;
+    private destroy$;
+    private pollingSubscription?;
+    private pollingAttempts;
+    constructor(paymentService: LokotroPaymentService, localization: LokotroLocalizationService, httpClient: LokotroHttpClientService);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    /**
+     * Initialize the service with configuration
+     */
+    private initializeService;
+    /**
+     * Start checking payment status
+     */
+    startStatusCheck(): void;
+    /**
+     * Stop polling
+     */
+    stopPolling(): void;
+    /**
+     * Check payment status via API
+     */
+    private checkPaymentStatus;
+    /**
+     * Sanitize error message to not expose sensitive information
+     * like URLs, internal codes, or technical details
+     */
+    private getSanitizedErrorMessage;
+    /**
+     * Handle status response from API
+     */
+    private handleStatusResponse;
+    /**
+     * Handle max polling attempts reached
+     */
+    private handleMaxAttemptsReached;
+    /**
+     * Retry checking status
+     */
+    retryCheck(): void;
+    /**
+     * Handle done button click
+     */
+    onDone(): void;
+    /**
+     * Handle OTP verification
+     */
+    onOtpVerified(otp: string): void;
+    /**
+     * Handle OTP resend
+     */
+    onResendOtp(): void;
+    /**
+     * Handle OTP cancellation
+     */
+    onOtpCancel(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LokotroPaymentStatusComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<LokotroPaymentStatusComponent, "lokotro-payment-status", never, { "statusConfig": { "alias": "statusConfig"; "required": false; }; "showHeader": { "alias": "showHeader"; "required": false; }; "showCloseButton": { "alias": "showCloseButton"; "required": false; }; }, { "statusChange": "statusChange"; "paymentComplete": "paymentComplete"; "paymentFailed": "paymentFailed"; "onClose": "onClose"; "onDoneEvent": "onDoneEvent"; }, never, never, true, never>;
+}
+
+export { LOKOTRO_ENV_CONFIG, LOKOTRO_PAY_CONFIG, LokotroBankTransferFormComponent, LokotroCountryService, LokotroCountryUtils, LokotroHttpClientService, LokotroLoadingComponent, LokotroLocalizationService, LokotroMobileMoneyPhoneInputComponent, LokotroOtpVerificationComponent, LokotroPayApiResponseCode, LokotroPayApiResponseCodeInfo, LokotroPayChannel, LokotroPayChannelInfo, LokotroPayCheckoutComponent, LokotroPayColors, LokotroPayEnv, LokotroPayFillingInfo, LokotroPayLanguage, LokotroPayLanguageInfo, LokotroPayModule, LokotroPayResultScreen, LokotroPayScreenNavigation, LokotroPayScreenNavigationInfo, LokotroPaymentFormComponent, LokotroPaymentMethodSelectionComponent, LokotroPaymentService, LokotroPaymentStatus, LokotroPaymentStatusComponent, LokotroProcessingComponent, LokotroResultComponent };
+export type { LokotroCheckoutConfig, LokotroCountry, LokotroCountryCode, LokotroHttpResponse, LokotroMerchantInfo, LokotroOtpVerifyRequest, LokotroOtpVerifyResponse, LokotroPayConfig, LokotroPayError, LokotroPayOnError, LokotroPayOnResponse, LokotroPayResponse, LokotroPayThemeConfig, LokotroPaymentBody, LokotroPaymentFormData, LokotroPaymentInfo, LokotroPaymentMethod, LokotroPaymentMethodListItem, LokotroPaymentStatusConfig, LokotroPaymentStatusResponse, LokotroPaymentSubmitRequest, LokotroPaymentSubmitResponse, LokotroPhonePrefix, LokotroRefCountry, LokotroTransactionDetails };