joopjs 2.0.0

package/dist/banking/index.d.ts

@@ -0,0 +1,1530 @@
+export { e as JoopCsvStatementConfig, f as JoopFraudConfig, a as JoopFraudDetection, g as JoopFraudLevel, h as JoopFraudResult, i as JoopFraudSignalResult, j as JoopOBAccount, k as JoopOBAccountType, l as JoopOBConsentRequest, m as JoopOBConsentStatus, n as JoopOBCredentials, o as JoopOBPaymentRequest, p as JoopOBPaymentStatus, q as JoopOBTransaction, b as JoopOpenBankingClient, c as JoopPaymentOrchestrator, r as JoopPaymentOrchestratorConfig, s as JoopPaymentRequest, t as JoopPaymentSession, u as JoopPaymentStep, v as JoopReceiptData, A as JoopReceiptLine, J as JoopReceiptService, d as JoopStatementParser, w as JoopStatementResult, x as JoopThreeDsResult, B as JoopTransaction, y as JoopTransactionSignal, z as JoopTxnType } from '../statement-parser-BHQtXwCM.js';
+import { J as JoopObservable, b as JoopSubject, a as JoopBehaviorSubject } from '../index-Dz0gOur2.js';
+
+declare function maskCard(cardNumber: string, showLast?: number): string;
+declare function formatCard(cardNumber: string): string;
+declare function maskIban(iban: string, showChars?: number): string;
+declare function maskAccountNumber(account: string, showLast?: number): string;
+declare function maskEmail(email: string): string;
+declare function maskPhone(phone: string, showLast?: number): string;
+declare function maskName(name: string): string;
+declare function validateNric(nric: string): boolean;
+declare function maskNric(nric: string): string;
+declare function validateMyKad(ic: string): boolean;
+declare function maskMyKad(ic: string): string;
+declare function formatMyKad(ic: string): string;
+
+/** Mask a string showing the first N and last M characters, masking everything in between.
+ *  maskRange('1234567890', 2, 4) → '12****7890'
+ *  maskRange('1234567890', 0, 4) → '******7890'
+ *  maskRange('1234567890', 2, 0) → '12********'
+ */
+declare function maskRange(value: string, firstVisible: number, lastVisible: number, maskChar?: string): string;
+/** Show only the last N characters.
+ *  maskShowLast('1234567890', 4) → '******7890'
+ */
+declare function maskShowLast(value: string, n: number, maskChar?: string): string;
+/** Show only the first N characters.
+ *  maskShowFirst('1234567890', 3) → '123*******'
+ */
+declare function maskShowFirst(value: string, n: number, maskChar?: string): string;
+/** Pattern-based masking using a format string.
+ *  '#' = reveal original character, 'X' = mask.
+ *  maskPattern('4532015112830366', '####XXXXXXXX####') → '4532********0366'
+ *  maskPattern('ABCPG1234C', 'XX*****XX*') → 'AB*****34*'  (any non-# char = mask)
+ *
+ *  Pattern characters:
+ *    '#' — show original character
+ *    '*' / 'X' / 'x' — replace with maskChar
+ *    Any other char is passed through as-is (separator)
+ */
+declare function maskPattern(value: string, pattern: string, maskChar?: string): string;
+/** Keep middle characters visible, mask the edges.
+ *  maskKeepMiddle('1234567890', 4) → '***4567***'
+ */
+declare function maskKeepMiddle(value: string, visibleCount: number, maskChar?: string): string;
+/** Mask every other character (interleaved masking).
+ *  maskInterleaved('1234567890') → '1*3*5*7*9*'
+ */
+declare function maskInterleaved(value: string, maskChar?: string): string;
+/** Mask all but keep separators in place (useful for formatted IBANs, phones etc).
+ *  maskKeepSeparators('GB29 NWBK 6016 1331', 4) → 'GB29 **** **** 1331'
+ */
+declare function maskKeepSeparators(value: string, lastVisible: number, separators?: string, maskChar?: string): string;
+
+declare function validateIban(iban: string): boolean;
+declare function formatIban(iban: string): string;
+declare function getIbanCountry(iban: string): string;
+declare function parseIban(iban: string): {
+    country: string;
+    checkDigits: string;
+    bban: string;
+} | null;
+declare function getSupportedIbanCountries(): string[];
+
+interface JoopCurrencyFormatOptions {
+    currency: string;
+    locale?: string;
+    showSymbol?: boolean;
+    minimumFractionDigits?: number;
+    maximumFractionDigits?: number;
+}
+declare function formatCurrency(amount: number | string, options: JoopCurrencyFormatOptions): string;
+declare function parseCurrencyString(value: string): number;
+declare function convertCurrency(amount: number, rate: number, decimals?: number): number;
+declare function getCurrencySymbol(currency: string, locale?: string): string;
+declare function formatAmount(amount: number, decimals?: number, locale?: string): string;
+
+declare function safeAdd(a: number, b: number, decimals?: number): number;
+declare function safeSubtract(a: number, b: number, decimals?: number): number;
+declare function safeMultiply(a: number, b: number, decimals?: number): number;
+declare function safeDivide(a: number, b: number, decimals?: number): number;
+declare function roundAmount(amount: number, decimals?: number): number;
+declare function isValidAmount(value: unknown): boolean;
+declare function clampAmount(amount: number, min: number, max: number): number;
+declare function toMinorUnits(amount: number, decimalPlaces?: number): number;
+declare function fromMinorUnits(amount: number, decimalPlaces?: number): number;
+declare function sumAmounts(...amounts: number[]): number;
+
+interface JoopTransactionRef {
+    id: string;
+    timestamp: number;
+    prefix: string;
+    full: string;
+}
+declare function generateTransactionId(prefix?: string): JoopTransactionRef;
+declare function generateReferenceNumber(length?: number): string;
+declare function parseTransactionId(id: string): {
+    prefix: string;
+    timestamp: number;
+    random: string;
+} | null;
+declare function isValidTransactionId(id: string): boolean;
+declare function generateBatchId(): string;
+
+type JoopCardNetwork = 'visa' | 'mastercard' | 'amex' | 'discover' | 'unionpay' | 'jcb' | 'diners' | 'maestro' | 'unknown';
+interface JoopCardInfo {
+    network: JoopCardNetwork;
+    valid: boolean;
+    lengths: number[];
+    cvvLength: number;
+    formatted: string;
+}
+/** Validate a card number using the Luhn algorithm */
+declare function validateLuhn(cardNumber: string): boolean;
+/** Compute the Luhn check digit for a partial card number */
+declare function luhnCheckDigit(partial: string): number;
+/** Detect the card network from the card number prefix */
+declare function getCardNetwork(cardNumber: string): JoopCardNetwork;
+/** Get full card validation info */
+declare function getCardInfo(cardNumber: string): JoopCardInfo;
+/** Format card number with spaces (e.g. 4111 1111 1111 1111 or 3714 496353 98431 for Amex) */
+declare function formatCardNumber(cardNumber: string): string;
+/** Validate card expiry (MM/YY or MM/YYYY) */
+declare function isCardExpired(month: number | string, year: number | string): boolean;
+/** Validate a CVV/CVC value */
+declare function validateCvv(cvv: string, network?: JoopCardNetwork): boolean;
+
+type JoopBeneficiaryType = 'domestic' | 'international' | 'upi' | 'mobile' | 'wallet' | 'crypto';
+interface JoopBeneficiary {
+    id: string;
+    name: string;
+    nickname?: string;
+    type: JoopBeneficiaryType;
+    accountNumber?: string;
+    iban?: string;
+    bic?: string;
+    routingNumber?: string;
+    sortCode?: string;
+    bankName?: string;
+    bankCode?: string;
+    branchCode?: string;
+    upiId?: string;
+    mobile?: string;
+    email?: string;
+    walletId?: string;
+    currency?: string;
+    country?: string;
+    group?: string;
+    isFavorite: boolean;
+    isVerified: boolean;
+    transferLimit?: number;
+    notes?: string;
+    createdAt: number;
+    updatedAt: number;
+    lastUsedAt?: number;
+    useCount: number;
+}
+interface JoopBeneficiaryValidation {
+    valid: boolean;
+    errors: string[];
+}
+declare class JoopBeneficiaryService {
+    private _beneficiaries;
+    private _list$;
+    add(data: Omit<JoopBeneficiary, 'id' | 'createdAt' | 'updatedAt' | 'useCount'>): JoopBeneficiary;
+    update(id: string, patch: Partial<Omit<JoopBeneficiary, 'id' | 'createdAt'>>): JoopBeneficiary;
+    remove(id: string): void;
+    get(id: string): JoopBeneficiary | undefined;
+    getAll(): JoopBeneficiary[];
+    getByType(type: JoopBeneficiaryType): JoopBeneficiary[];
+    getByGroup(group: string): JoopBeneficiary[];
+    getFavorites(): JoopBeneficiary[];
+    getRecent(limit?: number): JoopBeneficiary[];
+    getFrequent(limit?: number): JoopBeneficiary[];
+    search(query: string): JoopBeneficiary[];
+    toggleFavorite(id: string): JoopBeneficiary;
+    verify(id: string): JoopBeneficiary;
+    markUsed(id: string): void;
+    getGroups(): string[];
+    count(): number;
+    validate(b: Partial<JoopBeneficiary>): JoopBeneficiaryValidation;
+    beneficiaries$(): JoopObservable<JoopBeneficiary[]>;
+    private _get;
+    private _emit;
+}
+
+type JoopRecurrenceFrequency = 'once' | 'daily' | 'weekly' | 'biweekly' | 'monthly' | 'quarterly' | 'annually';
+type JoopScheduledPaymentStatus = 'active' | 'paused' | 'completed' | 'cancelled' | 'failed';
+interface JoopScheduledPayment {
+    id: string;
+    name: string;
+    fromAccount: string;
+    toAccount: string;
+    beneficiaryId?: string;
+    amount: number;
+    currency: string;
+    frequency: JoopRecurrenceFrequency;
+    startDate: number;
+    endDate?: number;
+    nextExecutionDate: number;
+    lastExecutionDate?: number;
+    executionCount: number;
+    maxExecutions?: number;
+    status: JoopScheduledPaymentStatus;
+    reference?: string;
+    description?: string;
+    createdAt: number;
+    updatedAt: number;
+}
+interface JoopPaymentExecution {
+    id: string;
+    paymentId: string;
+    executedAt: number;
+    amount: number;
+    currency: string;
+    status: 'success' | 'failed';
+    reference: string;
+    error?: string;
+}
+declare class JoopScheduledPaymentService {
+    private _payments;
+    private _executions;
+    private _payments$;
+    private _due$;
+    schedule(data: Omit<JoopScheduledPayment, 'id' | 'nextExecutionDate' | 'executionCount' | 'createdAt' | 'updatedAt' | 'status'>): JoopScheduledPayment;
+    update(id: string, patch: Partial<Omit<JoopScheduledPayment, 'id' | 'createdAt'>>): JoopScheduledPayment;
+    cancel(id: string): void;
+    pause(id: string): void;
+    resume(id: string): void;
+    get(id: string): JoopScheduledPayment | undefined;
+    getAll(): JoopScheduledPayment[];
+    getActive(): JoopScheduledPayment[];
+    getDue(asOf?: Date): JoopScheduledPayment[];
+    getUpcoming(days?: number, asOf?: Date): JoopScheduledPayment[];
+    recordExecution(paymentId: string, status: 'success' | 'failed', error?: string): JoopPaymentExecution;
+    getExecutionHistory(paymentId: string): JoopPaymentExecution[];
+    computeNextDate(current: number, frequency: JoopRecurrenceFrequency): number;
+    getSchedulePreview(startDate: number, frequency: JoopRecurrenceFrequency, count?: number, endDate?: number): number[];
+    payments$(): JoopObservable<JoopScheduledPayment[]>;
+    due$(): JoopObservable<JoopScheduledPayment>;
+    private _get;
+    private _emit;
+}
+
+type JoopCardStatus = 'active' | 'frozen' | 'blocked' | 'expired' | 'pending';
+type JoopCardType = 'physical' | 'virtual';
+type JoopManagedCardNetwork = 'visa' | 'mastercard' | 'amex' | 'discover' | 'unknown';
+interface JoopCardSpendingLimits {
+    daily?: number;
+    weekly?: number;
+    monthly?: number;
+    perTransaction?: number;
+}
+interface JoopCardControls {
+    onlinePayments: boolean;
+    internationalPayments: boolean;
+    contactlessPayments: boolean;
+    atmWithdrawals: boolean;
+    ecommercePayments: boolean;
+}
+interface JoopManagedCard {
+    id: string;
+    cardNumber: string;
+    last4: string;
+    network: JoopManagedCardNetwork;
+    type: JoopCardType;
+    holderName: string;
+    expiryMonth: number;
+    expiryYear: number;
+    status: JoopCardStatus;
+    accountId: string;
+    spendingLimits: JoopCardSpendingLimits;
+    controls: JoopCardControls;
+    currency?: string;
+    createdAt: number;
+    updatedAt: number;
+    frozenAt?: number;
+    frozenReason?: string;
+    blockedAt?: number;
+}
+interface JoopCardTransactionCheck {
+    allowed: boolean;
+    reason?: string;
+}
+declare class JoopCardManagementService {
+    private _cards;
+    private _cards$;
+    add(data: Omit<JoopManagedCard, 'id' | 'createdAt' | 'updatedAt'>): JoopManagedCard;
+    get(id: string): JoopManagedCard | undefined;
+    getAll(): JoopManagedCard[];
+    getByAccount(accountId: string): JoopManagedCard[];
+    getActive(): JoopManagedCard[];
+    remove(id: string): void;
+    freeze(id: string, reason?: string): JoopManagedCard;
+    unfreeze(id: string): JoopManagedCard;
+    block(id: string): JoopManagedCard;
+    setSpendingLimits(id: string, limits: JoopCardSpendingLimits): JoopManagedCard;
+    setControls(id: string, controls: Partial<JoopCardControls>): JoopManagedCard;
+    generateVirtual(accountId: string, holderName: string, options?: {
+        expiryMonths?: number;
+        currency?: string;
+    }): JoopManagedCard;
+    isExpired(id: string): boolean;
+    canTransact(id: string, amount: number, type: keyof Omit<JoopCardControls, 'ecommercePayments'> | 'ecommerce'): JoopCardTransactionCheck;
+    validatePin(pin: string): boolean;
+    cards$(): JoopObservable<JoopManagedCard[]>;
+    private _require;
+    private _update;
+    private _emit;
+}
+
+type JoopStatementFormat = 'text' | 'csv' | 'html';
+type JoopTransactionType = 'credit' | 'debit';
+interface JoopStatementTransaction {
+    id: string;
+    date: number;
+    description: string;
+    type: JoopTransactionType;
+    amount: number;
+    currency: string;
+    reference?: string;
+    category?: string;
+}
+interface JoopStatementEntry extends JoopStatementTransaction {
+    runningBalance: number;
+}
+interface JoopStatementOptions {
+    accountId: string;
+    accountName?: string;
+    accountNumber?: string;
+    currency: string;
+    openingBalance: number;
+    fromDate: number;
+    toDate: number;
+    transactions: JoopStatementTransaction[];
+}
+interface JoopStatement {
+    accountId: string;
+    accountName: string;
+    accountNumber: string;
+    currency: string;
+    fromDate: number;
+    toDate: number;
+    openingBalance: number;
+    closingBalance: number;
+    totalCredits: number;
+    totalDebits: number;
+    transactionCount: number;
+    entries: JoopStatementEntry[];
+    generatedAt: number;
+}
+declare class JoopStatementGeneratorService {
+    generate(options: JoopStatementOptions): JoopStatement;
+    render(statement: JoopStatement, format?: JoopStatementFormat): string;
+    getSummary(statement: JoopStatement): Record<string, number>;
+    getTopCategories(statement: JoopStatement, limit?: number): Array<{
+        category: string;
+        total: number;
+    }>;
+    private _renderText;
+    private _renderCsv;
+    private _renderHtml;
+}
+
+type JoopNotificationType = 'info' | 'success' | 'warning' | 'error' | 'transfer' | 'security' | 'promo' | 'system';
+type JoopNotificationPriority = 'low' | 'normal' | 'high' | 'urgent';
+interface JoopNotification {
+    id: string;
+    type: JoopNotificationType;
+    title: string;
+    body: string;
+    priority: JoopNotificationPriority;
+    category?: string;
+    imageUrl?: string;
+    actionUrl?: string;
+    actionLabel?: string;
+    metadata?: Record<string, unknown>;
+    isRead: boolean;
+    isDismissed: boolean;
+    createdAt: number;
+    readAt?: number;
+    expiresAt?: number;
+}
+interface JoopNotificationSummary {
+    total: number;
+    unread: number;
+    byType: Record<JoopNotificationType, number>;
+    byPriority: Record<JoopNotificationPriority, number>;
+}
+declare class JoopNotificationCenterService {
+    private _notifications;
+    private _notifications$;
+    private _maxItems;
+    constructor(maxItems?: number);
+    add(data: Omit<JoopNotification, 'id' | 'isRead' | 'isDismissed' | 'createdAt'>): JoopNotification;
+    get(id: string): JoopNotification | undefined;
+    getAll(includeExpired?: boolean): JoopNotification[];
+    getUnread(): JoopNotification[];
+    getByType(type: JoopNotificationType): JoopNotification[];
+    getByCategory(category: string): JoopNotification[];
+    getByPriority(priority: JoopNotificationPriority): JoopNotification[];
+    markRead(id: string): void;
+    markAllRead(): void;
+    dismiss(id: string): void;
+    dismissAll(): void;
+    unreadCount(): number;
+    getSummary(): JoopNotificationSummary;
+    purgeExpired(): number;
+    clear(): void;
+    notifications$(): JoopObservable<JoopNotification[]>;
+    private _emit;
+}
+
+type JoopDisputeStatus = 'open' | 'under-review' | 'resolved' | 'rejected' | 'escalated' | 'closed';
+type JoopDisputeReason = 'unauthorized-transaction' | 'duplicate-charge' | 'goods-not-received' | 'goods-not-as-described' | 'amount-mismatch' | 'cancelled-subscription' | 'atm-withdrawal-discrepancy' | 'other';
+interface JoopDisputeEvidence {
+    id: string;
+    type: 'screenshot' | 'receipt' | 'email' | 'document' | 'photo' | 'other';
+    name: string;
+    url?: string;
+    base64?: string;
+    uploadedAt: number;
+}
+interface JoopDispute {
+    id: string;
+    referenceNumber: string;
+    transactionId?: string;
+    transactionDate?: number;
+    amount: number;
+    currency: string;
+    merchantName?: string;
+    reason: JoopDisputeReason;
+    description: string;
+    status: JoopDisputeStatus;
+    evidence: JoopDisputeEvidence[];
+    resolution?: string;
+    rejectionReason?: string;
+    escalationReason?: string;
+    assignedTo?: string;
+    createdAt: number;
+    updatedAt: number;
+    resolvedAt?: number;
+}
+interface JoopDisputeStats {
+    total: number;
+    open: number;
+    underReview: number;
+    resolved: number;
+    rejected: number;
+    escalated: number;
+    totalAmount: number;
+}
+declare class JoopDisputeService {
+    private _disputes;
+    private _disputes$;
+    private _counter;
+    create(data: Omit<JoopDispute, 'id' | 'referenceNumber' | 'status' | 'evidence' | 'createdAt' | 'updatedAt'>): JoopDispute;
+    update(id: string, patch: Partial<Pick<JoopDispute, 'description' | 'reason' | 'merchantName' | 'assignedTo'>>): JoopDispute;
+    get(id: string): JoopDispute | undefined;
+    getByRef(ref: string): JoopDispute | undefined;
+    getAll(): JoopDispute[];
+    getByStatus(status: JoopDisputeStatus): JoopDispute[];
+    startReview(id: string, assignedTo?: string): JoopDispute;
+    resolve(id: string, resolution: string): JoopDispute;
+    reject(id: string, reason: string): JoopDispute;
+    escalate(id: string, reason: string): JoopDispute;
+    close(id: string): JoopDispute;
+    addEvidence(disputeId: string, evidence: Omit<JoopDisputeEvidence, 'id' | 'uploadedAt'>): JoopDisputeEvidence;
+    removeEvidence(disputeId: string, evidenceId: string): void;
+    getStats(): JoopDisputeStats;
+    disputes$(): JoopObservable<JoopDispute[]>;
+    private _require;
+    private _transition;
+    private _generateRef;
+    private _emit;
+}
+
+type JoopBillerCategory = 'electricity' | 'water' | 'gas' | 'internet' | 'mobile' | 'insurance' | 'tax' | 'subscription' | 'rent' | 'loan' | 'other';
+type JoopBillStatus = 'pending' | 'paid' | 'overdue' | 'cancelled';
+type JoopBillPaymentStatus = 'success' | 'failed' | 'pending' | 'reversed';
+interface JoopBiller {
+    id: string;
+    name: string;
+    category: JoopBillerCategory;
+    accountNumber?: string;
+    reference?: string;
+    currency: string;
+    defaultAmount?: number;
+    dueDayOfMonth?: number;
+    logoUrl?: string;
+    notes?: string;
+    isActive: boolean;
+    createdAt: number;
+}
+interface JoopBill {
+    id: string;
+    billerId: string;
+    billerName: string;
+    amount: number;
+    currency: string;
+    dueDate: number;
+    status: JoopBillStatus;
+    reference?: string;
+    createdAt: number;
+}
+interface JoopBillPayment {
+    id: string;
+    billerId: string;
+    billId?: string;
+    billerName: string;
+    amount: number;
+    currency: string;
+    status: JoopBillPaymentStatus;
+    reference: string;
+    fromAccount?: string;
+    paidAt: number;
+    errorMessage?: string;
+}
+interface JoopBillPaymentSummary {
+    totalPaidThisMonth: number;
+    totalPaidThisYear: number;
+    paymentCount: number;
+    billerCount: number;
+    currency: string;
+}
+declare class JoopBillPaymentService {
+    private _billers;
+    private _bills;
+    private _payments;
+    private _payments$;
+    addBiller(data: Omit<JoopBiller, 'id' | 'createdAt' | 'isActive'>): JoopBiller;
+    updateBiller(id: string, patch: Partial<Omit<JoopBiller, 'id' | 'createdAt'>>): JoopBiller;
+    removeBiller(id: string): void;
+    getBiller(id: string): JoopBiller | undefined;
+    getBillers(category?: JoopBillerCategory): JoopBiller[];
+    addBill(data: Omit<JoopBill, 'id' | 'createdAt' | 'status'>): JoopBill;
+    getBills(billerId?: string): JoopBill[];
+    getOverdueBills(asOf?: number): JoopBill[];
+    getUpcomingBills(days?: number, asOf?: number): JoopBill[];
+    pay(billerId: string, amount: number, options?: {
+        fromAccount?: string;
+        billId?: string;
+        reference?: string;
+    }): JoopBillPayment;
+    getPaymentHistory(billerId?: string): JoopBillPayment[];
+    getSummary(): JoopBillPaymentSummary;
+    payments$(): JoopObservable<JoopBillPayment[]>;
+    private _requireBiller;
+}
+
+type JoopPaymentUriScheme = 'upi' | 'bitcoin' | 'ethereum' | 'payto' | 'sepa' | 'generic';
+interface JoopUpiParams {
+    pa: string;
+    pn?: string;
+    am?: number;
+    cu?: string;
+    tn?: string;
+    tr?: string;
+    mc?: string;
+}
+interface JoopBitcoinParams {
+    address: string;
+    amount?: number;
+    label?: string;
+    message?: string;
+}
+interface JoopEthereumParams {
+    address: string;
+    value?: number;
+    gas?: number;
+    data?: string;
+}
+interface JoopPayToParams {
+    payId: string;
+    amount?: number;
+    currency?: string;
+    description?: string;
+}
+interface JoopSepaParams {
+    iban: string;
+    bic?: string;
+    name?: string;
+    amount?: number;
+    currency?: string;
+    reference?: string;
+    purpose?: string;
+}
+interface JoopPaymentUri {
+    scheme: JoopPaymentUriScheme;
+    raw: string;
+    isValid: boolean;
+    errors: string[];
+    upi?: JoopUpiParams;
+    bitcoin?: JoopBitcoinParams;
+    ethereum?: JoopEthereumParams;
+    payto?: JoopPayToParams;
+    sepa?: JoopSepaParams;
+    generic?: {
+        recipient?: string;
+        amount?: number;
+        currency?: string;
+        reference?: string;
+    };
+}
+declare class JoopPaymentUriService {
+    parse(uri: string): JoopPaymentUri;
+    generateUpi(params: JoopUpiParams): string;
+    generateBitcoin(params: JoopBitcoinParams): string;
+    generateEthereum(params: JoopEthereumParams): string;
+    generatePayTo(params: JoopPayToParams): string;
+    generateSepa(params: JoopSepaParams): string;
+    isValid(uri: string): boolean;
+    getScheme(uri: string): JoopPaymentUriScheme | null;
+    private _parseUpi;
+    private _parseBitcoin;
+    private _parseEthereum;
+    private _parsePayTo;
+    private _parseSepa;
+}
+
+type JoopMandateType = 'nach' | 'upi-autopay' | 'standing-instruction' | 'direct-debit';
+type JoopMandateStatus = 'pending' | 'active' | 'paused' | 'cancelled' | 'expired' | 'failed';
+type JoopMandateFrequency = 'daily' | 'weekly' | 'biweekly' | 'monthly' | 'quarterly' | 'half-yearly' | 'yearly' | 'as-presented';
+type JoopMandateExecutionStatus = 'success' | 'failed' | 'pending';
+interface JoopMandate {
+    id: string;
+    ref: string;
+    type: JoopMandateType;
+    status: JoopMandateStatus;
+    accountId: string;
+    payeeName: string;
+    payeeRef: string;
+    maxAmount: number;
+    frequency: JoopMandateFrequency;
+    startDate: number;
+    endDate?: number;
+    description?: string;
+    executionCount: number;
+    lastExecutedAt?: number;
+    nextExecutionAt?: number;
+    createdAt: number;
+    updatedAt: number;
+}
+interface JoopMandateExecution {
+    id: string;
+    mandateId: string;
+    amount: number;
+    status: JoopMandateExecutionStatus;
+    date: number;
+    failureReason?: string;
+}
+declare class JoopMandateService {
+    private _mandates;
+    private _executions;
+    private _counter;
+    private _change$;
+    create(data: {
+        type: JoopMandateType;
+        accountId: string;
+        payeeName: string;
+        payeeRef: string;
+        maxAmount: number;
+        frequency: JoopMandateFrequency;
+        startDate: number;
+        endDate?: number;
+        description?: string;
+    }): JoopMandate;
+    get(id: string): JoopMandate | undefined;
+    getAll(): JoopMandate[];
+    activate(id: string): JoopMandate;
+    cancel(id: string): JoopMandate;
+    pause(id: string): JoopMandate;
+    resume(id: string): JoopMandate;
+    fail(id: string): JoopMandate;
+    getActive(): JoopMandate[];
+    getByAccount(accountId: string): JoopMandate[];
+    getByStatus(status: JoopMandateStatus): JoopMandate[];
+    getDue(asOf?: number): JoopMandate[];
+    isExpired(mandate: JoopMandate): boolean;
+    recordExecution(mandateId: string, amount: number, status: JoopMandateExecutionStatus, failureReason?: string): JoopMandateExecution;
+    getExecutions(mandateId: string): JoopMandateExecution[];
+    computeNextDate(mandate: JoopMandate, fromDate?: number): number | undefined;
+    change$(): JoopObservable<JoopMandate>;
+    private _require;
+    private _transition;
+    private _byStatus;
+    private _computeNextDate;
+    private _generateRef;
+}
+
+type JoopSplitMethod = 'equal' | 'percentage' | 'exact' | 'shares';
+type JoopSplitStatus = 'open' | 'partial' | 'settled' | 'cancelled';
+type JoopSplitParticipantStatus = 'pending' | 'paid' | 'partial';
+interface JoopSplitParticipant {
+    id: string;
+    name: string;
+    share: number;
+    paid: number;
+    status: JoopSplitParticipantStatus;
+}
+interface JoopSplitExpense {
+    id: string;
+    title: string;
+    totalAmount: number;
+    currency: string;
+    paidBy: string;
+    method: JoopSplitMethod;
+    participants: JoopSplitParticipant[];
+    status: JoopSplitStatus;
+    notes?: string;
+    createdAt: number;
+    settledAt?: number;
+}
+interface JoopSplitSettlement {
+    from: string;
+    to: string;
+    amount: number;
+}
+interface JoopSplitBalance {
+    name: string;
+    owes: number;
+    owed: number;
+    net: number;
+}
+declare class JoopSplitPaymentService {
+    private _expenses;
+    private _change$;
+    create(title: string, totalAmount: number, paidBy: string, participantNames: string[], options?: {
+        method?: JoopSplitMethod;
+        currency?: string;
+        notes?: string;
+        amounts?: number[];
+        percentages?: number[];
+        shares?: number[];
+    }): JoopSplitExpense;
+    recordPayment(expenseId: string, participantId: string, amount: number): JoopSplitExpense;
+    settle(expenseId: string): void;
+    cancel(expenseId: string): void;
+    get(id: string): JoopSplitExpense | undefined;
+    getAll(): JoopSplitExpense[];
+    getOpen(): JoopSplitExpense[];
+    getSettlements(expenseId: string): JoopSplitSettlement[];
+    getSimplifiedSettlements(expenseId: string): JoopSplitSettlement[];
+    getBalance(name: string): JoopSplitBalance;
+    getSummary(expenseId: string): {
+        total: number;
+        paid: number;
+        remaining: number;
+        participantCount: number;
+        status: JoopSplitStatus;
+    };
+    change$(): JoopObservable<JoopSplitExpense>;
+    private _computeShares;
+    private _updateStatus;
+    private _require;
+    private _snapshot;
+}
+
+type JoopChequeStatus = 'available' | 'issued' | 'presented' | 'cleared' | 'bounced' | 'stopped' | 'cancelled' | 'expired';
+interface JoopChequeLeaf {
+    chequeNumber: string;
+    chequebookId: string;
+    accountId: string;
+    status: JoopChequeStatus;
+    issuedTo?: string;
+    amount?: number;
+    issuedAt?: number;
+    presentedAt?: number;
+    clearedAt?: number;
+    stoppedAt?: number;
+    stopReason?: string;
+    bounceReason?: string;
+    expiresAt?: number;
+    notes?: string;
+}
+interface JoopChequebook {
+    id: string;
+    accountId: string;
+    seriesStart: string;
+    seriesEnd: string;
+    leaves: JoopChequeLeaf[];
+    issuedAt: number;
+    isActive: boolean;
+}
+interface JoopChequebookStats {
+    total: number;
+    available: number;
+    issued: number;
+    presented: number;
+    cleared: number;
+    bounced: number;
+    stopped: number;
+    cancelled: number;
+    expired: number;
+}
+declare class JoopChequebookService {
+    private _books;
+    private _leafIndex;
+    private _change$;
+    addChequebook(accountId: string, seriesStart: string, seriesEnd: string): JoopChequebook;
+    getChequebook(id: string): JoopChequebook | undefined;
+    getByAccount(accountId: string): JoopChequebook[];
+    deactivateChequebook(id: string): void;
+    issueCheque(chequeNumber: string, issuedTo: string, amount: number, options?: {
+        expiresAt?: number;
+        notes?: string;
+    }): JoopChequeLeaf;
+    stopPayment(chequeNumber: string, reason: string): JoopChequeLeaf;
+    markPresented(chequeNumber: string, presentedAt?: number): JoopChequeLeaf;
+    markCleared(chequeNumber: string, clearedAt?: number): JoopChequeLeaf;
+    markBounced(chequeNumber: string, reason?: string): JoopChequeLeaf;
+    cancelCheque(chequeNumber: string): JoopChequeLeaf;
+    getLeaf(chequeNumber: string): JoopChequeLeaf | undefined;
+    getByStatus(status: JoopChequeStatus, accountId?: string): JoopChequeLeaf[];
+    getAvailableLeaves(accountId?: string): JoopChequeLeaf[];
+    isValid(chequeNumber: string): boolean;
+    getStats(accountId?: string): JoopChequebookStats;
+    change$(): JoopObservable<JoopChequeLeaf>;
+    private _requireLeaf;
+    private _generateLeaves;
+    private _snapshotBook;
+}
+
+type JoopInsuranceType = 'life' | 'health' | 'auto' | 'home' | 'travel' | 'business' | 'other';
+type JoopPolicyStatus = 'active' | 'expired' | 'cancelled' | 'lapsed' | 'pending';
+type JoopClaimStatus = 'submitted' | 'under-review' | 'approved' | 'rejected' | 'paid' | 'withdrawn';
+type JoopPremiumFrequency = 'monthly' | 'quarterly' | 'half-yearly' | 'yearly';
+interface JoopInsurancePolicy {
+    id: string;
+    type: JoopInsuranceType;
+    policyNumber: string;
+    insurer: string;
+    holderName: string;
+    coverageAmount: number;
+    premiumAmount: number;
+    premiumFrequency: JoopPremiumFrequency;
+    status: JoopPolicyStatus;
+    startDate: number;
+    endDate: number;
+    nextPremiumDate?: number;
+    deductible?: number;
+    notes?: string;
+    createdAt: number;
+    updatedAt: number;
+}
+interface JoopInsuranceClaim {
+    id: string;
+    claimNumber: string;
+    policyId: string;
+    amount: number;
+    status: JoopClaimStatus;
+    description: string;
+    documents: string[];
+    submittedAt: number;
+    resolvedAt?: number;
+    paidAmount?: number;
+    rejectionReason?: string;
+}
+interface JoopPremiumPayment {
+    id: string;
+    policyId: string;
+    amount: number;
+    date: number;
+    method?: string;
+}
+declare class JoopInsuranceService {
+    private _policies;
+    private _claims;
+    private _payments;
+    private _claimCounter;
+    private _change$;
+    addPolicy(data: Omit<JoopInsurancePolicy, 'id' | 'createdAt' | 'updatedAt'>): JoopInsurancePolicy;
+    updatePolicy(id: string, patch: Partial<Omit<JoopInsurancePolicy, 'id' | 'createdAt'>>): JoopInsurancePolicy;
+    cancelPolicy(id: string, reason?: string): JoopInsurancePolicy;
+    renewPolicy(id: string, newEndDate: number): JoopInsurancePolicy;
+    getPolicy(id: string): JoopInsurancePolicy | undefined;
+    getAll(): JoopInsurancePolicy[];
+    getActive(): JoopInsurancePolicy[];
+    getByType(type: JoopInsuranceType): JoopInsurancePolicy[];
+    getExpiring(withinDays: number, asOf?: number): JoopInsurancePolicy[];
+    fileClaim(policyId: string, amount: number, description: string, documents?: string[]): JoopInsuranceClaim;
+    updateClaim(id: string, status: JoopClaimStatus, options?: {
+        paidAmount?: number;
+        rejectionReason?: string;
+    }): JoopInsuranceClaim;
+    getClaims(policyId?: string): JoopInsuranceClaim[];
+    recordPremiumPayment(policyId: string, amount: number, method?: string): JoopPremiumPayment;
+    getPremiumHistory(policyId: string): JoopPremiumPayment[];
+    getTotalCoverage(): number;
+    getTotalAnnualPremium(): number;
+    change$(): JoopObservable<JoopInsurancePolicy>;
+    private _require;
+    private _requireClaim;
+}
+
+type JoopRemittanceStatus = 'initiated' | 'processing' | 'completed' | 'failed' | 'cancelled' | 'returned';
+type JoopRemittanceChannel = 'swift' | 'sepa' | 'ach' | 'wire' | 'crypto' | 'mobile-money' | 'cash-pickup';
+interface JoopRemittanceQuote {
+    sendAmount: number;
+    sendCurrency: string;
+    receiveAmount: number;
+    receiveCurrency: string;
+    exchangeRate: number;
+    fee: number;
+    totalDebit: number;
+    estimatedArrivalMs: number;
+    channel: JoopRemittanceChannel;
+}
+interface JoopRemittance {
+    id: string;
+    ref: string;
+    sendAmount: number;
+    sendCurrency: string;
+    receiveAmount: number;
+    receiveCurrency: string;
+    exchangeRate: number;
+    fee: number;
+    totalDebit: number;
+    status: JoopRemittanceStatus;
+    channel: JoopRemittanceChannel;
+    senderName: string;
+    senderAccount: string;
+    recipientName: string;
+    recipientAccount: string;
+    recipientBankCode?: string;
+    recipientCountry: string;
+    purposeCode?: string;
+    notes?: string;
+    initiatedAt: number;
+    completedAt?: number;
+    estimatedArrival?: number;
+}
+declare class JoopRemittanceService {
+    private _remittances;
+    private _rates;
+    private _fees;
+    private _counter;
+    private _change$;
+    setExchangeRate(from: string, to: string, rate: number): void;
+    getExchangeRate(from: string, to: string): number | null;
+    setChannelFee(channel: JoopRemittanceChannel, fee: number): void;
+    getFee(channel: JoopRemittanceChannel): number;
+    getQuote(sendAmount: number, sendCurrency: string, receiveCurrency: string, channel?: JoopRemittanceChannel): JoopRemittanceQuote;
+    initiate(data: {
+        sendAmount: number;
+        sendCurrency: string;
+        receiveCurrency: string;
+        channel: JoopRemittanceChannel;
+        senderName: string;
+        senderAccount: string;
+        recipientName: string;
+        recipientAccount: string;
+        recipientCountry: string;
+        recipientBankCode?: string;
+        purposeCode?: string;
+        notes?: string;
+    }): JoopRemittance;
+    cancel(id: string): JoopRemittance;
+    updateStatus(id: string, status: JoopRemittanceStatus, options?: {
+        notes?: string;
+    }): JoopRemittance;
+    getById(id: string): JoopRemittance | undefined;
+    getByRef(ref: string): JoopRemittance | undefined;
+    getByStatus(status: JoopRemittanceStatus): JoopRemittance[];
+    getHistory(limit?: number): JoopRemittance[];
+    getTotalSent(currency?: string): number;
+    change$(): JoopObservable<JoopRemittance>;
+    private _transition;
+    private _generateRef;
+}
+
+type JoopVirtualAccountStatus = 'active' | 'inactive' | 'closed';
+type JoopVirtualAccountPurpose = 'collection' | 'escrow' | 'payroll' | 'vendor' | 'customer' | 'project' | 'other';
+interface JoopVirtualAccount {
+    id: string;
+    accountNumber: string;
+    iban?: string;
+    parentAccountId: string;
+    label: string;
+    purpose: JoopVirtualAccountPurpose;
+    status: JoopVirtualAccountStatus;
+    currency: string;
+    collectedAmount: number;
+    expectedAmount?: number;
+    reference?: string;
+    expiresAt?: number;
+    metadata?: Record<string, string>;
+    createdAt: number;
+    updatedAt: number;
+}
+interface JoopVirtualCredit {
+    id: string;
+    virtualAccountId: string;
+    amount: number;
+    currency: string;
+    senderName?: string;
+    senderRef?: string;
+    receivedAt: number;
+    notes?: string;
+}
+declare class JoopVirtualAccountService {
+    private _accounts;
+    private _credits;
+    private _counter;
+    private _change$;
+    create(data: {
+        parentAccountId: string;
+        label: string;
+        purpose: JoopVirtualAccountPurpose;
+        currency?: string;
+        expectedAmount?: number;
+        reference?: string;
+        expiresAt?: number;
+        metadata?: Record<string, string>;
+        ibanPrefix?: string;
+    }): JoopVirtualAccount;
+    close(id: string): JoopVirtualAccount;
+    deactivate(id: string): JoopVirtualAccount;
+    activate(id: string): JoopVirtualAccount;
+    update(id: string, patch: Partial<Pick<JoopVirtualAccount, 'label' | 'expectedAmount' | 'reference' | 'expiresAt' | 'metadata'>>): JoopVirtualAccount;
+    get(id: string): JoopVirtualAccount | undefined;
+    getAll(): JoopVirtualAccount[];
+    getActive(parentAccountId?: string): JoopVirtualAccount[];
+    getByReference(reference: string): JoopVirtualAccount | undefined;
+    getByPurpose(purpose: JoopVirtualAccountPurpose): JoopVirtualAccount[];
+    getExpiring(withinMs: number, asOf?: number): JoopVirtualAccount[];
+    recordCredit(virtualAccountId: string, amount: number, options?: {
+        currency?: string;
+        senderName?: string;
+        senderRef?: string;
+        notes?: string;
+    }): JoopVirtualCredit;
+    getCredits(virtualAccountId: string): JoopVirtualCredit[];
+    getTotalCollected(virtualAccountId: string): number;
+    isFullyCollected(virtualAccountId: string): boolean;
+    generateAccountNumber(prefix?: string): string;
+    change$(): JoopObservable<JoopVirtualAccount>;
+    private _require;
+    private _setStatus;
+}
+
+type JoopAccountType = 'asset' | 'liability' | 'equity' | 'revenue' | 'expense';
+interface JoopLedgerAccount {
+    code: string;
+    name: string;
+    type: JoopAccountType;
+    description?: string;
+    createdAt: number;
+}
+interface JoopJournalLine {
+    accountCode: string;
+    debit: number;
+    credit: number;
+    description?: string;
+}
+interface JoopJournalEntry {
+    id: string;
+    ref: string;
+    description: string;
+    date: number;
+    lines: JoopJournalLine[];
+    postedAt: number;
+    postedBy?: string;
+    tags?: string[];
+}
+interface JoopTrialBalanceRow {
+    code: string;
+    name: string;
+    type: JoopAccountType;
+    totalDebits: number;
+    totalCredits: number;
+    balance: number;
+}
+interface JoopTrialBalance {
+    asOf: number;
+    rows: JoopTrialBalanceRow[];
+    totalDebits: number;
+    totalCredits: number;
+    isBalanced: boolean;
+}
+declare class JoopLedgerService {
+    private _accounts;
+    private _entries;
+    private _seq;
+    private _change$;
+    addAccount(code: string, name: string, type: JoopAccountType, description?: string): JoopLedgerAccount;
+    getAccount(code: string): JoopLedgerAccount | undefined;
+    getAccounts(): JoopLedgerAccount[];
+    removeAccount(code: string): void;
+    postEntry(description: string, lines: JoopJournalLine[], opts?: {
+        date?: number;
+        postedBy?: string;
+        tags?: string[];
+    }): JoopJournalEntry;
+    getEntry(id: string): JoopJournalEntry | undefined;
+    getJournal(from?: number, to?: number): JoopJournalEntry[];
+    getBalance(code: string): number;
+    getTrialBalance(): JoopTrialBalance;
+    getBalancesByType(type: JoopAccountType): Record<string, number>;
+    change$(): JoopSubject<JoopJournalEntry>;
+}
+
+type JoopReconItemSource = 'internal' | 'bank';
+type JoopReconMatchStatus = 'matched' | 'unmatched' | 'disputed';
+interface JoopReconItem {
+    id: string;
+    source: JoopReconItemSource;
+    date: number;
+    amount: number;
+    description: string;
+    reference?: string;
+}
+interface JoopReconMatch {
+    id: string;
+    internalId: string;
+    bankId: string;
+    matchedAt: number;
+    isManual: boolean;
+    difference: number;
+}
+interface JoopReconSession {
+    id: string;
+    accountId: string;
+    startedAt: number;
+    closedAt?: number;
+    internalItems: JoopReconItem[];
+    bankItems: JoopReconItem[];
+    matches: JoopReconMatch[];
+}
+interface JoopReconSummary {
+    sessionId: string;
+    totalInternal: number;
+    totalBank: number;
+    matchedPairs: number;
+    unmatchedInternal: number;
+    unmatchedBank: number;
+    totalDifference: number;
+    isReconciled: boolean;
+}
+declare class JoopReconciliationService {
+    private _sessions;
+    private _change$;
+    createSession(accountId: string, bankItems: Omit<JoopReconItem, 'id' | 'source'>[], internalItems?: Omit<JoopReconItem, 'id' | 'source'>[]): JoopReconSession;
+    getSession(id: string): JoopReconSession | undefined;
+    closeSession(id: string): JoopReconSession;
+    addInternalItems(sessionId: string, items: Omit<JoopReconItem, 'id' | 'source'>[]): JoopReconSession;
+    autoMatch(sessionId: string, toleranceAmount?: number, toleranceDays?: number): JoopReconMatch[];
+    manualMatch(sessionId: string, internalId: string, bankId: string): JoopReconMatch;
+    unmatch(sessionId: string, matchId: string): void;
+    getUnmatched(sessionId: string): {
+        internal: JoopReconItem[];
+        bank: JoopReconItem[];
+    };
+    getSummary(sessionId: string): JoopReconSummary;
+    change$(): JoopSubject<JoopReconSession>;
+    private _get;
+}
+
+type JoopLimitType = 'per-transaction' | 'daily' | 'weekly' | 'monthly' | 'yearly';
+type JoopLimitScope = 'account' | 'user' | 'card' | 'channel';
+interface JoopLimit {
+    id: string;
+    scope: JoopLimitScope;
+    scopeId: string;
+    type: JoopLimitType;
+    maxAmount: number;
+    currency: string;
+    enabled: boolean;
+    createdAt: number;
+    notes?: string;
+}
+interface JoopLimitCheckResult {
+    allowed: boolean;
+    limit: JoopLimit;
+    currentUsage: number;
+    remaining: number;
+    requestedAmount: number;
+    reason?: string;
+}
+interface JoopUsageRecord {
+    limitId: string;
+    amount: number;
+    recordedAt: number;
+    reference?: string;
+}
+interface JoopUsageSummary {
+    scope: JoopLimitScope;
+    scopeId: string;
+    limits: Array<{
+        limitId: string;
+        type: JoopLimitType;
+        maxAmount: number;
+        used: number;
+        remaining: number;
+        utilizationPercent: number;
+    }>;
+}
+declare class JoopLimitManagementService {
+    private _limits;
+    private _usage;
+    private _change$;
+    setLimit(scope: JoopLimitScope, scopeId: string, type: JoopLimitType, maxAmount: number, currency?: string, notes?: string): JoopLimit;
+    getLimit(id: string): JoopLimit | undefined;
+    getLimits(scope?: JoopLimitScope, scopeId?: string): JoopLimit[];
+    removeLimit(limitId: string): void;
+    enableLimit(limitId: string): void;
+    disableLimit(limitId: string): void;
+    checkLimit(scope: JoopLimitScope, scopeId: string, type: JoopLimitType, amount: number, currency?: string): JoopLimitCheckResult | null;
+    checkAllLimits(scope: JoopLimitScope, scopeId: string, amount: number, currency?: string): JoopLimitCheckResult[];
+    recordUsage(scope: JoopLimitScope, scopeId: string, type: JoopLimitType, amount: number, currency?: string, reference?: string): void;
+    resetUsage(limitId: string): void;
+    getUsageSummary(scope: JoopLimitScope, scopeId: string): JoopUsageSummary;
+    change$(): JoopSubject<JoopLimit>;
+    private _findLimit;
+    private _currentUsage;
+    private _toggle;
+}
+
+type JoopStandingOrderStatus = 'active' | 'paused' | 'cancelled' | 'completed';
+type JoopStandingOrderFrequency = 'daily' | 'weekly' | 'biweekly' | 'monthly' | 'quarterly' | 'half-yearly' | 'yearly';
+type JoopExecutionStatus = 'success' | 'failed' | 'skipped';
+interface JoopStandingOrder {
+    id: string;
+    ref: string;
+    fromAccount: string;
+    toAccount: string;
+    toBeneficiaryName: string;
+    amount: number;
+    currency: string;
+    frequency: JoopStandingOrderFrequency;
+    startDate: number;
+    endDate?: number;
+    status: JoopStandingOrderStatus;
+    nextExecutionAt?: number;
+    executionCount: number;
+    maxExecutions?: number;
+    reference?: string;
+    notes?: string;
+    createdAt: number;
+}
+interface JoopStandingOrderExecution {
+    id: string;
+    orderId: string;
+    executedAt: number;
+    amount: number;
+    currency: string;
+    status: JoopExecutionStatus;
+    failureReason?: string;
+    transactionRef?: string;
+}
+declare class JoopStandingOrderService {
+    private _orders;
+    private _executions;
+    private _seq;
+    private _change$;
+    create(params: {
+        fromAccount: string;
+        toAccount: string;
+        toBeneficiaryName: string;
+        amount: number;
+        currency?: string;
+        frequency: JoopStandingOrderFrequency;
+        startDate: number;
+        endDate?: number;
+        maxExecutions?: number;
+        reference?: string;
+        notes?: string;
+    }): JoopStandingOrder;
+    update(id: string, patch: Partial<Pick<JoopStandingOrder, 'amount' | 'toBeneficiaryName' | 'endDate' | 'maxExecutions' | 'reference' | 'notes'>>): JoopStandingOrder;
+    pause(id: string): JoopStandingOrder;
+    resume(id: string): JoopStandingOrder;
+    cancel(id: string): JoopStandingOrder;
+    execute(id: string, status?: JoopExecutionStatus, opts?: {
+        failureReason?: string;
+        transactionRef?: string;
+    }): JoopStandingOrderExecution;
+    get(id: string): JoopStandingOrder | undefined;
+    getAll(): JoopStandingOrder[];
+    getActive(): JoopStandingOrder[];
+    getByAccount(accountId: string): JoopStandingOrder[];
+    getDue(asOf?: number): JoopStandingOrder[];
+    getExecutions(orderId: string): JoopStandingOrderExecution[];
+    change$(): JoopSubject<JoopStandingOrder>;
+    private _get;
+}
+
+type JoopLoanAccountStatus = 'active' | 'closed' | 'defaulted' | 'written-off';
+type JoopRepaymentStatus = 'pending' | 'paid' | 'partial' | 'overdue' | 'waived';
+interface JoopLoanAccount {
+    id: string;
+    ref: string;
+    borrowerName: string;
+    borrowerId: string;
+    principalAmount: number;
+    outstandingPrincipal: number;
+    annualInterestRatePercent: number;
+    tenureMonths: number;
+    disbursedAt: number;
+    status: JoopLoanAccountStatus;
+    emiAmount: number;
+    currency: string;
+    nextDueDate: number;
+    totalPaid: number;
+    penaltyRatePercent: number;
+    notes?: string;
+}
+interface JoopInstallment {
+    installmentNumber: number;
+    dueDate: number;
+    principalComponent: number;
+    interestComponent: number;
+    totalDue: number;
+    outstandingAfter: number;
+    status: JoopRepaymentStatus;
+    paidAmount: number;
+    paidAt?: number;
+}
+interface JoopLoanPayment {
+    id: string;
+    loanId: string;
+    amount: number;
+    paidAt: number;
+    interestPaid: number;
+    principalPaid: number;
+    penaltyPaid: number;
+    reference?: string;
+}
+interface JoopLoanStatement {
+    loan: JoopLoanAccount;
+    schedule: JoopInstallment[];
+    payments: JoopLoanPayment[];
+    outstandingPrincipal: number;
+    accruedInterest: number;
+    totalOverdue: number;
+}
+declare class JoopLoanServicingService {
+    private _loans;
+    private _schedules;
+    private _payments;
+    private _seq;
+    private _change$;
+    createLoan(params: {
+        borrowerName: string;
+        borrowerId: string;
+        principalAmount: number;
+        annualInterestRatePercent: number;
+        tenureMonths: number;
+        disbursedAt?: number;
+        currency?: string;
+        penaltyRatePercent?: number;
+        notes?: string;
+    }): JoopLoanAccount;
+    recordPayment(loanId: string, amount: number, opts?: {
+        paidAt?: number;
+        reference?: string;
+    }): JoopLoanPayment;
+    waveInstallment(loanId: string, installmentNumber: number): void;
+    markDefaulted(loanId: string): JoopLoanAccount;
+    getLoan(id: string): JoopLoanAccount | undefined;
+    getAll(): JoopLoanAccount[];
+    getActive(): JoopLoanAccount[];
+    getByBorrower(borrowerId: string): JoopLoanAccount[];
+    getSchedule(loanId: string): JoopInstallment[];
+    getPendingInstallments(loanId: string): JoopInstallment[];
+    getOverdueInstallments(loanId: string): JoopInstallment[];
+    getOutstandingBalance(loanId: string): number;
+    getAccruedInterest(loanId: string, asOf?: number): number;
+    getLoanStatement(loanId: string): JoopLoanStatement;
+    change$(): JoopSubject<JoopLoanAccount>;
+    private _get;
+    private _markOverdue;
+}
+
+type JoopWalletStatus = 'active' | 'frozen' | 'closed';
+type JoopWalletTxnType = 'topup' | 'transfer-out' | 'transfer-in' | 'payment' | 'refund' | 'cashback' | 'withdrawal' | 'fee';
+interface JoopWallet {
+    id: string;
+    userId: string;
+    label?: string;
+    currency: string;
+    balance: number;
+    status: JoopWalletStatus;
+    createdAt: number;
+    dailyLimit?: number;
+    monthlyLimit?: number;
+}
+interface JoopWalletTransaction {
+    id: string;
+    walletId: string;
+    type: JoopWalletTxnType;
+    amount: number;
+    balanceBefore: number;
+    balanceAfter: number;
+    description: string;
+    reference?: string;
+    counterpartyId?: string;
+    counterpartyName?: string;
+    createdAt: number;
+    metadata?: Record<string, unknown>;
+}
+interface JoopTransferResult {
+    fromTxn: JoopWalletTransaction;
+    toTxn: JoopWalletTransaction;
+}
+declare class JoopDigitalWalletService {
+    private _wallets;
+    private _transactions;
+    private _balance$;
+    createWallet(userId: string, opts?: {
+        label?: string;
+        currency?: string;
+        dailyLimit?: number;
+        monthlyLimit?: number;
+    }): JoopWallet;
+    freeze(walletId: string): JoopWallet;
+    unfreeze(walletId: string): JoopWallet;
+    close(walletId: string): JoopWallet;
+    updateLimits(walletId: string, limits: {
+        dailyLimit?: number;
+        monthlyLimit?: number;
+    }): JoopWallet;
+    topUp(walletId: string, amount: number, opts?: {
+        reference?: string;
+        description?: string;
+    }): JoopWalletTransaction;
+    withdraw(walletId: string, amount: number, opts?: {
+        reference?: string;
+        description?: string;
+    }): JoopWalletTransaction;
+    pay(walletId: string, amount: number, merchantId: string, merchantName: string, opts?: {
+        reference?: string;
+        metadata?: Record<string, unknown>;
+    }): JoopWalletTransaction;
+    transfer(fromWalletId: string, toWalletId: string, amount: number, opts?: {
+        note?: string;
+        reference?: string;
+    }): JoopTransferResult;
+    refund(originalTxnId: string, opts?: {
+        amount?: number;
+        reason?: string;
+    }): JoopWalletTransaction;
+    getWallet(id: string): JoopWallet | undefined;
+    getWalletsByUser(userId: string): JoopWallet[];
+    getBalance(walletId: string): number;
+    getTransactions(walletId: string, limit?: number): JoopWalletTransaction[];
+    getTotalSpent(walletId: string, from?: number, to?: number): number;
+    getTotalTopUp(walletId: string): number;
+    balance$(): JoopBehaviorSubject<{
+        walletId: string;
+        balance: number;
+    } | null>;
+    private _get;
+    private _getActive;
+    private _assertSufficientBalance;
+    private _record;
+}
+
+type JoopForwardType = 'buy' | 'sell';
+type JoopForwardStatus = 'open' | 'settled' | 'cancelled' | 'expired';
+interface JoopFxForward {
+    id: string;
+    ref: string;
+    type: JoopForwardType;
+    baseCurrency: string;
+    quoteCurrency: string;
+    notionalAmount: number;
+    contractRate: number;
+    spotRateAtCreation: number;
+    maturityDate: number;
+    status: JoopForwardStatus;
+    counterpartyId?: string;
+    counterpartyName?: string;
+    createdAt: number;
+    settledAt?: number;
+    settlementSpotRate?: number;
+    pnl?: number;
+    notes?: string;
+}
+interface JoopForwardSettlement {
+    forwardId: string;
+    ref: string;
+    settledAt: number;
+    contractRate: number;
+    spotRate: number;
+    notionalAmount: number;
+    baseCurrency: string;
+    quoteCurrency: string;
+    pnl: number;
+}
+interface JoopFxExposure {
+    currency: string;
+    type: JoopForwardType;
+    totalNotional: number;
+    contractCount: number;
+}
+declare class JoopFxForwardService {
+    private _forwards;
+    private _settlements;
+    private _spotRates;
+    private _seq;
+    private _change$;
+    setSpotRate(baseCurrency: string, quoteCurrency: string, rate: number): void;
+    getSpotRate(baseCurrency: string, quoteCurrency: string): number | undefined;
+    createForward(params: {
+        type: JoopForwardType;
+        baseCurrency: string;
+        quoteCurrency: string;
+        notionalAmount: number;
+        contractRate: number;
+        maturityDate: number;
+        counterpartyId?: string;
+        counterpartyName?: string;
+        notes?: string;
+    }): JoopFxForward;
+    settleForward(id: string, spotRate?: number): JoopForwardSettlement;
+    cancelForward(id: string, notes?: string): JoopFxForward;
+    expireForward(id: string): JoopFxForward;
+    get(id: string): JoopFxForward | undefined;
+    getAll(status?: JoopForwardStatus): JoopFxForward[];
+    getExpiring(withinMs: number, asOf?: number): JoopFxForward[];
+    getSettlements(): JoopForwardSettlement[];
+    getSettlement(forwardId: string): JoopForwardSettlement | undefined;
+    getExposure(currency: string, type?: JoopForwardType): JoopFxExposure[];
+    getTotalPnL(): number;
+    getMarkToMarket(id: string): number;
+    change$(): JoopSubject<JoopFxForward>;
+    private _get;
+}
+
+export { type JoopAccountType, type JoopBeneficiary, JoopBeneficiaryService, type JoopBeneficiaryType, type JoopBeneficiaryValidation, type JoopBill, type JoopBillPayment, JoopBillPaymentService, type JoopBillPaymentStatus, type JoopBillPaymentSummary, type JoopBillStatus, type JoopBiller, type JoopBillerCategory, type JoopBitcoinParams, type JoopCardControls, type JoopCardInfo, JoopCardManagementService, type JoopCardNetwork, type JoopCardSpendingLimits, type JoopCardStatus, type JoopCardTransactionCheck, type JoopCardType, type JoopChequeLeaf, type JoopChequeStatus, type JoopChequebook, JoopChequebookService, type JoopChequebookStats, type JoopClaimStatus, type JoopCurrencyFormatOptions, JoopDigitalWalletService, type JoopDispute, type JoopDisputeEvidence, type JoopDisputeReason, JoopDisputeService, type JoopDisputeStats, type JoopDisputeStatus, type JoopEthereumParams, type JoopExecutionStatus, type JoopForwardSettlement, type JoopForwardStatus, type JoopForwardType, type JoopFxExposure, type JoopFxForward, JoopFxForwardService, type JoopInstallment, type JoopInsuranceClaim, type JoopInsurancePolicy, JoopInsuranceService, type JoopInsuranceType, type JoopJournalEntry, type JoopJournalLine, type JoopLedgerAccount, JoopLedgerService, type JoopLimit, type JoopLimitCheckResult, JoopLimitManagementService, type JoopLimitScope, type JoopLimitType, type JoopLoanAccount, type JoopLoanAccountStatus, type JoopLoanPayment, JoopLoanServicingService, type JoopLoanStatement, type JoopManagedCard, type JoopManagedCardNetwork, type JoopMandate, type JoopMandateExecution, type JoopMandateExecutionStatus, type JoopMandateFrequency, JoopMandateService, type JoopMandateStatus, type JoopMandateType, type JoopNotification, JoopNotificationCenterService, type JoopNotificationPriority, type JoopNotificationSummary, type JoopNotificationType, type JoopPayToParams, type JoopPaymentExecution, type JoopPaymentUri, type JoopPaymentUriScheme, JoopPaymentUriService, type JoopPolicyStatus, type JoopPremiumFrequency, type JoopPremiumPayment, type JoopReconItem, type JoopReconItemSource, type JoopReconMatch, type JoopReconMatchStatus, type JoopReconSession, type JoopReconSummary, JoopReconciliationService, type JoopRecurrenceFrequency, type JoopRemittance, type JoopRemittanceChannel, type JoopRemittanceQuote, JoopRemittanceService, type JoopRemittanceStatus, type JoopRepaymentStatus, type JoopScheduledPayment, JoopScheduledPaymentService, type JoopScheduledPaymentStatus, type JoopSepaParams, type JoopSplitBalance, type JoopSplitExpense, type JoopSplitMethod, type JoopSplitParticipant, type JoopSplitParticipantStatus, JoopSplitPaymentService, type JoopSplitSettlement, type JoopSplitStatus, type JoopStandingOrder, type JoopStandingOrderExecution, type JoopStandingOrderFrequency, JoopStandingOrderService, type JoopStandingOrderStatus, type JoopStatement, type JoopStatementEntry, type JoopStatementFormat, JoopStatementGeneratorService, type JoopStatementOptions, type JoopStatementTransaction, type JoopTransactionRef, type JoopTransactionType, type JoopTransferResult, type JoopTrialBalance, type JoopTrialBalanceRow, type JoopUpiParams, type JoopUsageRecord, type JoopUsageSummary, type JoopVirtualAccount, type JoopVirtualAccountPurpose, JoopVirtualAccountService, type JoopVirtualAccountStatus, type JoopVirtualCredit, type JoopWallet, type JoopWalletStatus, type JoopWalletTransaction, type JoopWalletTxnType, clampAmount, convertCurrency, formatAmount, formatCard, formatCardNumber, formatCurrency, formatIban, formatMyKad, fromMinorUnits, generateBatchId, generateReferenceNumber, generateTransactionId, getCardInfo, getCardNetwork, getCurrencySymbol, getIbanCountry, getSupportedIbanCountries, isCardExpired, isValidAmount, isValidTransactionId, luhnCheckDigit, maskAccountNumber, maskCard, maskEmail, maskIban, maskInterleaved, maskKeepMiddle, maskKeepSeparators, maskMyKad, maskName, maskNric, maskPattern, maskPhone, maskRange, maskShowFirst, maskShowLast, parseCurrencyString, parseIban, parseTransactionId, roundAmount, safeAdd, safeDivide, safeMultiply, safeSubtract, sumAmounts, toMinorUnits, validateCvv, validateIban, validateLuhn, validateMyKad, validateNric };