joopjs 2.0.0

package/dist/index.d.mts

@@ -0,0 +1,1336 @@
+export { J as JoopInstance, c as createJoop } from './joop-Bx7Iwj5p.mjs';
+export { JoopCapabilities, JoopPlatform, JoopPlatformConfig, JoopPlatformType } from './platform/index.mjs';
+export { J as JoopAppState, f as JoopBiometricAdapter, k as JoopCompressionAdapter, l as JoopCompressionFormat, m as JoopCryptoAdapter, c as JoopEffectiveType, e as JoopKeyVaultAdapter, i as JoopLifecycleAdapter, j as JoopNetworkAdapter, a as JoopNetworkState, b as JoopNetworkType, n as JoopPlatformAdapterConfig, g as JoopPushAdapter, h as JoopPushPayload, d as JoopStorageAdapter, o as JoopWorkerAdapter } from './adapters-B6slG6hQ.mjs';
+import { J as JoopObservable, a as JoopBehaviorSubject, b as JoopSubject } from './index-Dz0gOur2.mjs';
+export { L as Listener, U as Unsubscribe } from './index-Dz0gOur2.mjs';
+export { a as JoopApp, J as JoopConfig, f as JoopLanguage, d as JoopLocalization, e as JoopLoggerConfig, g as JoopLoggerTypeConfig, h as JoopOpenBankingConfig, i as JoopPaymentGatewayConfig, c as JoopSession, b as JoopTimeout } from './config.models-Cqg04fAQ.mjs';
+export { b as JoopAesService, J as JoopGcmService, d as JoopHttpOptions, c as JoopRequestOptions, a as JoopRsaService } from './aes.service-CkoupAww.mjs';
+export { b as JoopCircuitBreaker, k as JoopCircuitBreakerConfig, l as JoopCircuitBreakerOpenError, m as JoopCircuitBreakerRegistry, n as JoopCircuitBreakerState, o as JoopCircuitBreakerStats, p as JoopCircuitState, q as JoopCsvOptions, r as JoopDownloadOptions, s as JoopEncryptionError, t as JoopError, u as JoopErrorButton, v as JoopErrorInterceptor, w as JoopErrorType, h as JoopExportService, x as JoopFetchOptions, f as JoopFileSaverService, J as JoopHttpClient, y as JoopHttpError, z as JoopIdempotencyConfig, j as JoopIdempotencyService, a as JoopInterceptorPipeline, A as JoopLoadingState, B as JoopMappedComponent, C as JoopMappedResponse, c as JoopOfflineQueue, D as JoopPollConfig, d as JoopPollingService, E as JoopRawResponse, F as JoopRawResponse6, G as JoopRequest, H as JoopRequestInterceptor, e as JoopRequestService, I as JoopResponse, K as JoopResponseInterceptor, g as JoopResponseMapper, L as JoopWebhookOptions, M as JoopWebhookProvider, i as JoopWebhookVerifier, N as isHttpError } from './idempotency.service-_6LqhivP.mjs';
+export { g as JoopConsentCategory, f as JoopConsentService, h as JoopConsentState, i as JoopEnvironmentName, j as JoopEnvironmentProfile, b as JoopEnvironmentService, d as JoopFeatureFlagService, k as JoopFlagContext, l as JoopFlagDefinition, m as JoopHealthCheck, n as JoopHealthCheckResult, c as JoopHealthService, o as JoopLogEntry, J as JoopLogger, p as JoopLoggerOptions, q as JoopPlugin, a as JoopPluginService, e as JoopRateLimiter, r as JoopTokenBucket, s as JoopTokenBucketConfig, t as logger } from './index-B_ksKpS1.mjs';
+export { a as JoopHttpMethod, b as JoopLogLevel, J as JoopScopeType } from './index-CqDKWTUP.mjs';
+export { J as JoopConfigService, c as configService } from './config.service-Cz4QQLlf.mjs';
+export { J as JoopDataStorage, a as JoopScopeMapService } from './data-storage.service-LvhGRCmw.mjs';
+export { JoopIdbConfig, JoopIdbStoreSchema, JoopIndexedDbService } from './storage/index.mjs';
+export { JoopAntiTamperService, JoopCertPin, JoopCertPinningService, JoopClipboardEntry, JoopClipboardEvent, JoopPinValidationResult, JoopPinViolation, JoopRequestSigningConfig, JoopRequestSigningService, JoopScreenSecurityConfig, JoopScreenSecurityEvent, JoopScreenSecurityService, JoopSecureClipboard, JoopSecureClipboardConfig, JoopSecureStorage, JoopSecureStorageConfig, JoopSignedPayload, JoopTamperCheck, JoopTamperReport, JoopTamperSeverity, JoopTamperType } from './security/index.mjs';
+export { e as JoopAnomalyEvent, J as JoopBehavioralBiometrics, f as JoopBiometricProfile, g as JoopBiometricScore, d as JoopDifferentialPrivacy, h as JoopPIIFinding, i as JoopPIIPattern, b as JoopPIIScanner, j as JoopRiskContext, a as JoopRiskEngine, k as JoopRiskFactor, l as JoopRiskScore, c as JoopSecretSharing, m as JoopShare } from './differential-privacy-BcAv1G80.mjs';
+export { J as JoopAuthService } from './auth.service-DNVB-L4U.mjs';
+export { c as JoopBiometricService, f as JoopLoginOptions, g as JoopMfaChallenge, d as JoopMfaService, h as JoopMfaTotpSetup, i as JoopMfaVerifyResult, e as JoopOIDCClient, j as JoopOIDCConfig, k as JoopOIDCMetadata, l as JoopOIDCTokens, b as JoopOtpService, m as JoopPKCEParams, a as JoopPKCEService, n as JoopTokenPayload, J as JoopTokenService } from './oidc-client-DIJcClmB.mjs';
+export { J as JoopClientProfile, c as clientProfile } from './client-profile.service-BuPeXVp5.mjs';
+export { JoopHttpClientExtended, JoopParallelResult, JoopRequestQueue, JoopRequestQueueConfig, JoopRetryConfig, baseUrlInterceptor, bearerAuthInterceptor, cacheRequestInterceptor, cacheResponseInterceptor, clearCache, correlationInterceptor, loggingRequestInterceptor, loggingResponseInterceptor, retryErrorInterceptor, withRetry } from './api/index.mjs';
+export { JoopE2EPayload, JoopE2EService, JoopRsaKeyPair, JoopX25519Service } from './encryption/index.mjs';
+export { J as JoopCryptoUtils, a as JoopPasswordHash } from './crypto-utils-DriNhLdx.mjs';
+export { JoopConcurrentSessionEvent, JoopConcurrentSessionService, JoopIdleConfig, JoopIdleService, JoopIdleState, JoopMultiTabSync, JoopSessionEvent, JoopSessionTimeoutService, JoopTabEvent, JoopTabEventType } from './session/index.mjs';
+export { JoopAccountType, JoopBeneficiary, JoopBeneficiaryService, JoopBeneficiaryType, JoopBeneficiaryValidation, JoopBill, JoopBillPayment, JoopBillPaymentService, JoopBillPaymentStatus, JoopBillPaymentSummary, JoopBillStatus, JoopBiller, JoopBillerCategory, JoopBitcoinParams, JoopCardControls, JoopCardInfo, JoopCardManagementService, JoopCardNetwork, JoopCardSpendingLimits, JoopCardStatus, JoopCardTransactionCheck, JoopCardType, JoopChequeLeaf, JoopChequeStatus, JoopChequebook, JoopChequebookService, JoopChequebookStats, JoopClaimStatus, JoopCurrencyFormatOptions, JoopDigitalWalletService, JoopDispute, JoopDisputeEvidence, JoopDisputeReason, JoopDisputeService, JoopDisputeStats, JoopDisputeStatus, JoopEthereumParams, JoopExecutionStatus, JoopForwardSettlement, JoopForwardStatus, JoopForwardType, JoopFxExposure, JoopFxForward, JoopFxForwardService, JoopInstallment, JoopInsuranceClaim, JoopInsurancePolicy, JoopInsuranceService, JoopInsuranceType, JoopJournalEntry, JoopJournalLine, JoopLedgerAccount, JoopLedgerService, JoopLimit, JoopLimitCheckResult, JoopLimitManagementService, JoopLimitScope, JoopLimitType, JoopLoanAccount, JoopLoanAccountStatus, JoopLoanPayment, JoopLoanServicingService, JoopLoanStatement, JoopManagedCard, JoopManagedCardNetwork, JoopMandate, JoopMandateExecution, JoopMandateExecutionStatus, JoopMandateFrequency, JoopMandateService, JoopMandateStatus, JoopMandateType, JoopNotification, JoopNotificationCenterService, JoopNotificationPriority, JoopNotificationSummary, JoopNotificationType, JoopPayToParams, JoopPaymentExecution, JoopPaymentUri, JoopPaymentUriScheme, JoopPaymentUriService, JoopPolicyStatus, JoopPremiumFrequency, JoopPremiumPayment, JoopReconItem, JoopReconItemSource, JoopReconMatch, JoopReconMatchStatus, JoopReconSession, JoopReconSummary, JoopReconciliationService, JoopRecurrenceFrequency, JoopRemittance, JoopRemittanceChannel, JoopRemittanceQuote, JoopRemittanceService, JoopRemittanceStatus, JoopRepaymentStatus, JoopScheduledPayment, JoopScheduledPaymentService, JoopScheduledPaymentStatus, JoopSepaParams, JoopSplitBalance, JoopSplitExpense, JoopSplitMethod, JoopSplitParticipant, JoopSplitParticipantStatus, JoopSplitPaymentService, JoopSplitSettlement, JoopSplitStatus, JoopStandingOrder, JoopStandingOrderExecution, JoopStandingOrderFrequency, JoopStandingOrderService, JoopStandingOrderStatus, JoopStatement, JoopStatementEntry, JoopStatementFormat, JoopStatementGeneratorService, JoopStatementOptions, JoopStatementTransaction, JoopTransactionRef, JoopTransactionType, JoopTransferResult, JoopTrialBalance, JoopTrialBalanceRow, JoopUpiParams, JoopUsageRecord, JoopUsageSummary, JoopVirtualAccount, JoopVirtualAccountPurpose, JoopVirtualAccountService, JoopVirtualAccountStatus, JoopVirtualCredit, JoopWallet, JoopWalletStatus, JoopWalletTransaction, 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 } from './banking/index.mjs';
+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, J as JoopReceiptService, d as JoopStatementParser, w as JoopStatementResult, x as JoopThreeDsResult, y as JoopTransactionSignal, z as JoopTxnType } from './statement-parser-C2qNmb49.mjs';
+export { JoopAuditAction, JoopAuditEntry, JoopAuditListener, JoopAuditLog, JoopCorrelationService, JoopErrorHandler, JoopErrorReport, JoopErrorReporter, JoopPerfMark, JoopPerformanceService, JoopRecordedEvent, JoopSessionRecord, JoopSessionRecorder, JoopSessionRecorderOptions, JoopVitalUpdate, JoopVitalsSnapshot, JoopWebVitals } from './observability/index.mjs';
+export { e as JoopAppLifecycle, f as JoopAuthenticateOptions, c as JoopBiometricAuth, g as JoopBiometricConfig, b as JoopDeviceFingerprintService, h as JoopDeviceInfo, i as JoopEnrollResult, a as JoopKeyVault, j as JoopKeyVaultConfig, k as JoopLifecycleConfig, J as JoopNetworkMonitor, l as JoopNetworkMonitorConfig, m as JoopPushConfig, n as JoopPushPermission, d as JoopPushService, o as JoopPushSubscriptionInfo } from './network-monitor-BIwPSXme.mjs';
+export { JoopBrowserInfo, JoopCardForm, JoopCardScanResult, JoopCardScanner, JoopCardScannerConfig, JoopClientInfo, JoopClientInfoConfig, JoopClientInfoService, JoopDeviceKind, JoopOsInfo } from './device/index.mjs';
+export { JoopMockRoute, JoopMockService } from './dev/index.mjs';
+export { JoopTheme, JoopThemeColor, JoopThemeInfo, JoopThemePalette, JoopThemeService } from './theme/index.mjs';
+export { JoopDirection, JoopI18nService, JoopLanguageDetail, JoopTranslations } from './i18n/index.mjs';
+export { d as JoopA11yService, a as JoopAlertService, e as JoopAlertType, f as JoopAriaLivePoliteness, g as JoopDialogButton, h as JoopDialogOptions, i as JoopFocusTrapOptions, j as JoopInlineAlert, k as JoopLoaderConfig, J as JoopLoaderService, l as JoopPageState, b as JoopPaginationService, c as JoopPrintService, m as JoopToastOptions } from './a11y.service-C-DQQfgO.mjs';
+export { JoopBankingKeyboard, JoopBankingKeyboardConfig, JoopBankingKeyboardOptions, JoopKeyboardMode, JoopVirtualRange, JoopVirtualScroll, JoopVirtualScrollOptions } from './ui/index.mjs';
+export { JoopNativeBridgeService, JoopNativeMessage } from './native-bridge/index.mjs';
+export { a as JoopDeeplinkData, J as JoopDeeplinkService } from './deeplink.service-Ctd5u243.mjs';
+export { JoopDeeplinkRouter, JoopRouteHandler, JoopRouteParams } from './deeplink/index.mjs';
+export { JoopCacheOptions, JoopCacheService } from './cache/index.mjs';
+export { JoopSSEConfig, JoopSSEMessage, JoopSSEState, JoopStreamingService, JoopWebSocketService, JoopWsConfig, JoopWsMessage, JoopWsState } from './network/index.mjs';
+export { JoopAnalyticsAdapter, JoopAnalyticsEvent, JoopAnalyticsService, consoleAnalyticsAdapter } from './analytics/index.mjs';
+export { J as JoopFormValidator, a as JoopPasswordStrength, b as JoopValidationResult } from './form-validator-3tkmzr_o.mjs';
+export { JoopPasswordRule, JoopPasswordRuleSet, JoopPasswordRulesValidator, JoopPasswordValidationResult, passwordRuleSets, passwordRules } from './validation/index.mjs';
+export { JoopOtpTimer, JoopOtpTimerConfig, JoopOtpTimerState, JoopSsoConfig, JoopSsoExchangeRequest, JoopSsoService, JoopSsoToken } from './auth/index.mjs';
+export { JoopBarcodeOptions, JoopCategoryAgg, JoopChartBucket, JoopHijriDate, JoopQrDecoder, JoopQrEcLevel, JoopQrOptions, JoopQrScanResult, JoopQrScanner, JoopQrScannerConfig, JoopTimeInterval, JoopWeekend, addBusinessDays, aggregateByCategory, bucketByTime, bufferToHex, buildFormData, buildQueryString, cumulative, daysBetween, deepClone, detectTrend, escapeHtml, flattenObj, flattenObject, formatDate, formatHijri, fromHijri, generateBarcodeDataUrl, generateCode128, generateCode39, generateEan13, generatePaymentQr, generateQr, generateQrDataUrl, generateTotpUri, getBusinessDaysBetween, getDeviceInfo, getRandomNum, isAlphanumeric, isBrowser, isBusinessDay, isDateInRange, isPlainObject, isSSR, isValidEmail, isValidPhone, isValidUrl, movingSum, normalize, objectToQueryString, parseDate, percentChange, randomString, removeTrailingSlash, rollingAverage, sanitizeFileName, sanitizeInput, sparklinePoints, sparklineSvg, stringToHex, stripHtml, stripSqlKeywords, timeAgo, toHijri, truncate, urlEncode, validateEan13 } from './utilities/index.mjs';
+export { J as JoopClipboardService, f as JoopCompressOptions, g as JoopGeoOptions, h as JoopGeoPosition, c as JoopGeoService, i as JoopImageInfo, a as JoopImageService, j as JoopImageValidation, k as JoopMediaConstraints, l as JoopMediaRecorder, d as JoopMediaService, m as JoopPdfLineOptions, n as JoopPdfOptions, b as JoopPdfService, o as JoopPdfTableColumn, p as JoopPdfTextOptions, q as JoopReceiptLine, r as JoopRecorderOptions, s as JoopWatermarkOptions, e as JoopWatermarkService, t as clipboard } from './watermark.service-QNegMeQZ.mjs';
+export { a as JoopNotificationOptions, b as JoopNotificationPermission, J as JoopNotificationService } from './notification.service-Dm4fvfZf.mjs';
+export { JoopField, JoopFieldConfig, JoopFieldState, JoopForm, JoopFormBuilder, JoopFormState } from './forms/index.mjs';
+export { JoopRoute, JoopRouteGuard, JoopRouterService } from './router/index.mjs';
+export { JoopServiceWorkerService } from './pwa/index.mjs';
+export { JoopAiClient, JoopAiConfig, JoopAiMessage, JoopAiProvider, JoopAiStreamOptions, JoopAiUsage, JoopToolCall, JoopToolDefinition, JoopToolParameter, JoopToolRegistry, JoopToolResult } from './ai/index.mjs';
+export { JoopCompressionService, JoopWorkerPool, JoopWorkerPoolConfig } from './workers/index.mjs';
+export { JoopAction, JoopReducer, JoopStore, JoopStoreConfig, createSlice, createStore } from './state/index.mjs';
+export { a as JoopMutation, b as JoopSyncConfig, c as JoopSyncConflict, J as JoopSyncEngine, d as JoopSyncStatus } from './sync-engine-DZqyKHkK.mjs';
+export { CRDTCounter, CRDTRegister, CRDTSet, CRDTText, mergeCRDT } from './sync/index.mjs';
+export { JoopMachineConfig, JoopStateConfig, JoopStateMachine, JoopStateTransition, JoopTransition, JoopWorkflowDefinition, JoopWorkflowEngine, JoopWorkflowResult, JoopWorkflowRun, JoopWorkflowStep } from './workflow/index.mjs';
+
+interface JoopEncryptedResponse {
+    screenId?: string;
+    encrypted?: boolean;
+    encryptedData?: string;
+}
+
+declare const DEFAULT_REQUEST_TIMEOUT = 30000;
+declare const DEFAULT_SESSION_TIMEOUT = 300000;
+declare const DEFAULT_SESSION_WAIT_TIMEOUT = 60000;
+declare const PAGE_TOKEN_KEY = "pageToken";
+declare const DECRYPTION_FAILED = "Response decryption failed";
+declare const SESSION_STORAGE_KEY = "joopSession";
+
+type JoopBudgetPeriod = 'daily' | 'weekly' | 'monthly';
+interface JoopBudgetCategory {
+    category: string;
+    limitAmount: number;
+    period: JoopBudgetPeriod;
+    currency?: string;
+    color?: string;
+}
+interface JoopBudgetEntry {
+    id: string;
+    category: string;
+    amount: number;
+    date: number;
+    description?: string;
+}
+interface JoopBudgetStatus {
+    category: string;
+    limitAmount: number;
+    spentAmount: number;
+    remainingAmount: number;
+    percentUsed: number;
+    isOverBudget: boolean;
+    isNearLimit: boolean;
+    period: JoopBudgetPeriod;
+    currency: string;
+}
+interface JoopBudgetSummary {
+    totalLimit: number;
+    totalSpent: number;
+    totalRemaining: number;
+    overBudgetCount: number;
+    nearLimitCount: number;
+    currency: string;
+}
+declare class JoopBudgetService {
+    private _categories;
+    private _entries;
+    private _alertThreshold;
+    private _alertHandlers;
+    private _status$;
+    setBudget(budget: JoopBudgetCategory): void;
+    removeBudget(category: string): void;
+    getBudget(category: string): JoopBudgetCategory | undefined;
+    getAllBudgets(): JoopBudgetCategory[];
+    addSpending(entry: Omit<JoopBudgetEntry, 'id'>): JoopBudgetEntry;
+    removeSpending(id: string): void;
+    getSpending(category?: string): JoopBudgetEntry[];
+    getStatus(category: string, asOf?: Date): JoopBudgetStatus | null;
+    getAllStatus(asOf?: Date): JoopBudgetStatus[];
+    getOverBudget(asOf?: Date): JoopBudgetStatus[];
+    getNearLimit(asOf?: Date): JoopBudgetStatus[];
+    getSummary(asOf?: Date): JoopBudgetSummary;
+    setAlertThreshold(threshold: number): void;
+    getAlertThreshold(): number;
+    onAlert(handler: (status: JoopBudgetStatus) => void): () => void;
+    status$(): JoopObservable<JoopBudgetStatus>;
+    reset(category?: string): void;
+    private _computeStatus;
+}
+
+type JoopGoalStatus = 'active' | 'completed' | 'paused' | 'cancelled';
+type JoopAutoDebitFrequency = 'daily' | 'weekly' | 'monthly';
+interface JoopSavingsGoal {
+    id: string;
+    name: string;
+    targetAmount: number;
+    currentAmount: number;
+    currency: string;
+    targetDate?: number;
+    autoDebitAmount?: number;
+    autoDebitFrequency?: JoopAutoDebitFrequency;
+    icon?: string;
+    notes?: string;
+    createdAt: number;
+    completedAt?: number;
+    status: JoopGoalStatus;
+}
+interface JoopSavingsTransaction {
+    id: string;
+    goalId: string;
+    amount: number;
+    type: 'deposit' | 'withdrawal';
+    note?: string;
+    date: number;
+}
+interface JoopSavingsProgress {
+    goal: JoopSavingsGoal;
+    progressPercent: number;
+    remainingAmount: number;
+    daysRemaining: number | null;
+    isOnTrack: boolean;
+    projectedCompletionDate: number | null;
+    requiredMonthlyAmount: number | null;
+    dailyTargetAmount: number | null;
+}
+declare class JoopSavingsGoalService {
+    private _goals;
+    private _transactions;
+    private _completedHandlers;
+    private _goals$;
+    create(data: Omit<JoopSavingsGoal, 'id' | 'createdAt' | 'status' | 'currentAmount'> & {
+        currentAmount?: number;
+    }): JoopSavingsGoal;
+    update(id: string, patch: Partial<Omit<JoopSavingsGoal, 'id' | 'createdAt'>>): JoopSavingsGoal;
+    delete(id: string): void;
+    get(id: string): JoopSavingsGoal | undefined;
+    getAll(): JoopSavingsGoal[];
+    getActive(): JoopSavingsGoal[];
+    getCompleted(): JoopSavingsGoal[];
+    deposit(id: string, amount: number, note?: string): JoopSavingsGoal;
+    withdraw(id: string, amount: number, note?: string): JoopSavingsGoal;
+    getTransactions(goalId: string): JoopSavingsTransaction[];
+    getProgress(id: string, asOf?: number): JoopSavingsProgress | null;
+    getAllProgress(asOf?: number): JoopSavingsProgress[];
+    complete(id: string): void;
+    pause(id: string): void;
+    resume(id: string): void;
+    cancel(id: string): void;
+    totalSaved(): number;
+    totalTarget(): number;
+    overallProgress(): number;
+    onGoalCompleted(handler: (goal: JoopSavingsGoal) => void): () => void;
+    goals$(): JoopObservable<JoopSavingsGoal[]>;
+    private _get;
+    private _emit;
+    private _computeProgress;
+}
+
+interface JoopExchangeRate {
+    from: string;
+    to: string;
+    rate: number;
+    timestamp: number;
+    source?: string;
+}
+interface JoopConversionResult {
+    from: string;
+    to: string;
+    amount: number;
+    convertedAmount: number;
+    rate: number;
+    inverseRate: number;
+    spread: number;
+    fee: number;
+    grossAmount: number;
+    netAmount: number;
+    timestamp: number;
+}
+interface JoopExchangeRateProvider {
+    name: string;
+    fetch(base: string, targets: string[]): Promise<Record<string, number>>;
+}
+declare class JoopCurrencyExchangeService {
+    private _rates;
+    private _history;
+    private _provider;
+    private _rates$;
+    setProvider(provider: JoopExchangeRateProvider): void;
+    setRate(from: string, to: string, rate: number, source?: string): void;
+    setRates(rates: JoopExchangeRate[]): void;
+    fetchRates(base: string, targets?: string[]): Promise<void>;
+    getRate(from: string, to: string): number | null;
+    getRateEntry(from: string, to: string): JoopExchangeRate | null;
+    convert(amount: number, from: string, to: string, spreadPercent?: number, fixedFee?: number): JoopConversionResult;
+    getHistory(from: string, to: string): JoopExchangeRate[];
+    getSupportedCurrencies(): string[];
+    isSupported(currency: string): boolean;
+    getAllRates(): JoopExchangeRate[];
+    rates$(): JoopObservable<JoopExchangeRate[]>;
+    private _pushHistory;
+    private _emitRates;
+}
+
+type JoopCreditScoreRating = 'excellent' | 'good' | 'fair' | 'poor' | 'bad';
+type JoopLoanType = 'personal' | 'mortgage' | 'auto' | 'student' | 'business';
+interface JoopLoanApplicant {
+    grossMonthlyIncome: number;
+    netMonthlyIncome: number;
+    monthlyDebts: number;
+    creditScore: number;
+    employmentMonths: number;
+    assets?: number;
+    currency?: string;
+}
+interface JoopLoanParams {
+    requestedAmount: number;
+    interestRatePercent: number;
+    termMonths: number;
+    loanType?: JoopLoanType;
+    currency?: string;
+}
+interface JoopEmiBreakdown {
+    emi: number;
+    totalPayment: number;
+    totalInterest: number;
+    principal: number;
+    interestRatePercent: number;
+    termMonths: number;
+    schedule: JoopEmiScheduleEntry$1[];
+}
+interface JoopEmiScheduleEntry$1 {
+    month: number;
+    emi: number;
+    principal: number;
+    interest: number;
+    remainingBalance: number;
+}
+interface JoopLoanEligibilityResult {
+    isEligible: boolean;
+    reasons: string[];
+    dtiRatio: number;
+    maxEligibleAmount: number;
+    repaymentCapacity: number;
+    creditRating: JoopCreditScoreRating;
+    requestedEmi?: number;
+    emiBreakdown?: JoopEmiBreakdown;
+    currency: string;
+}
+interface JoopLoanProduct {
+    name: string;
+    type: JoopLoanType;
+    minAmount: number;
+    maxAmount: number;
+    minTermMonths: number;
+    maxTermMonths: number;
+    baseRatePercent: number;
+    maxDtiPercent: number;
+    minCreditScore: number;
+}
+declare class JoopLoanEligibilityService {
+    private _products;
+    addProduct(product: JoopLoanProduct): void;
+    removeProduct(name: string): void;
+    getProducts(): JoopLoanProduct[];
+    getProductsByType(type: JoopLoanType): JoopLoanProduct[];
+    assess(applicant: JoopLoanApplicant, params: JoopLoanParams): JoopLoanEligibilityResult;
+    compareProducts(applicant: JoopLoanApplicant, requestedAmount: number, termMonths: number): Array<{
+        product: JoopLoanProduct;
+        result: JoopLoanEligibilityResult;
+    }>;
+    computeEmi(principal: number, annualRatePercent: number, termMonths: number): number;
+    computeEmiBreakdown(principal: number, annualRatePercent: number, termMonths: number): JoopEmiBreakdown;
+    maxLoanAmount(monthlyPaymentCapacity: number, annualRatePercent: number, termMonths: number): number;
+    creditScoreRating(score: number): JoopCreditScoreRating;
+    computeDti(monthlyDebts: number, grossMonthlyIncome: number): number;
+}
+
+type JoopLoyaltyTier = 'bronze' | 'silver' | 'gold' | 'platinum';
+type JoopLoyaltyTxnType = 'earn' | 'redeem' | 'expire' | 'adjust' | 'bonus';
+interface JoopLoyaltyTierDef {
+    tier: JoopLoyaltyTier;
+    minPoints: number;
+    earnMultiplier: number;
+    label: string;
+}
+interface JoopLoyaltyEarnRule {
+    category: string;
+    pointsPerUnit: number;
+    currency?: string;
+    multiplier?: number;
+    maxPerTxn?: number;
+}
+interface JoopLoyaltyTransaction {
+    id: string;
+    type: JoopLoyaltyTxnType;
+    points: number;
+    balance: number;
+    description: string;
+    category?: string;
+    reference?: string;
+    expiresAt?: number;
+    date: number;
+}
+interface JoopLoyaltySummary {
+    balance: number;
+    lifetimeEarned: number;
+    lifetimeRedeemed: number;
+    lifetimeExpired: number;
+    tier: JoopLoyaltyTier;
+    nextTier: JoopLoyaltyTier | null;
+    pointsToNextTier: number | null;
+    tierMultiplier: number;
+}
+declare class JoopLoyaltyService {
+    private _balance;
+    private _lifetimeEarned;
+    private _lifetimeRedeemed;
+    private _lifetimeExpired;
+    private _transactions;
+    private _tiers;
+    private _baseEarnRate;
+    private _earnRules;
+    private _pointValue;
+    private _summary$;
+    constructor(options?: {
+        baseEarnRate?: number;
+        pointValue?: number;
+        tiers?: JoopLoyaltyTierDef[];
+    });
+    setEarnRule(rule: JoopLoyaltyEarnRule): void;
+    removeEarnRule(category: string): void;
+    getEarnRate(amount: number, category?: string): number;
+    earn(amount: number, options?: {
+        category?: string;
+        description?: string;
+        reference?: string;
+        ttlDays?: number;
+        bonus?: number;
+    }): JoopLoyaltyTransaction;
+    redeem(points: number, options?: {
+        description?: string;
+        reference?: string;
+    }): JoopLoyaltyTransaction;
+    adjust(points: number, description: string): JoopLoyaltyTransaction;
+    getBalance(): number;
+    getAvailableBalance(asOf?: number): number;
+    pointsToValue(points: number): number;
+    currencyToPoints(amount: number, category?: string): number;
+    expirePoints(asOf?: number): number;
+    getCurrentTier(): JoopLoyaltyTier;
+    getTierDef(tier: JoopLoyaltyTier): JoopLoyaltyTierDef;
+    getNextTier(): JoopLoyaltyTier | null;
+    getPointsToNextTier(): number | null;
+    getTransactions(): JoopLoyaltyTransaction[];
+    getTransactionsByType(type: JoopLoyaltyTxnType): JoopLoyaltyTransaction[];
+    getSummary(): JoopLoyaltySummary;
+    summary$(): JoopObservable<JoopLoyaltySummary>;
+    private _record;
+    private _currentTier;
+    private _getTierDef;
+    private _emitSummary;
+}
+
+type JoopAssetType = 'stock' | 'bond' | 'etf' | 'crypto' | 'mutual-fund' | 'real-estate' | 'commodity' | 'cash' | 'other';
+interface JoopHolding {
+    id: string;
+    symbol: string;
+    name: string;
+    assetType: JoopAssetType;
+    quantity: number;
+    purchasePrice: number;
+    currentPrice: number;
+    currency: string;
+    purchaseDate?: number;
+    exchange?: string;
+    sector?: string;
+    notes?: string;
+    createdAt: number;
+    updatedAt: number;
+}
+interface JoopHoldingPerformance {
+    holding: JoopHolding;
+    costBasis: number;
+    marketValue: number;
+    unrealizedGain: number;
+    unrealizedGainPercent: number;
+    allocationPercent: number;
+    daysSinceEntry: number | null;
+    annualizedReturnPercent: number | null;
+}
+interface JoopPortfolioSummary {
+    totalCost: number;
+    totalValue: number;
+    totalUnrealizedGain: number;
+    totalUnrealizedGainPercent: number;
+    holdingCount: number;
+    allocationByType: Record<JoopAssetType, number>;
+    topHolding: JoopHoldingPerformance | null;
+    worstHolding: JoopHoldingPerformance | null;
+    currency: string;
+}
+declare class JoopPortfolioService {
+    private _holdings;
+    private _portfolio$;
+    add(data: Omit<JoopHolding, 'id' | 'createdAt' | 'updatedAt'>): JoopHolding;
+    update(idOrSymbol: string, patch: Partial<Omit<JoopHolding, 'id' | 'createdAt'>>): JoopHolding;
+    remove(idOrSymbol: string): void;
+    get(idOrSymbol: string): JoopHolding | undefined;
+    getAll(): JoopHolding[];
+    getByType(type: JoopAssetType): JoopHolding[];
+    addToPosition(symbol: string, quantity: number, price: number): JoopHolding;
+    reducePosition(symbol: string, quantity: number): JoopHolding;
+    updatePrice(symbol: string, price: number): JoopHolding;
+    updatePrices(prices: Record<string, number>): void;
+    getPerformance(idOrSymbol: string): JoopHoldingPerformance | null;
+    getAllPerformance(): JoopHoldingPerformance[];
+    getTotalValue(): number;
+    getTotalCost(): number;
+    getTotalGain(): number;
+    getTotalGainPercent(): number;
+    getAllocation(): Array<{
+        symbol: string;
+        percent: number;
+    }>;
+    getAllocationByType(): Record<JoopAssetType, number>;
+    getSummary(): JoopPortfolioSummary;
+    portfolio$(): JoopObservable<JoopHolding[]>;
+    private _bySymbol;
+    private _require;
+    private _requireBySymbol;
+    private _totalValue;
+    private _computePerf;
+    private _emit;
+}
+
+interface JoopTaxBracket {
+    from: number;
+    to: number | null;
+    rate: number;
+    label?: string;
+}
+interface JoopTaxDeduction {
+    name: string;
+    amount: number;
+}
+interface JoopIncomeTaxResult {
+    grossIncome: number;
+    totalDeductions: number;
+    taxableIncome: number;
+    tax: number;
+    effectiveRate: number;
+    marginalRate: number;
+    netIncome: number;
+    bracketBreakdown: Array<{
+        bracket: JoopTaxBracket;
+        taxableInBracket: number;
+        tax: number;
+    }>;
+    currency: string;
+}
+interface JoopCapitalGainsTaxResult {
+    gain: number;
+    holdingDays: number;
+    isLongTerm: boolean;
+    rate: number;
+    tax: number;
+    netGain: number;
+}
+interface JoopGstResult {
+    baseAmount: number;
+    rate: number;
+    gstAmount: number;
+    totalAmount: number;
+    isInclusive: boolean;
+}
+interface JoopTaxSummary {
+    grossIncome: number;
+    incomeTax: number;
+    capitalGainsTax: number;
+    withholdingTax: number;
+    totalTax: number;
+    netIncome: number;
+    effectiveOverallRate: number;
+    currency: string;
+}
+declare const JoopTaxBrackets: {
+    US_2024: JoopTaxBracket[];
+    UK_2024: JoopTaxBracket[];
+    IN_FY2024: JoopTaxBracket[];
+    AU_FY2024: JoopTaxBracket[];
+};
+declare class JoopTaxCalculatorService {
+    private _brackets;
+    private _currency;
+    private _longTermThresholdDays;
+    private _shortTermCgtRate;
+    private _longTermCgtRate;
+    private _defaultGstRate;
+    constructor(options?: {
+        brackets?: JoopTaxBracket[];
+        currency?: string;
+        longTermThresholdDays?: number;
+        shortTermCgtRate?: number;
+        longTermCgtRate?: number;
+        defaultGstRate?: number;
+    });
+    setBrackets(brackets: JoopTaxBracket[]): void;
+    getBrackets(): JoopTaxBracket[];
+    calculateIncomeTax(grossIncome: number, deductions?: JoopTaxDeduction[], brackets?: JoopTaxBracket[]): JoopIncomeTaxResult;
+    calculateCapitalGains(gain: number, holdingDays: number, options?: {
+        shortTermRate?: number;
+        longTermRate?: number;
+    }): JoopCapitalGainsTaxResult;
+    calculateGst(amount: number, options?: {
+        rate?: number;
+        inclusive?: boolean;
+    }): JoopGstResult;
+    calculateVat: (amount: number, options?: {
+        rate?: number;
+        inclusive?: boolean;
+    }) => JoopGstResult;
+    calculateWithholding(amount: number, rate: number): {
+        gross: number;
+        withheld: number;
+        net: number;
+        rate: number;
+    };
+    getTaxSummary(options: {
+        grossIncome: number;
+        deductions?: JoopTaxDeduction[];
+        capitalGain?: number;
+        capitalGainHoldingDays?: number;
+        withholdingAmount?: number;
+        withholdingRate?: number;
+    }): JoopTaxSummary;
+    getMarginalRate(income: number, brackets?: JoopTaxBracket[]): number;
+    getEffectiveRate(income: number, brackets?: JoopTaxBracket[]): number;
+}
+
+type JoopCompoundFrequency = 'daily' | 'monthly' | 'quarterly' | 'half-yearly' | 'yearly';
+interface JoopSimpleInterestResult {
+    principal: number;
+    rate: number;
+    years: number;
+    interest: number;
+    amount: number;
+}
+interface JoopCompoundInterestResult {
+    principal: number;
+    rate: number;
+    years: number;
+    frequency: JoopCompoundFrequency;
+    compoundsPerYear: number;
+    interest: number;
+    amount: number;
+    effectiveAnnualRate: number;
+}
+interface JoopFixedDepositResult {
+    principal: number;
+    ratePercent: number;
+    termDays: number;
+    frequency: JoopCompoundFrequency;
+    maturityAmount: number;
+    totalInterest: number;
+    effectiveAnnualRate: number;
+}
+interface JoopRecurringDepositResult {
+    monthlyDeposit: number;
+    ratePercent: number;
+    termMonths: number;
+    maturityAmount: number;
+    totalDeposited: number;
+    totalInterest: number;
+}
+interface JoopSavingsProjectionEntry {
+    year: number;
+    openingBalance: number;
+    deposits: number;
+    interest: number;
+    closingBalance: number;
+}
+interface JoopSavingsProjection {
+    startBalance: number;
+    monthlyDeposit: number;
+    annualRatePercent: number;
+    years: number;
+    finalBalance: number;
+    totalDeposited: number;
+    totalInterest: number;
+    schedule: JoopSavingsProjectionEntry[];
+}
+declare class JoopInterestCalculatorService {
+    simpleInterest(principal: number, ratePercent: number, years: number): JoopSimpleInterestResult;
+    compoundInterest(principal: number, ratePercent: number, years: number, frequency?: JoopCompoundFrequency): JoopCompoundInterestResult;
+    fixedDeposit(principal: number, ratePercent: number, termDays: number, frequency?: JoopCompoundFrequency): JoopFixedDepositResult;
+    recurringDeposit(monthlyDeposit: number, ratePercent: number, termMonths: number): JoopRecurringDepositResult;
+    projectSavings(startBalance: number, monthlyDeposit: number, annualRatePercent: number, years: number): JoopSavingsProjection;
+    effectiveAnnualRate(nominalRatePercent: number, compoundsPerYear: number): number;
+    ruleOf72(ratePercent: number): number;
+    breakEven(fixedCost: number, pricePerUnit: number, variableCostPerUnit: number): number;
+    presentValue(futureValue: number, ratePercent: number, years: number): number;
+    futureValue(presentValue: number, ratePercent: number, years: number): number;
+    cagr(startValue: number, endValue: number, years: number): number;
+}
+
+type JoopCreditBand = 'exceptional' | 'very-good' | 'good' | 'fair' | 'poor';
+type JoopCreditFactor = 'payment-history' | 'utilization' | 'age-of-credit' | 'credit-mix' | 'new-inquiries';
+type JoopCreditTrend = 'improving' | 'declining' | 'stable';
+type JoopCreditAlertSeverity = 'info' | 'warning' | 'critical';
+interface JoopCreditEntry {
+    id: string;
+    score: number;
+    date: number;
+    source: string;
+    note?: string;
+}
+interface JoopCreditFactorScore {
+    factor: JoopCreditFactor;
+    score: number;
+    weight: number;
+    impact: 'positive' | 'negative' | 'neutral';
+    description: string;
+}
+interface JoopCreditAlert {
+    id: string;
+    type: string;
+    severity: JoopCreditAlertSeverity;
+    message: string;
+    date: number;
+    acknowledged: boolean;
+}
+interface JoopCreditReport {
+    currentScore: number | null;
+    band: JoopCreditBand | null;
+    trend: JoopCreditTrend;
+    change30d: number | null;
+    change90d: number | null;
+    entries: JoopCreditEntry[];
+    factors: JoopCreditFactorScore[];
+    alerts: JoopCreditAlert[];
+}
+interface JoopCreditSimulation {
+    action: string;
+    currentScore: number;
+    estimatedChange: number;
+    estimatedScore: number;
+    confidence: 'low' | 'medium' | 'high';
+}
+declare class JoopCreditScoreService {
+    private _entries;
+    private _factors;
+    private _alerts;
+    private _score$;
+    addEntry(score: number, source?: string, note?: string): JoopCreditEntry;
+    getCurrentScore(): number | null;
+    getHistory(limit?: number): JoopCreditEntry[];
+    getBand(score?: number): JoopCreditBand | null;
+    getTrend(): JoopCreditTrend;
+    private _changeOver;
+    setFactors(factors: JoopCreditFactorScore[]): void;
+    getFactors(): JoopCreditFactorScore[];
+    setDefaultFactors(options?: {
+        paymentHistoryScore?: number;
+        utilizationScore?: number;
+        ageScore?: number;
+        mixScore?: number;
+        inquiriesScore?: number;
+    }): void;
+    addAlert(type: string, severity: JoopCreditAlertSeverity, message: string): JoopCreditAlert;
+    acknowledgeAlert(id: string): void;
+    getAlerts(unacknowledgedOnly?: boolean): JoopCreditAlert[];
+    simulateImpact(action: string): JoopCreditSimulation;
+    getReport(): JoopCreditReport;
+    score$(): JoopObservable<number | null>;
+}
+
+type JoopAssetCategory = 'cash' | 'investment' | 'real-estate' | 'vehicle' | 'retirement' | 'business' | 'personal-property' | 'other-asset';
+type JoopLiabilityCategory = 'mortgage' | 'auto-loan' | 'student-loan' | 'credit-card' | 'personal-loan' | 'business-loan' | 'other-liability';
+interface JoopFinancialAsset {
+    id: string;
+    name: string;
+    category: JoopAssetCategory;
+    value: number;
+    currency: string;
+    notes?: string;
+    asOf: number;
+}
+interface JoopFinancialLiability {
+    id: string;
+    name: string;
+    category: JoopLiabilityCategory;
+    balance: number;
+    interestRate?: number;
+    currency: string;
+    notes?: string;
+    asOf: number;
+}
+interface JoopNetWorthSnapshot {
+    id: string;
+    date: number;
+    totalAssets: number;
+    totalLiabilities: number;
+    netWorth: number;
+    assetsByCategory: Record<string, number>;
+    liabilitiesByCategory: Record<string, number>;
+}
+interface JoopNetWorthTrend {
+    snapshots: JoopNetWorthSnapshot[];
+    change: number;
+    changePercent: number;
+    direction: 'up' | 'down' | 'flat';
+}
+declare class JoopNetWorthService {
+    private _assets;
+    private _liabilities;
+    private _snapshots;
+    private _netWorth$;
+    addAsset(data: Omit<JoopFinancialAsset, 'id'>): JoopFinancialAsset;
+    updateAsset(id: string, patch: Partial<Omit<JoopFinancialAsset, 'id'>>): JoopFinancialAsset;
+    removeAsset(id: string): void;
+    getAsset(id: string): JoopFinancialAsset | undefined;
+    getAssets(): JoopFinancialAsset[];
+    addLiability(data: Omit<JoopFinancialLiability, 'id'>): JoopFinancialLiability;
+    updateLiability(id: string, patch: Partial<Omit<JoopFinancialLiability, 'id'>>): JoopFinancialLiability;
+    removeLiability(id: string): void;
+    getLiability(id: string): JoopFinancialLiability | undefined;
+    getLiabilities(): JoopFinancialLiability[];
+    getTotalAssets(): number;
+    getTotalLiabilities(): number;
+    getNetWorth(): number;
+    getAssetsByCategory(): Record<JoopAssetCategory, number>;
+    getLiabilitiesByCategory(): Record<JoopLiabilityCategory, number>;
+    getDebtToAssetRatio(): number;
+    snapshot(): JoopNetWorthSnapshot;
+    getHistory(): JoopNetWorthSnapshot[];
+    getTrend(periods?: number): JoopNetWorthTrend;
+    netWorth$(): JoopObservable<number>;
+    private _emit;
+    private _requireAsset;
+    private _requireLiability;
+}
+
+type JoopCashFlowCategory = 'income' | 'expense' | 'transfer' | 'tax' | 'investment';
+type JoopCashFlowFrequency = 'daily' | 'weekly' | 'biweekly' | 'monthly' | 'quarterly' | 'yearly';
+type JoopCashFlowDirection = 'inflow' | 'outflow';
+interface JoopCashFlowEntry {
+    id: string;
+    direction: JoopCashFlowDirection;
+    amount: number;
+    category: JoopCashFlowCategory;
+    description: string;
+    date: number;
+    currency: string;
+    isRecurring: boolean;
+    frequency?: JoopCashFlowFrequency;
+    endDate?: number;
+    tags?: string[];
+}
+interface JoopCashFlowPeriod {
+    from: number;
+    to: number;
+    totalInflow: number;
+    totalOutflow: number;
+    netCashFlow: number;
+    entries: JoopCashFlowEntry[];
+}
+interface JoopCashFlowForecast {
+    from: number;
+    to: number;
+    periods: JoopCashFlowPeriod[];
+    projectedInflow: number;
+    projectedOutflow: number;
+    projectedNet: number;
+}
+interface JoopBurnRateResult {
+    dailyBurnRate: number;
+    monthlyBurnRate: number;
+    periodDays: number;
+}
+interface JoopRunwayResult {
+    runwayDays: number;
+    runwayMonths: number;
+    currentBalance: number;
+    monthlyBurnRate: number;
+}
+interface JoopCategoryBreakdown {
+    category: JoopCashFlowCategory;
+    inflow: number;
+    outflow: number;
+    net: number;
+}
+declare class JoopCashFlowService {
+    private _entries;
+    private _netCash$;
+    addEntry(direction: JoopCashFlowDirection, amount: number, category: JoopCashFlowCategory, description: string, date: number, opts?: {
+        currency?: string;
+        isRecurring?: boolean;
+        frequency?: JoopCashFlowFrequency;
+        endDate?: number;
+        tags?: string[];
+    }): JoopCashFlowEntry;
+    updateEntry(id: string, patch: Partial<Omit<JoopCashFlowEntry, 'id'>>): JoopCashFlowEntry;
+    removeEntry(id: string): void;
+    getEntry(id: string): JoopCashFlowEntry | undefined;
+    getEntries(from?: number, to?: number): JoopCashFlowEntry[];
+    getInflow(from: number, to: number): number;
+    getOutflow(from: number, to: number): number;
+    getNetCashFlow(from: number, to: number): number;
+    getCategoryBreakdown(from: number, to: number): JoopCategoryBreakdown[];
+    getBurnRate(periodDays?: number): JoopBurnRateResult;
+    getRunway(currentBalance: number, periodDays?: number): JoopRunwayResult;
+    forecast(from: number, to: number, granularityDays?: number): JoopCashFlowForecast;
+    cashFlow$(): JoopBehaviorSubject<number>;
+    private _getEntry;
+    private _emit;
+    /** Expand recurring entries into concrete occurrences within [from, to]. */
+    private _expandRecurring;
+}
+
+interface JoopJwtHeader {
+    alg: string;
+    typ?: string;
+    kid?: string;
+    [key: string]: unknown;
+}
+interface JoopJwtClaims {
+    sub?: string;
+    iss?: string;
+    aud?: string | string[];
+    exp?: number;
+    iat?: number;
+    nbf?: number;
+    jti?: string;
+    [key: string]: unknown;
+}
+interface JoopJwtParseResult {
+    header: JoopJwtHeader;
+    claims: JoopJwtClaims;
+    signature: string;
+    raw: string;
+}
+interface JoopJwtValidationResult {
+    valid: boolean;
+    expired: boolean;
+    claims?: JoopJwtClaims;
+    reason?: string;
+}
+interface JoopJwtConfig {
+    issuer?: string;
+    audience?: string | string[];
+    clockSkewMs?: number;
+}
+interface JoopJwtRefreshConfig {
+    refreshThresholdMs?: number;
+    refreshFn: (token: string) => Promise<{
+        accessToken: string;
+        refreshToken?: string;
+    }>;
+    onRefreshed?: (tokens: {
+        accessToken: string;
+        refreshToken?: string;
+    }) => void;
+    onError?: (err: Error) => void;
+}
+declare class JoopJwtService {
+    private readonly clockSkewMs;
+    private readonly issuer?;
+    private readonly audience?;
+    private _refreshTimer?;
+    constructor(config?: JoopJwtConfig);
+    parse(token: string): JoopJwtParseResult;
+    validate(token: string): JoopJwtValidationResult;
+    isExpired(token: string): boolean;
+    getExpiry(token: string): Date | null;
+    getTimeToExpiry(token: string): number;
+    getClaim<T>(token: string, key: string): T | undefined;
+    startAutoRefresh(token: string, config: JoopJwtRefreshConfig): (newToken: string) => void;
+    stopAutoRefresh(): void;
+    static decode(token: string): JoopJwtParseResult;
+}
+
+interface JoopEmiScheduleEntry {
+    month: number;
+    instalment: number;
+    principal: number;
+    interest: number;
+    balance: number;
+}
+interface JoopEmiResult {
+    monthlyInstalment: number;
+    totalAmount: number;
+    totalInterest: number;
+    effectiveAnnualRate: number;
+    schedule: JoopEmiScheduleEntry[];
+}
+interface JoopPrepaymentResult {
+    mode: 'reduce-tenure' | 'reduce-emi';
+    savedInterest: number;
+    newTenureMonths?: number;
+    newMonthlyInstalment?: number;
+    originalTotalInterest: number;
+    newTotalInterest: number;
+}
+interface JoopAffordabilityResult {
+    maxLoan: number;
+    maxEmi: number;
+    dtiRatio: number;
+}
+declare class JoopEmiCalculator {
+    /** Reducing-balance EMI (standard bank method). */
+    calculate(principal: number, annualRate: number, tenureMonths: number): JoopEmiResult;
+    /** Flat-rate EMI — interest computed on original principal throughout. */
+    calculateFlat(principal: number, annualRate: number, tenureMonths: number): JoopEmiResult;
+    /** Impact of a lump-sum prepayment — either shorten tenure or reduce EMI. */
+    prepayment(principal: number, annualRate: number, tenureMonths: number, prepayAmount: number, prepayAtMonth: number, mode: 'reduce-tenure' | 'reduce-emi'): JoopPrepaymentResult;
+    /** Maximum loan a borrower can afford given income, obligations, and a DTI cap. */
+    affordability(monthlyIncome: number, existingObligations: number, annualRate: number, tenureMonths: number, maxDtiRatio?: number): JoopAffordabilityResult;
+}
+
+type JoopTransactionCategory = 'groceries' | 'utilities' | 'salary' | 'transfer' | 'entertainment' | 'dining' | 'travel' | 'healthcare' | 'education' | 'shopping' | 'fuel' | 'insurance' | 'emi' | 'tax' | 'fees' | 'atm' | 'other';
+interface JoopTransaction {
+    description: string;
+    amount: number;
+    type?: 'credit' | 'debit';
+    merchantCode?: string;
+}
+interface JoopCategoryRule {
+    category: JoopTransactionCategory;
+    keywords?: string[];
+    patterns?: RegExp[];
+    merchantCodes?: string[];
+    amountRange?: {
+        min?: number;
+        max?: number;
+    };
+    type?: 'credit' | 'debit';
+    priority?: number;
+    label?: string;
+}
+interface JoopCategorizationResult {
+    category: JoopTransactionCategory;
+    confidence: number;
+    matchedRule?: string;
+}
+declare class JoopTransactionCategorizer {
+    private rules;
+    constructor(customRules?: JoopCategoryRule[]);
+    categorize(tx: JoopTransaction): JoopCategorizationResult;
+    categorizeBatch(txs: JoopTransaction[]): JoopCategorizationResult[];
+    addRule(rule: JoopCategoryRule): void;
+    removeRule(label: string): void;
+    getRules(): JoopCategoryRule[];
+    getCategories(): JoopTransactionCategory[];
+}
+
+type JoopEventMap = Record<string, any>;
+interface JoopEventBusOptions {
+    replayLast?: boolean;
+    maxHistory?: number;
+    maxListeners?: number;
+}
+interface JoopEventMeta {
+    event: string;
+    timestamp: number;
+    id: string;
+}
+type JoopEventHandler<T = unknown> = (payload: T, meta: JoopEventMeta) => void;
+type JoopAnyHandler = (event: string, payload: unknown, meta: JoopEventMeta) => void;
+interface JoopEventHistoryEntry {
+    event: string;
+    payload: unknown;
+    meta: JoopEventMeta;
+}
+declare class JoopEventBus<TMap extends JoopEventMap = JoopEventMap> {
+    private readonly listeners;
+    private readonly onceMarked;
+    private readonly wildcards;
+    private readonly anyHandlers;
+    private readonly lastEmitted;
+    private readonly _history;
+    private readonly opts;
+    constructor(options?: JoopEventBusOptions);
+    on<K extends keyof TMap>(event: K, handler: JoopEventHandler<TMap[K]>): () => void;
+    once<K extends keyof TMap>(event: K, handler: JoopEventHandler<TMap[K]>): () => void;
+    off<K extends keyof TMap>(event: K, handler: JoopEventHandler<TMap[K]>): void;
+    emit<K extends keyof TMap>(event: K, payload: TMap[K]): void;
+    onWildcard(pattern: string | RegExp, handler: JoopEventHandler<unknown>): () => void;
+    onAny(handler: JoopAnyHandler): () => void;
+    waitFor<K extends keyof TMap>(event: K, timeoutMs?: number): Promise<TMap[K]>;
+    history(event?: keyof TMap, limit?: number): JoopEventHistoryEntry[];
+    listenerCount(event?: keyof TMap): number;
+    clear(event?: keyof TMap): void;
+}
+declare const joopEventBus: JoopEventBus<JoopEventMap>;
+
+type JoopKycStatus = 'unverified' | 'started' | 'docs_submitted' | 'under_review' | 'additional_info_required' | 'verified' | 'rejected' | 'expired';
+type JoopKycDocumentType = 'passport' | 'national_id' | 'driving_license' | 'utility_bill' | 'bank_statement' | 'selfie' | 'proof_of_address';
+interface JoopKycDocument {
+    type: JoopKycDocumentType;
+    status: 'pending' | 'accepted' | 'rejected';
+    submittedAt: number;
+    url?: string;
+    rejectionReason?: string;
+}
+interface JoopKycContext {
+    userId: string;
+    status: JoopKycStatus;
+    documents: JoopKycDocument[];
+    reviewNotes: string[];
+    startedAt?: number;
+    submittedAt?: number;
+    completedAt?: number;
+    rejectionReason?: string;
+    metadata: Record<string, unknown>;
+}
+interface JoopKycHistoryEntry {
+    from: JoopKycStatus;
+    to: JoopKycStatus;
+    event: string;
+    timestamp: number;
+}
+type TransitionFn = (from: JoopKycStatus, to: JoopKycStatus, ctx: JoopKycContext) => void;
+type EnterFn = (ctx: JoopKycContext) => void;
+declare class JoopKycStateMachine {
+    private ctx;
+    private readonly _history;
+    private readonly transitionListeners;
+    private readonly enterListeners;
+    constructor(userId: string, initialStatus?: JoopKycStatus);
+    private transition;
+    start(): Promise<void>;
+    submitDocuments(docs: Omit<JoopKycDocument, 'submittedAt'>[]): Promise<void>;
+    beginReview(): Promise<void>;
+    requestMoreInfo(reason: string): Promise<void>;
+    approve(): Promise<void>;
+    reject(reason: string): Promise<void>;
+    expire(): Promise<void>;
+    resubmit(docs: Omit<JoopKycDocument, 'submittedAt'>[]): Promise<void>;
+    restart(): Promise<void>;
+    getContext(): JoopKycContext;
+    getStatus(): JoopKycStatus;
+    canTransitionTo(status: JoopKycStatus): boolean;
+    getAvailableTransitions(): string[];
+    getHistory(): readonly JoopKycHistoryEntry[];
+    onTransition(fn: TransitionFn): () => void;
+    onEnter(status: JoopKycStatus, fn: EnterFn): () => void;
+    setMetadata(key: string, value: unknown): void;
+    serialize(): string;
+    static deserialize(data: string): JoopKycStateMachine;
+}
+
+type JoopAmlRuleType = 'velocity' | 'threshold' | 'structuring' | 'geographic' | 'watchlist' | 'pattern';
+type JoopAmlAlertSeverity = 'low' | 'medium' | 'high' | 'critical';
+type JoopAmlDisposition = 'true-positive' | 'false-positive' | 'pending';
+type JoopAmlTxnType = 'credit' | 'debit';
+interface JoopAmlTransaction {
+    id: string;
+    entityId: string;
+    entityName?: string;
+    amount: number;
+    currency: string;
+    type: JoopAmlTxnType;
+    country?: string;
+    date: number;
+    description?: string;
+}
+interface JoopAmlRule {
+    id: string;
+    name: string;
+    type: JoopAmlRuleType;
+    enabled: boolean;
+    severity: JoopAmlAlertSeverity;
+    params: Record<string, unknown>;
+}
+interface JoopAmlAlert {
+    id: string;
+    ruleId: string;
+    ruleName: string;
+    severity: JoopAmlAlertSeverity;
+    entityId: string;
+    transactionIds: string[];
+    description: string;
+    raisedAt: number;
+    disposition: JoopAmlDisposition;
+    reviewedAt?: number;
+    reviewedBy?: string;
+}
+interface JoopAmlStats {
+    total: number;
+    pending: number;
+    truePositive: number;
+    falsePositive: number;
+    bySeverity: Record<JoopAmlAlertSeverity, number>;
+    byRule: Record<string, number>;
+}
+declare class JoopAmlService {
+    private _rules;
+    private _alerts;
+    private _txnHistory;
+    private _watchlist;
+    private _highRisk;
+    private _alert$;
+    constructor();
+    addRule(data: Omit<JoopAmlRule, 'id'>): JoopAmlRule;
+    enableRule(id: string): void;
+    disableRule(id: string): void;
+    getRules(): JoopAmlRule[];
+    addToWatchlist(name: string): void;
+    removeFromWatchlist(name: string): void;
+    isOnWatchlist(name: string): boolean;
+    addHighRiskCountry(code: string): void;
+    removeHighRiskCountry(code: string): void;
+    isHighRisk(countryCode: string): boolean;
+    screenTransaction(txn: JoopAmlTransaction): JoopAmlAlert[];
+    getAlerts(disposition?: JoopAmlDisposition): JoopAmlAlert[];
+    getEntityAlerts(entityId: string): JoopAmlAlert[];
+    reviewAlert(id: string, disposition: 'true-positive' | 'false-positive', reviewedBy?: string): JoopAmlAlert;
+    getStats(): JoopAmlStats;
+    alert$(): JoopObservable<JoopAmlAlert>;
+    private _applyRule;
+    private _makeAlert;
+    private _getRule;
+}
+
+type JoopFundCategory = 'equity' | 'debt' | 'hybrid' | 'money-market' | 'index' | 'etf';
+type JoopSipStatus = 'active' | 'paused' | 'cancelled' | 'completed';
+type JoopFundTxnType = 'invest' | 'redeem' | 'sip' | 'dividend';
+interface JoopMutualFund {
+    symbol: string;
+    name: string;
+    category: JoopFundCategory;
+    currentNav: number;
+    currency: string;
+    navUpdatedAt: number;
+    isinCode?: string;
+    expenseRatio?: number;
+}
+interface JoopFundHolding {
+    id: string;
+    symbol: string;
+    investorId: string;
+    units: number;
+    averageNav: number;
+    totalInvested: number;
+    currentValue: number;
+    unrealizedGain: number;
+    returnPercent: number;
+    createdAt: number;
+    lastUpdatedAt: number;
+}
+interface JoopSip {
+    id: string;
+    symbol: string;
+    investorId: string;
+    amount: number;
+    currency: string;
+    frequency: 'weekly' | 'monthly' | 'quarterly';
+    startDate: number;
+    nextExecutionDate: number;
+    endDate?: number;
+    status: JoopSipStatus;
+    executionCount: number;
+    totalInvested: number;
+}
+interface JoopFundTransaction {
+    id: string;
+    holdingId: string;
+    symbol: string;
+    investorId: string;
+    type: JoopFundTxnType;
+    units: number;
+    nav: number;
+    amount: number;
+    executedAt: number;
+    sipId?: string;
+}
+interface JoopFundPortfolioSummary {
+    investorId: string;
+    totalInvested: number;
+    currentValue: number;
+    totalUnrealizedGain: number;
+    totalReturnPercent: number;
+    holdings: JoopFundHolding[];
+}
+declare class JoopMutualFundService {
+    private _funds;
+    private _holdings;
+    private _sips;
+    private _txns;
+    private _change$;
+    addFund(symbol: string, name: string, category: JoopFundCategory, currentNav: number, opts?: {
+        currency?: string;
+        isinCode?: string;
+        expenseRatio?: number;
+    }): JoopMutualFund;
+    updateNav(symbol: string, newNav: number): JoopMutualFund;
+    getFund(symbol: string): JoopMutualFund | undefined;
+    getFunds(): JoopMutualFund[];
+    invest(symbol: string, investorId: string, amount: number, opts?: {
+        sipId?: string;
+    }): JoopFundHolding;
+    redeem(holdingId: string, units: number): JoopFundTransaction;
+    createSip(symbol: string, investorId: string, amount: number, frequency: JoopSip['frequency'], startDate: number, opts?: {
+        endDate?: number;
+    }): JoopSip;
+    executeSip(sipId: string): JoopFundHolding;
+    pauseSip(sipId: string): JoopSip;
+    resumeSip(sipId: string): JoopSip;
+    cancelSip(sipId: string): JoopSip;
+    getSip(id: string): JoopSip | undefined;
+    getSipsByInvestor(investorId: string): JoopSip[];
+    getHolding(id: string): JoopFundHolding | undefined;
+    getHoldingsByInvestor(investorId: string): JoopFundHolding[];
+    getPortfolioSummary(investorId: string): JoopFundPortfolioSummary;
+    getTransactions(investorId?: string): JoopFundTransaction[];
+    change$(): JoopSubject<JoopFundHolding>;
+    private _getFund;
+    private _getHolding;
+    private _getSip;
+    private _findHolding;
+    private _refreshHolding;
+    private _recordTxn;
+    private _setSipStatus;
+    private _setSipStat;
+}
+
+type JoopSanctionsList = 'ofac' | 'un' | 'eu' | 'uk' | 'custom';
+type JoopSanctionEntityType = 'individual' | 'entity' | 'vessel' | 'aircraft';
+type JoopSanctionMatchType = 'exact' | 'alias' | 'fuzzy';
+interface JoopSanctionEntry {
+    id: string;
+    list: JoopSanctionsList;
+    name: string;
+    normalizedName: string;
+    entityType: JoopSanctionEntityType;
+    country?: string;
+    aliases: string[];
+    normalizedAliases: string[];
+    reference?: string;
+    addedAt: number;
+    notes?: string;
+}
+interface JoopSanctionHit {
+    entryId: string;
+    list: JoopSanctionsList;
+    matchedName: string;
+    matchType: JoopSanctionMatchType;
+    score: number;
+    entry: JoopSanctionEntry;
+}
+interface JoopScreenResult {
+    id: string;
+    screenedName: string;
+    normalizedInput: string;
+    screenedAt: number;
+    hits: JoopSanctionHit[];
+    isClear: boolean;
+    threshold: number;
+}
+interface JoopScreeningStats {
+    totalEntries: number;
+    entriesByList: Record<string, number>;
+    totalScreened: number;
+    totalHits: number;
+}
+declare class JoopSanctionsScreeningService {
+    private _entries;
+    private _results;
+    private _disabledLists;
+    private _hit$;
+    addEntry(list: JoopSanctionsList, name: string, entityType: JoopSanctionEntityType, opts?: {
+        country?: string;
+        aliases?: string[];
+        reference?: string;
+        notes?: string;
+    }): JoopSanctionEntry;
+    addBulk(entries: Omit<Parameters<JoopSanctionsScreeningService['addEntry']>[0 | 1 | 2 | 3], never>[]): JoopSanctionEntry[];
+    removeEntry(id: string): void;
+    updateEntry(id: string, patch: Partial<Pick<JoopSanctionEntry, 'name' | 'aliases' | 'country' | 'notes'>>): JoopSanctionEntry;
+    getEntries(list?: JoopSanctionsList): JoopSanctionEntry[];
+    disableList(list: JoopSanctionsList): void;
+    enableList(list: JoopSanctionsList): void;
+    isListEnabled(list: JoopSanctionsList): boolean;
+    screen(name: string, opts?: {
+        threshold?: number;
+        lists?: JoopSanctionsList[];
+    }): JoopScreenResult;
+    screenBatch(names: string[], opts?: {
+        threshold?: number;
+        lists?: JoopSanctionsList[];
+    }): JoopScreenResult[];
+    getResult(id: string): JoopScreenResult | undefined;
+    getResults(hitOnly?: boolean): JoopScreenResult[];
+    isClear(resultId: string): boolean;
+    getStats(): JoopScreeningStats;
+    hit$(): JoopSubject<JoopScreenResult>;
+}
+
+export { DECRYPTION_FAILED, DEFAULT_REQUEST_TIMEOUT, DEFAULT_SESSION_TIMEOUT, DEFAULT_SESSION_WAIT_TIMEOUT, type JoopAffordabilityResult, type JoopAmlAlert, type JoopAmlAlertSeverity, type JoopAmlDisposition, type JoopAmlRule, type JoopAmlRuleType, JoopAmlService, type JoopAmlStats, type JoopAmlTransaction, type JoopAmlTxnType, type JoopAnyHandler, type JoopAssetCategory, type JoopAssetType, type JoopAutoDebitFrequency, JoopBehaviorSubject, type JoopBudgetCategory, type JoopBudgetEntry, type JoopBudgetPeriod, JoopBudgetService, type JoopBudgetStatus, type JoopBudgetSummary, type JoopBurnRateResult, type JoopCapitalGainsTaxResult, type JoopCashFlowCategory, type JoopCashFlowDirection, type JoopCashFlowEntry, type JoopCashFlowForecast, type JoopCashFlowFrequency, type JoopCashFlowPeriod, JoopCashFlowService, type JoopCategorizationResult, type JoopCategoryBreakdown, type JoopCategoryRule, type JoopCompoundFrequency, type JoopCompoundInterestResult, type JoopConversionResult, type JoopCreditAlert, type JoopCreditAlertSeverity, type JoopCreditBand, type JoopCreditEntry, type JoopCreditFactor, type JoopCreditFactorScore, type JoopCreditReport, type JoopCreditScoreRating, JoopCreditScoreService, type JoopCreditSimulation, type JoopCreditTrend, JoopCurrencyExchangeService, type JoopEmiBreakdown, JoopEmiCalculator, type JoopEmiResult, type JoopEmiScheduleEntry, type JoopEncryptedResponse, JoopEventBus, type JoopEventBusOptions, type JoopEventHandler, type JoopEventHistoryEntry, type JoopEventMap, type JoopEventMeta, type JoopExchangeRate, type JoopExchangeRateProvider, type JoopFinancialAsset, type JoopFinancialLiability, type JoopFixedDepositResult, type JoopFundCategory, type JoopFundHolding, type JoopFundPortfolioSummary, type JoopFundTransaction, type JoopFundTxnType, type JoopGoalStatus, type JoopGstResult, type JoopHolding, type JoopHoldingPerformance, type JoopIncomeTaxResult, JoopInterestCalculatorService, type JoopJwtClaims, type JoopJwtConfig, type JoopJwtHeader, type JoopJwtParseResult, type JoopJwtRefreshConfig, JoopJwtService, type JoopJwtValidationResult, type JoopKycContext, type JoopKycDocument, type JoopKycDocumentType, type JoopKycHistoryEntry, JoopKycStateMachine, type JoopKycStatus, type JoopLiabilityCategory, type JoopLoanApplicant, type JoopLoanEligibilityResult, JoopLoanEligibilityService, type JoopLoanParams, type JoopLoanProduct, type JoopLoanType, type JoopLoyaltyEarnRule, JoopLoyaltyService, type JoopLoyaltySummary, type JoopLoyaltyTier, type JoopLoyaltyTierDef, type JoopLoyaltyTransaction, type JoopLoyaltyTxnType, type JoopMutualFund, JoopMutualFundService, JoopNetWorthService, type JoopNetWorthSnapshot, type JoopNetWorthTrend, JoopObservable, JoopPortfolioService, type JoopPortfolioSummary, type JoopPrepaymentResult, type JoopRecurringDepositResult, type JoopRunwayResult, type JoopSanctionEntityType, type JoopSanctionEntry, type JoopSanctionHit, type JoopSanctionMatchType, type JoopSanctionsList, JoopSanctionsScreeningService, type JoopSavingsGoal, JoopSavingsGoalService, type JoopSavingsProgress, type JoopSavingsProjection, type JoopSavingsProjectionEntry, type JoopSavingsTransaction, type JoopScreenResult, type JoopScreeningStats, type JoopSimpleInterestResult, type JoopSip, type JoopSipStatus, JoopSubject, type JoopTaxBracket, JoopTaxBrackets, JoopTaxCalculatorService, type JoopTaxDeduction, type JoopTaxSummary, type JoopTransaction, JoopTransactionCategorizer, type JoopTransactionCategory, PAGE_TOKEN_KEY, SESSION_STORAGE_KEY, joopEventBus };