@a-cube-io/ereceipts-js-sdk 2.0.8 → 2.0.9

package/dist/index.esm.js

@@ -1392,6 +1392,15 @@ function from(input, scheduler) {
     return scheduler ? scheduled(input, scheduler) : innerFrom(input);
 }
 
+function of() {
+    var args = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+        args[_i] = arguments[_i];
+    }
+    var scheduler = popScheduler(args);
+    return from(args, scheduler);
+}
+
 function isValidDate(value) {
     return value instanceof Date && !isNaN(value);
 }
@@ -2103,7 +2112,7 @@ function formatDecimal(value, decimals = 2) {
     return num.toFixed(decimals);
 }
 
-const log$g = createPrefixedLogger('AUTH-SERVICE');
+const log$h = createPrefixedLogger('AUTH-SERVICE');
 class AuthenticationService {
     get user$() {
         return this.userSubject.asObservable();
@@ -2125,7 +2134,7 @@ class AuthenticationService {
     }
     async login(credentials) {
         this.authStateSubject.next('authenticating');
-        log$g.info('Login attempt', {
+        log$h.info('Login attempt', {
             authUrl: this.config.authUrl,
             email: credentials.email,
         });
@@ -2136,7 +2145,7 @@ class AuthenticationService {
             });
             const jwtPayload = parseJwt(response.data.token);
             const expiresAt = jwtPayload.exp * 1000;
-            log$g.info('Login successful', {
+            log$h.info('Login successful', {
                 authUrl: this.config.authUrl,
                 tokenPrefix: response.data.token.substring(0, 30) + '...',
                 expiresAt: new Date(expiresAt).toISOString(),
@@ -2165,21 +2174,21 @@ class AuthenticationService {
         const token = await this.tokenStorage.getAccessToken();
         if (!token) {
             // No token - clear any stale user state
-            log$g.debug('getCurrentUser: No token in storage');
+            log$h.debug('getCurrentUser: No token in storage');
             if (this.userSubject.value) {
                 this.userSubject.next(null);
                 this.authStateSubject.next('idle');
             }
             return null;
         }
-        log$g.debug('getCurrentUser: Token found', {
+        log$h.debug('getCurrentUser: Token found', {
             tokenPrefix: token.substring(0, 30) + '...',
             tokenLength: token.length,
         });
         const jwtPayload = parseJwt(token);
         if (isTokenExpired(jwtPayload)) {
             // Token expired - clear everything
-            log$g.warn('getCurrentUser: Token expired');
+            log$h.warn('getCurrentUser: Token expired');
             await this.tokenStorage.clearTokens();
             this.userSubject.next(null);
             this.authStateSubject.next('idle');
@@ -2189,7 +2198,7 @@ class AuthenticationService {
         // Token is valid - return cached user if available
         const currentUser = this.userSubject.value;
         if (currentUser) {
-            log$g.debug('getCurrentUser: Returning cached user', {
+            log$h.debug('getCurrentUser: Returning cached user', {
                 email: currentUser.email,
                 roles: currentUser.roles,
             });
@@ -2212,12 +2221,12 @@ class AuthenticationService {
     async isAuthenticated() {
         const token = await this.tokenStorage.getAccessToken();
         if (!token) {
-            log$g.debug('isAuthenticated: No token in storage');
+            log$h.debug('isAuthenticated: No token in storage');
             return false;
         }
         const jwtPayload = parseJwt(token);
         const expired = isTokenExpired(jwtPayload);
-        log$g.debug('isAuthenticated: Token check', {
+        log$h.debug('isAuthenticated: Token check', {
             hasToken: true,
             expired,
             expiresAt: new Date(jwtPayload.exp * 1000).toISOString(),
@@ -2889,7 +2898,7 @@ class ACubeSDKError extends Error {
     }
 }
 
-const log$f = createPrefixedLogger('AUTH-STRATEGY');
+const log$g = createPrefixedLogger('AUTH-STRATEGY');
 class AuthStrategy {
     constructor(jwtHandler, mtlsHandler, userProvider, mtlsAdapter) {
         this.jwtHandler = jwtHandler;
@@ -2904,7 +2913,7 @@ class AuthStrategy {
         const platform = this.detectPlatform();
         const userRole = await this.getUserRole();
         const isReceiptEndpoint = this.isReceiptEndpoint(url);
-        log$f.debug('Determining auth config', {
+        log$g.debug('Determining auth config', {
             url,
             method,
             platform,
@@ -3035,7 +3044,7 @@ class JwtAuthHandler {
     }
 }
 
-const log$e = createPrefixedLogger('MTLS-HANDLER');
+const log$f = createPrefixedLogger('MTLS-HANDLER');
 class MtlsAuthHandler {
     constructor(mtlsAdapter, certificatePort) {
         this.mtlsAdapter = mtlsAdapter;
@@ -3077,7 +3086,7 @@ class MtlsAuthHandler {
     async makeRequest(url, config, jwtToken) {
         const requestKey = this.generateRequestKey(url, config, jwtToken);
         if (this.pendingRequests.has(requestKey)) {
-            log$e.debug('Deduplicating concurrent request:', url);
+            log$f.debug('Deduplicating concurrent request:', url);
             return this.pendingRequests.get(requestKey);
         }
         const requestPromise = this.executeRequest(url, config, jwtToken, false);
@@ -3101,10 +3110,10 @@ class MtlsAuthHandler {
         };
         if (jwtToken) {
             headers['Authorization'] = `Bearer ${jwtToken}`;
-            log$e.debug('JWT token present:', jwtToken.substring(0, 20) + '...');
+            log$f.debug('JWT token present:', jwtToken.substring(0, 20) + '...');
         }
         else {
-            log$e.warn('No JWT token provided for mTLS request');
+            log$f.warn('No JWT token provided for mTLS request');
         }
         const fullUrl = this.constructMtlsUrl(url);
         const mtlsConfig = {
@@ -3115,25 +3124,25 @@ class MtlsAuthHandler {
             timeout: config.timeout,
             responseType: config.responseType,
         };
-        log$e.debug('header-mtls', headers);
-        log$e.debug(`${config.method} ${fullUrl}`);
+        log$f.debug('header-mtls', headers);
+        log$f.debug(`${config.method} ${fullUrl}`);
         if (config.data) {
-            log$e.debug('Request body:', config.data);
+            log$f.debug('Request body:', config.data);
         }
         try {
             const response = await this.mtlsAdapter.request(mtlsConfig);
-            log$e.debug(`Response ${response.status} from ${fullUrl}`);
+            log$f.debug(`Response ${response.status} from ${fullUrl}`);
             if (response.data) {
-                log$e.debug('Response body:', response.data);
+                log$f.debug('Response body:', response.data);
             }
             return response.data;
         }
         catch (error) {
-            log$e.error(`Response error from ${fullUrl}:`, error);
+            log$f.error(`Response error from ${fullUrl}:`, error);
             if (error && typeof error === 'object' && 'response' in error) {
                 const axiosError = error;
                 if (axiosError.response?.data) {
-                    log$e.error('Response body:', axiosError.response.data);
+                    log$f.error('Response body:', axiosError.response.data);
                 }
             }
             if (isRetryAttempt) {
@@ -3143,7 +3152,7 @@ class MtlsAuthHandler {
             if (!shouldRetry) {
                 throw error;
             }
-            log$e.debug('Request failed, reconfiguring certificate and retrying...');
+            log$f.debug('Request failed, reconfiguring certificate and retrying...');
             try {
                 await this.configureCertificate(certificate);
                 return await this.executeRequest(url, config, jwtToken, true);
@@ -3870,7 +3879,7 @@ function decompressData(data, compressed) {
     return new CompressionAdapter().decompress(data, compressed);
 }
 
-const log$d = createPrefixedLogger('CACHE-RN');
+const log$e = createPrefixedLogger('CACHE-RN');
 /**
  * React Native cache adapter using SQLite (Expo or react-native-sqlite-storage)
  * Cache never expires - data persists until explicitly invalidated
@@ -3954,26 +3963,26 @@ class ReactNativeCacheAdapter {
         await this.runMigrations();
     }
     async runMigrations() {
-        log$d.debug('Running database migrations...');
+        log$e.debug('Running database migrations...');
         try {
             // Check if compressed column exists
             this.hasCompressedColumn = await this.checkColumnExists('compressed');
             if (!this.hasCompressedColumn) {
-                log$d.debug('Adding compressed column to cache table');
+                log$e.debug('Adding compressed column to cache table');
                 const addColumnSQL = `ALTER TABLE ${ReactNativeCacheAdapter.TABLE_NAME} ADD COLUMN compressed INTEGER DEFAULT 0`;
                 await this.executeSql(addColumnSQL);
                 this.hasCompressedColumn = true;
-                log$d.debug('Successfully added compressed column');
+                log$e.debug('Successfully added compressed column');
             }
             else {
-                log$d.debug('Compressed column already exists');
+                log$e.debug('Compressed column already exists');
             }
-            log$d.debug('Database migrations completed', {
+            log$e.debug('Database migrations completed', {
                 hasCompressedColumn: this.hasCompressedColumn,
             });
         }
         catch (error) {
-            log$d.debug('Migration failed, disabling compression features', error);
+            log$e.debug('Migration failed, disabling compression features', error);
             this.hasCompressedColumn = false;
             // Don't throw - allow the app to continue even if migration fails
             // The compressed feature will just be disabled
@@ -3984,20 +3993,20 @@ class ReactNativeCacheAdapter {
             const pragmaSQL = `PRAGMA table_info(${ReactNativeCacheAdapter.TABLE_NAME})`;
             const results = await this.executeSql(pragmaSQL);
             const columns = this.normalizeResults(results);
-            log$d.debug('Table columns found', { columns: columns.map((c) => c.name) });
+            log$e.debug('Table columns found', { columns: columns.map((c) => c.name) });
             return columns.some((column) => column.name === columnName);
         }
         catch (error) {
-            log$d.debug('Error checking column existence', error);
+            log$e.debug('Error checking column existence', error);
             return false;
         }
     }
     async get(key) {
         await this.ensureInitialized();
         const sql = `SELECT * FROM ${ReactNativeCacheAdapter.TABLE_NAME} WHERE cache_key = ?`;
-        log$d.debug('Executing get query', { sql, key });
+        log$e.debug('Executing get query', { sql, key });
         const results = await this.executeSql(sql, [key]);
-        log$d.debug('Get query results', { key, hasResults: !!results });
+        log$e.debug('Get query results', { key, hasResults: !!results });
         // Normalize results from different SQLite implementations
         const rows = this.normalizeResults(results);
         if (!rows || rows.length === 0) {
@@ -4020,7 +4029,7 @@ class ReactNativeCacheAdapter {
             data,
             timestamp: Date.now(),
         };
-        log$d.debug('Setting cache item', { key });
+        log$e.debug('Setting cache item', { key });
         return this.setItem(key, item);
     }
     async setItem(key, item) {
@@ -4033,7 +4042,7 @@ class ReactNativeCacheAdapter {
             const compressionResult = compressData(serializedData, this.options.compressionThreshold);
             finalData = compressionResult.data;
             isCompressed = compressionResult.compressed;
-            log$d.debug('Compression result', {
+            log$e.debug('Compression result', {
                 key,
                 originalSize: compressionResult.originalSize,
                 compressedSize: compressionResult.compressedSize,
@@ -4041,7 +4050,7 @@ class ReactNativeCacheAdapter {
                 savings: compressionResult.originalSize - compressionResult.compressedSize,
             });
         }
-        log$d.debug('Setting item with metadata', {
+        log$e.debug('Setting item with metadata', {
             key,
             timestamp: item.timestamp,
             compressed: isCompressed,
@@ -4067,14 +4076,14 @@ class ReactNativeCacheAdapter {
       `;
             params = [key, finalData, item.timestamp];
         }
-        log$d.debug('Executing setItem SQL', { key, paramsCount: params.length });
+        log$e.debug('Executing setItem SQL', { key, paramsCount: params.length });
         await this.executeSql(sql, params);
     }
     async setBatch(items) {
         if (items.length === 0)
             return;
         await this.ensureInitialized();
-        log$d.debug('Batch setting items', { count: items.length });
+        log$e.debug('Batch setting items', { count: items.length });
         if (this.isExpo) {
             await this.db.withTransactionAsync(async () => {
                 for (const [key, item] of items) {
@@ -4092,7 +4101,7 @@ class ReactNativeCacheAdapter {
                 }, reject, () => resolve());
             });
         }
-        log$d.debug('Batch operation completed', { count: items.length });
+        log$e.debug('Batch operation completed', { count: items.length });
     }
     async setBatchItem(key, item) {
         // Handle compression if enabled and compressed column is available
@@ -4266,10 +4275,10 @@ class MemoryCacheAdapter {
         return keySize + itemSize;
     }
     async get(key) {
-        log$d.debug('Getting cache item', { key });
+        log$e.debug('Getting cache item', { key });
         const item = this.cache.get(key);
         if (!item) {
-            log$d.debug('Cache miss', { key });
+            log$e.debug('Cache miss', { key });
             return null;
         }
         // Handle decompression if needed
@@ -4279,7 +4288,7 @@ class MemoryCacheAdapter {
             const decompressed = decompressData(item.data, true);
             finalData = JSON.parse(decompressed.data);
         }
-        log$d.debug('Cache hit', { key, compressed: isCompressed });
+        log$e.debug('Cache hit', { key, compressed: isCompressed });
         return {
             ...item,
             data: finalData,
@@ -4287,7 +4296,7 @@ class MemoryCacheAdapter {
         };
     }
     async set(key, data) {
-        log$d.debug('Setting cache item', { key });
+        log$e.debug('Setting cache item', { key });
         // Handle compression if enabled
         let finalData = data;
         let isCompressed = false;
@@ -4297,7 +4306,7 @@ class MemoryCacheAdapter {
             if (compressionResult.compressed) {
                 finalData = compressionResult.data;
                 isCompressed = true;
-                log$d.debug('Compression result', {
+                log$e.debug('Compression result', {
                     key,
                     originalSize: compressionResult.originalSize,
                     compressedSize: compressionResult.compressedSize,
@@ -4329,13 +4338,13 @@ class MemoryCacheAdapter {
                 const oldestItemSize = this.calculateItemSize(oldestKey, oldestItem);
                 this.totalBytes -= oldestItemSize;
                 this.cache.delete(oldestKey);
-                log$d.debug('Removed oldest item for capacity', { oldestKey, freedBytes: oldestItemSize });
+                log$e.debug('Removed oldest item for capacity', { oldestKey, freedBytes: oldestItemSize });
             }
         }
         // Set new item and update total size
         this.cache.set(key, item);
         this.totalBytes += newItemSize;
-        log$d.debug('Updated cache size', {
+        log$e.debug('Updated cache size', {
             entries: this.cache.size,
             totalBytes: this.totalBytes,
             newItemSize,
@@ -4344,7 +4353,7 @@ class MemoryCacheAdapter {
     async setBatch(items) {
         if (items.length === 0)
             return;
-        log$d.debug('Batch setting items', { count: items.length });
+        log$e.debug('Batch setting items', { count: items.length });
         let totalNewBytes = 0;
         let totalOldBytes = 0;
         const itemsToRemove = [];
@@ -4373,7 +4382,7 @@ class MemoryCacheAdapter {
                 itemsToRemove.push(oldKey);
             }
             if (itemsToRemove.length > 0) {
-                log$d.debug('Removed items for batch capacity', {
+                log$e.debug('Removed items for batch capacity', {
                     removedCount: itemsToRemove.length,
                     removedKeys: itemsToRemove,
                 });
@@ -4385,7 +4394,7 @@ class MemoryCacheAdapter {
         for (const [key, item] of items) {
             this.cache.set(key, item);
         }
-        log$d.debug('Batch operation completed', {
+        log$e.debug('Batch operation completed', {
             count: items.length,
             totalBytes: this.totalBytes,
             entries: this.cache.size,
@@ -4407,7 +4416,7 @@ class MemoryCacheAdapter {
             }
         }
         if (removed > 0) {
-            log$d.debug('Invalidation completed', {
+            log$e.debug('Invalidation completed', {
                 pattern,
                 entriesRemoved: removed,
                 bytesFreed,
@@ -4419,7 +4428,7 @@ class MemoryCacheAdapter {
     async clear() {
         this.cache.clear();
         this.totalBytes = 0;
-        log$d.debug('Cache cleared', { entries: 0, bytes: 0 });
+        log$e.debug('Cache cleared', { entries: 0, bytes: 0 });
     }
     async getSize() {
         return {
@@ -4750,7 +4759,7 @@ replaceTraps((oldTraps) => ({
     },
 }));
 
-const log$c = createPrefixedLogger('CACHE-WEB');
+const log$d = createPrefixedLogger('CACHE-WEB');
 /**
  * Web cache adapter using IndexedDB with automatic error recovery
  * Cache never expires - data persists until explicitly invalidated
@@ -4773,18 +4782,18 @@ class WebCacheAdapter {
     async initialize() {
         if (this.db)
             return;
-        log$c.debug('Initializing IndexedDB cache', {
+        log$d.debug('Initializing IndexedDB cache', {
             dbName: WebCacheAdapter.DB_NAME,
             version: WebCacheAdapter.DB_VERSION,
         });
         try {
             this.db = await this.openDatabase();
-            log$c.debug('IndexedDB cache initialized successfully');
+            log$d.debug('IndexedDB cache initialized successfully');
             this.retryCount = 0; // Reset retry count on success
         }
         catch (error) {
             const errorMessage = error instanceof Error ? error.message : 'Unknown error';
-            log$c.debug('Failed to initialize IndexedDB', { error: errorMessage });
+            log$d.debug('Failed to initialize IndexedDB', { error: errorMessage });
             // Check if this is a version conflict error
             if (this.isVersionConflictError(errorMessage)) {
                 await this.handleVersionConflict();
@@ -4797,32 +4806,32 @@ class WebCacheAdapter {
     async openDatabase() {
         return await openDB(WebCacheAdapter.DB_NAME, WebCacheAdapter.DB_VERSION, {
             upgrade: (db, oldVersion, newVersion, transaction) => {
-                log$c.debug('Database upgrade needed', { oldVersion, newVersion });
+                log$d.debug('Database upgrade needed', { oldVersion, newVersion });
                 this.handleUpgrade(db, oldVersion, newVersion, transaction);
             },
             blocked: () => {
-                log$c.debug('Database blocked - another tab may be open');
+                log$d.debug('Database blocked - another tab may be open');
             },
             blocking: () => {
-                log$c.debug('Database blocking - will close connection');
+                log$d.debug('Database blocking - will close connection');
                 if (this.db) {
                     this.db.close();
                     this.db = null;
                 }
             },
             terminated: () => {
-                log$c.debug('Database connection terminated unexpectedly');
+                log$d.debug('Database connection terminated unexpectedly');
                 this.db = null;
             },
         });
     }
     handleUpgrade(db, oldVersion, newVersion, transaction) {
-        log$c.debug('Handling database upgrade', { oldVersion, newVersion });
+        log$d.debug('Handling database upgrade', { oldVersion, newVersion });
         // Create cache store if it doesn't exist (initial setup)
         if (!db.objectStoreNames.contains(WebCacheAdapter.STORE_NAME)) {
             const store = db.createObjectStore(WebCacheAdapter.STORE_NAME, { keyPath: 'key' });
             store.createIndex('timestamp', 'timestamp', { unique: false });
-            log$c.debug('Created cache store and timestamp index');
+            log$d.debug('Created cache store and timestamp index');
         }
         // Handle migration from version 1 to 2
         if (oldVersion < 2) {
@@ -4833,16 +4842,16 @@ class WebCacheAdapter {
                 try {
                     if (store.indexNames.contains(indexName)) {
                         store.deleteIndex(indexName);
-                        log$c.debug(`Removed unused index: ${indexName}`);
+                        log$d.debug(`Removed unused index: ${indexName}`);
                     }
                 }
                 catch (error) {
                     // Ignore errors if indexes don't exist
-                    log$c.debug(`Warning: Could not remove index ${indexName}`, error);
+                    log$d.debug(`Warning: Could not remove index ${indexName}`, error);
                 }
             });
         }
-        log$c.debug('Database upgrade completed');
+        log$d.debug('Database upgrade completed');
     }
     isVersionConflictError(errorMessage) {
         return (errorMessage.includes('less than the existing version') ||
@@ -4850,7 +4859,7 @@ class WebCacheAdapter {
             errorMessage.includes('VersionError'));
     }
     async handleVersionConflict() {
-        log$c.debug('Handling version conflict, attempting recovery...');
+        log$d.debug('Handling version conflict, attempting recovery...');
         if (this.retryCount >= this.maxRetries) {
             throw new Error('Failed to resolve IndexedDB version conflict after multiple attempts');
         }
@@ -4862,19 +4871,19 @@ class WebCacheAdapter {
                 this.db = null;
             }
             // Delete the problematic database
-            log$c.debug('Deleting problematic database to resolve version conflict');
+            log$d.debug('Deleting problematic database to resolve version conflict');
             await deleteDB(WebCacheAdapter.DB_NAME);
             // Wait a bit for the deletion to complete
             await new Promise((resolve) => setTimeout(resolve, 200));
             // Try to open the database again
-            log$c.debug(`Retrying database initialization (attempt ${this.retryCount}/${this.maxRetries})`);
+            log$d.debug(`Retrying database initialization (attempt ${this.retryCount}/${this.maxRetries})`);
             this.db = await this.openDatabase();
-            log$c.debug('Successfully recovered from version conflict');
+            log$d.debug('Successfully recovered from version conflict');
             this.retryCount = 0; // Reset retry count on success
         }
         catch (retryError) {
             const retryErrorMessage = retryError instanceof Error ? retryError.message : 'Unknown error';
-            log$c.debug('Recovery attempt failed', { attempt: this.retryCount, error: retryErrorMessage });
+            log$d.debug('Recovery attempt failed', { attempt: this.retryCount, error: retryErrorMessage });
             if (this.retryCount < this.maxRetries) {
                 // Try again
                 await this.handleVersionConflict();
@@ -4886,7 +4895,7 @@ class WebCacheAdapter {
     }
     async get(key) {
         await this.ensureInitialized();
-        log$c.debug('Getting cache item', { key });
+        log$d.debug('Getting cache item', { key });
         try {
             const transaction = this.db.transaction([WebCacheAdapter.STORE_NAME], 'readonly');
             const store = transaction.objectStore(WebCacheAdapter.STORE_NAME);
@@ -4912,7 +4921,7 @@ class WebCacheAdapter {
             };
         }
         catch (error) {
-            log$c.debug('Error getting cache item', { key, error });
+            log$d.debug('Error getting cache item', { key, error });
             return null; // Return null on error instead of throwing
         }
     }
@@ -4934,7 +4943,7 @@ class WebCacheAdapter {
             if (compressionResult.compressed) {
                 finalData = compressionResult.data;
                 isCompressed = true;
-                log$c.debug('Compression result', {
+                log$d.debug('Compression result', {
                     key,
                     originalSize: compressionResult.originalSize,
                     compressedSize: compressionResult.compressedSize,
@@ -4943,7 +4952,7 @@ class WebCacheAdapter {
                 });
             }
         }
-        log$c.debug('Setting cache item', { key, timestamp: item.timestamp, compressed: isCompressed });
+        log$d.debug('Setting cache item', { key, timestamp: item.timestamp, compressed: isCompressed });
         const storedItem = {
             key,
             data: finalData,
@@ -4956,7 +4965,7 @@ class WebCacheAdapter {
             await store.put(storedItem);
         }
         catch (error) {
-            log$c.debug('Error setting cache item', { key, error });
+            log$d.debug('Error setting cache item', { key, error });
             // Silently fail for cache writes
         }
     }
@@ -4964,7 +4973,7 @@ class WebCacheAdapter {
         if (items.length === 0)
             return;
         await this.ensureInitialized();
-        log$c.debug('Batch setting items', { count: items.length });
+        log$d.debug('Batch setting items', { count: items.length });
         try {
             const transaction = this.db.transaction([WebCacheAdapter.STORE_NAME], 'readwrite');
             const store = transaction.objectStore(WebCacheAdapter.STORE_NAME);
@@ -4974,10 +4983,10 @@ class WebCacheAdapter {
                 return store.put(storedItem);
             });
             await Promise.all(promises);
-            log$c.debug('Batch operation completed', { count: items.length });
+            log$d.debug('Batch operation completed', { count: items.length });
         }
         catch (error) {
-            log$c.debug('Error in batch operation', { count: items.length, error });
+            log$d.debug('Error in batch operation', { count: items.length, error });
             // Silently fail for batch writes
         }
     }
@@ -5012,10 +5021,10 @@ class WebCacheAdapter {
             const transaction = this.db.transaction([WebCacheAdapter.STORE_NAME], 'readwrite');
             const store = transaction.objectStore(WebCacheAdapter.STORE_NAME);
             await store.clear();
-            log$c.debug('Cache cleared successfully');
+            log$d.debug('Cache cleared successfully');
         }
         catch (error) {
-            log$c.debug('Error clearing cache', error);
+            log$d.debug('Error clearing cache', error);
             // Silently fail for cache clear
         }
     }
@@ -5041,7 +5050,7 @@ class WebCacheAdapter {
             };
         }
         catch (error) {
-            log$c.debug('Error getting cache size', error);
+            log$d.debug('Error getting cache size', error);
             return {
                 entries: 0,
                 bytes: 0,
@@ -5066,7 +5075,7 @@ class WebCacheAdapter {
             return allKeys.filter((key) => regex.test(key));
         }
         catch (error) {
-            log$c.debug('Error getting cache keys', error);
+            log$d.debug('Error getting cache keys', error);
             return [];
         }
     }
@@ -5079,7 +5088,7 @@ class WebCacheAdapter {
             return true;
         }
         catch (error) {
-            log$c.debug('Error deleting cache item', { key, error });
+            log$d.debug('Error deleting cache item', { key, error });
             return false;
         }
     }
@@ -5091,7 +5100,7 @@ class WebCacheAdapter {
             await this.initPromise;
         }
         catch (error) {
-            log$c.debug('Failed to ensure initialization', error);
+            log$d.debug('Failed to ensure initialization', error);
             // Reset and try once more
             this.initPromise = null;
             this.db = null;
@@ -5110,7 +5119,7 @@ WebCacheAdapter.DB_NAME = 'acube_cache';
 WebCacheAdapter.DB_VERSION = 2;
 WebCacheAdapter.STORE_NAME = 'cache_entries';
 
-const log$b = createPrefixedLogger('CACHE-LOADER');
+const log$c = createPrefixedLogger('CACHE-LOADER');
 function loadCacheAdapter(platform) {
     try {
         switch (platform) {
@@ -5142,7 +5151,7 @@ function loadCacheAdapter(platform) {
         }
     }
     catch (error) {
-        log$b.warn(`Cache adapter not available for platform ${platform}:`, error);
+        log$c.warn(`Cache adapter not available for platform ${platform}:`, error);
         return undefined;
     }
 }
@@ -5199,7 +5208,7 @@ class BaseSecureStorageAdapter {
     }
 }
 
-const log$a = createPrefixedLogger('NETWORK-BASE');
+const log$b = createPrefixedLogger('NETWORK-BASE');
 class NetworkBase {
     constructor(initialOnline = true, debounceMs = 300) {
         this.destroy$ = new Subject();
@@ -5219,14 +5228,14 @@ class NetworkBase {
         const current = this.statusSubject.getValue();
         if (current.online !== online) {
             this.statusSubject.next({ online, timestamp: Date.now() });
-            log$a.debug(`Network status changed: ${online ? 'online' : 'offline'}`);
+            log$b.debug(`Network status changed: ${online ? 'online' : 'offline'}`);
         }
     }
     destroy() {
         this.destroy$.next();
         this.destroy$.complete();
         this.statusSubject.complete();
-        log$a.debug('Network monitor destroyed');
+        log$b.debug('Network monitor destroyed');
     }
 }
 
@@ -5286,7 +5295,7 @@ class NodeSecureStorageAdapter extends BaseSecureStorageAdapter {
     }
 }
 
-const log$9 = createPrefixedLogger('RN-STORAGE');
+const log$a = createPrefixedLogger('RN-STORAGE');
 /**
  * React Native storage adapter using AsyncStorage
  * Note: Uses native batch operations for better performance (not base class)
@@ -5318,7 +5327,7 @@ class ReactNativeStorageAdapter {
             return await this.AsyncStorage.getItem(key);
         }
         catch (error) {
-            log$9.error('Failed to get item from AsyncStorage:', error);
+            log$a.error('Failed to get item from AsyncStorage:', error);
             return null;
         }
     }
@@ -5359,7 +5368,7 @@ class ReactNativeStorageAdapter {
             return await this.AsyncStorage.getAllKeys();
         }
         catch (error) {
-            log$9.error('Failed to get all keys:', error);
+            log$a.error('Failed to get all keys:', error);
             return [];
         }
     }
@@ -5376,7 +5385,7 @@ class ReactNativeStorageAdapter {
             return result;
         }
         catch (error) {
-            log$9.error('Failed to get multiple items:', error);
+            log$a.error('Failed to get multiple items:', error);
             const result = {};
             keys.forEach((key) => {
                 result[key] = null;
@@ -5426,7 +5435,7 @@ class ReactNativeSecureStorageAdapter extends BaseSecureStorageAdapter {
             return;
         }
         catch {
-            log$9.debug('expo-secure-store not available, trying react-native-keychain');
+            log$a.debug('expo-secure-store not available, trying react-native-keychain');
         }
         try {
             const Keychain = require('react-native-keychain');
@@ -5435,7 +5444,7 @@ class ReactNativeSecureStorageAdapter extends BaseSecureStorageAdapter {
             return;
         }
         catch {
-            log$9.error('react-native-keychain not available');
+            log$a.error('react-native-keychain not available');
         }
         throw new Error('No secure storage available. Please install expo-secure-store or react-native-keychain');
     }
@@ -5453,7 +5462,7 @@ class ReactNativeSecureStorageAdapter extends BaseSecureStorageAdapter {
             }
         }
         catch (error) {
-            log$9.error('Failed to get secure item:', error);
+            log$a.error('Failed to get secure item:', error);
         }
         return null;
     }
@@ -5490,10 +5499,10 @@ class ReactNativeSecureStorageAdapter extends BaseSecureStorageAdapter {
         }
     }
     async clear() {
-        log$9.warn('Clear all secure items not fully implemented for React Native');
+        log$a.warn('Clear all secure items not fully implemented for React Native');
     }
     async getAllKeys() {
-        log$9.warn('Get all secure keys not implemented for React Native');
+        log$a.warn('Get all secure keys not implemented for React Native');
         return [];
     }
     async isAvailable() {
@@ -5711,7 +5720,7 @@ class NodeNetworkMonitor extends NetworkBase {
     }
 }
 
-const log$8 = createPrefixedLogger('RN-NETWORK');
+const log$9 = createPrefixedLogger('RN-NETWORK');
 /**
  * React Native network monitor using RxJS
  * Supports both @react-native-community/netinfo and expo-network
@@ -5724,7 +5733,7 @@ class ReactNativeNetworkMonitor extends NetworkBase {
         this.moduleReady$ = new Subject();
         this.isExpo = detectPlatform().isExpo;
         this.init().catch((error) => {
-            log$8.error('Network monitor initialization failed:', error);
+            log$9.error('Network monitor initialization failed:', error);
         });
     }
     async init() {
@@ -5743,10 +5752,10 @@ class ReactNativeNetworkMonitor extends NetworkBase {
         try {
             const module = require('@react-native-community/netinfo');
             this.netInfoModule = module.default || module;
-            log$8.debug('Loaded @react-native-community/netinfo module');
+            log$9.debug('Loaded @react-native-community/netinfo module');
         }
         catch (error) {
-            log$8.error('Failed to load React Native NetInfo module:', error);
+            log$9.error('Failed to load React Native NetInfo module:', error);
             this.netInfoModule = null;
         }
     }
@@ -5754,10 +5763,10 @@ class ReactNativeNetworkMonitor extends NetworkBase {
         try {
             const module = require('expo-network');
             this.netInfoModule = module.default || module;
-            log$8.debug('Loaded expo-network module');
+            log$9.debug('Loaded expo-network module');
         }
         catch (error) {
-            log$8.error('Failed to load Expo Network module:', error);
+            log$9.error('Failed to load Expo Network module:', error);
             this.netInfoModule = null;
         }
     }
@@ -5774,16 +5783,16 @@ class ReactNativeNetworkMonitor extends NetworkBase {
             }
             const online = !!(state.isConnected && state.isInternetReachable !== false);
             this.updateStatus(online);
-            log$8.debug('Initial network state:', online ? 'online' : 'offline');
+            log$9.debug('Initial network state:', online ? 'online' : 'offline');
         }
         catch (error) {
-            log$8.warn('Could not fetch initial network state:', error);
+            log$9.warn('Could not fetch initial network state:', error);
         }
     }
     subscribeToStateChanges() {
         if (!this.netInfoModule)
             return;
-        log$8.debug('Subscribing to network state changes');
+        log$9.debug('Subscribing to network state changes');
         const handleState = (state) => {
             const online = !!(state.isConnected && (state.isInternetReachable ?? true));
             this.updateStatus(online);
@@ -5825,7 +5834,7 @@ class ReactNativeNetworkMonitor extends NetworkBase {
             };
         }
         catch (error) {
-            log$8.error('Failed to fetch detailed network info:', error);
+            log$9.error('Failed to fetch detailed network info:', error);
             return null;
         }
     }
@@ -5961,7 +5970,7 @@ class CertificateValidator {
     }
 }
 
-const log$7 = createPrefixedLogger('RN-MTLS');
+const log$8 = createPrefixedLogger('RN-MTLS');
 /**
  * React Native mTLS Adapter using @a-cube-io/expo-mutual-tls
  */
@@ -5983,7 +5992,7 @@ class ReactNativeMTLSAdapter {
             this.expoMTLS = ExpoMutualTls;
             // Set up debug logging with the correct event signature
             const debugListener = ExpoMutualTls.onDebugLog((event) => {
-                log$7.debug(`${event.type}: ${event.message}`, {
+                log$8.debug(`${event.type}: ${event.message}`, {
                     method: event.method,
                     url: event.url,
                     statusCode: event.statusCode,
@@ -5993,28 +6002,28 @@ class ReactNativeMTLSAdapter {
             this.eventListeners.push(debugListener);
             // Set up error logging with the correct event signature
             const errorListener = ExpoMutualTls.onError((event) => {
-                log$7.error(event.message, {
+                log$8.error(event.message, {
                     code: event.code,
                 });
             });
             this.eventListeners.push(errorListener);
             // Set up certificate expiry monitoring with the correct event signature
             const expiryListener = ExpoMutualTls.onCertificateExpiry((event) => {
-                log$7.warn(`Certificate ${event.subject} expires at ${new Date(event.expiry)}`, {
+                log$8.warn(`Certificate ${event.subject} expires at ${new Date(event.expiry)}`, {
                     alias: event.alias,
                     warning: event.warning,
                 });
             });
             this.eventListeners.push(expiryListener);
-            log$7.debug('Expo mTLS module loaded successfully');
+            log$8.debug('Expo mTLS module loaded successfully');
         }
         catch (error) {
-            log$7.warn('@a-cube-io/expo-mutual-tls not available:', error);
+            log$8.warn('@a-cube-io/expo-mutual-tls not available:', error);
         }
     }
     async isMTLSSupported() {
         const supported = this.expoMTLS !== null;
-        log$7.debug('mTLS support check:', {
+        log$8.debug('mTLS support check:', {
             supported,
             platform: this.getPlatformInfo().platform,
             moduleAvailable: !!this.expoMTLS,
@@ -6026,7 +6035,7 @@ class ReactNativeMTLSAdapter {
             throw new MTLSError(MTLSErrorType$1.NOT_SUPPORTED, 'Expo mTLS module not available');
         }
         this.config = config;
-        log$7.debug('Initialized with config:', {
+        log$8.debug('Initialized with config:', {
             baseUrl: config.baseUrl,
             port: config.port,
             timeout: config.timeout,
@@ -6040,7 +6049,7 @@ class ReactNativeMTLSAdapter {
         if (!this.config) {
             throw new MTLSError(MTLSErrorType$1.CONFIGURATION_ERROR, 'Adapter not initialized. Call initialize() first.');
         }
-        log$7.debug('Configuring certificate:', {
+        log$8.debug('Configuring certificate:', {
             format: certificateData.format,
             hasPassword: !!certificateData.password,
             certificateLength: certificateData.certificate.length,
@@ -6057,14 +6066,14 @@ class ReactNativeMTLSAdapter {
                 'client-key-service', // keyService
                 true // enableLogging - let the native module handle its own debug logging
                 );
-                log$7.debug('PEM services configured:', configResult);
+                log$8.debug('PEM services configured:', configResult);
                 if (!configResult.success) {
                     throw new MTLSError(MTLSErrorType$1.CONFIGURATION_ERROR, `PEM configuration failed: ${configResult.state}`);
                 }
                 // Step 2: Store the actual PEM certificate and private key
                 const storeResult = await this.expoMTLS.storePEM(certificateData.certificate, certificateData.privateKey, certificateData.password // passphrase (optional)
                 );
-                log$7.debug('PEM certificate store result:', storeResult);
+                log$8.debug('PEM certificate store result:', storeResult);
                 if (!storeResult) {
                     throw new MTLSError(MTLSErrorType$1.CERTIFICATE_INVALID, 'Failed to store PEM certificate');
                 }
@@ -6077,14 +6086,14 @@ class ReactNativeMTLSAdapter {
                 const configResult = await this.expoMTLS.configureP12('client-p12-service', // keychainService
                 true // enableLogging - let the native module handle its own debug logging
                 );
-                log$7.debug('P12 service configured:', configResult);
+                log$8.debug('P12 service configured:', configResult);
                 if (!configResult.success) {
                     throw new MTLSError(MTLSErrorType$1.CONFIGURATION_ERROR, `P12 configuration failed: ${configResult.state}`);
                 }
                 // Step 2: Store the P12 certificate data
                 const storeResult = await this.expoMTLS.storeP12(certificateData.certificate, // P12 data in certificate field
                 certificateData.password);
-                log$7.debug('P12 certificate store result:', storeResult);
+                log$8.debug('P12 certificate store result:', storeResult);
                 if (!storeResult) {
                     throw new MTLSError(MTLSErrorType$1.CERTIFICATE_INVALID, 'Failed to store P12 certificate');
                 }
@@ -6098,7 +6107,7 @@ class ReactNativeMTLSAdapter {
             if (error instanceof MTLSError) {
                 throw error;
             }
-            log$7.error('Certificate configuration failed:', error);
+            log$8.error('Certificate configuration failed:', error);
             throw new MTLSError(MTLSErrorType$1.CONFIGURATION_ERROR, 'Failed to configure certificate', error);
         }
     }
@@ -6109,38 +6118,38 @@ class ReactNativeMTLSAdapter {
         try {
             // Use static method call
             const hasCert = await this.expoMTLS.hasCertificate();
-            log$7.debug('Certificate availability check:', hasCert);
+            log$8.debug('Certificate availability check:', hasCert);
             return hasCert;
         }
         catch (error) {
-            log$7.error('Certificate check failed:', error);
+            log$8.error('Certificate check failed:', error);
             return false;
         }
     }
     async getCertificateInfo() {
         if (!this.expoMTLS) {
-            log$7.debug('Certificate info requested but module not available');
+            log$8.debug('Certificate info requested but module not available');
             return null;
         }
         try {
             const hasCert = await this.hasCertificate();
             if (!hasCert) {
-                log$7.debug('No certificate stored');
+                log$8.debug('No certificate stored');
                 return null;
             }
             // Use getCertificatesInfo to retrieve information about stored certificates
             const result = await this.expoMTLS.getCertificatesInfo();
             if (!result || !result.certificates || result.certificates.length === 0) {
-                log$7.debug('No certificate information available');
+                log$8.debug('No certificate information available');
                 return null;
             }
             // Get the first certificate (primary client certificate)
             const cert = result.certificates[0];
             if (!cert) {
-                log$7.debug('Certificate data is empty');
+                log$8.debug('Certificate data is empty');
                 return null;
             }
-            log$7.debug('Retrieved certificate info:', {
+            log$8.debug('Retrieved certificate info:', {
                 subject: cert.subject.commonName,
                 issuer: cert.issuer.commonName,
                 validFrom: new Date(cert.validFrom),
@@ -6159,7 +6168,7 @@ class ReactNativeMTLSAdapter {
             };
         }
         catch (error) {
-            log$7.error('Failed to get certificate info:', error);
+            log$8.error('Failed to get certificate info:', error);
             return null;
         }
     }
@@ -6170,7 +6179,7 @@ class ReactNativeMTLSAdapter {
      */
     async parseCertificateData(certificateData) {
         if (!this.expoMTLS) {
-            log$7.debug('Parse certificate: Module not available');
+            log$8.debug('Parse certificate: Module not available');
             return null;
         }
         try {
@@ -6187,14 +6196,14 @@ class ReactNativeMTLSAdapter {
             else {
                 throw new MTLSError(MTLSErrorType$1.CERTIFICATE_INVALID, `Unsupported certificate format: ${certificateData.format}`);
             }
-            log$7.debug('Certificate parsed successfully:', {
+            log$8.debug('Certificate parsed successfully:', {
                 certificateCount: result.certificates.length,
                 subjects: result.certificates.map((cert) => cert.subject.commonName),
             });
             return result;
         }
         catch (error) {
-            log$7.error('Failed to parse certificate:', error);
+            log$8.error('Failed to parse certificate:', error);
             if (error instanceof MTLSError) {
                 throw error;
             }
@@ -6209,7 +6218,7 @@ class ReactNativeMTLSAdapter {
         if (!hasCert) {
             throw new MTLSError(MTLSErrorType$1.CERTIFICATE_NOT_FOUND, 'No certificate configured');
         }
-        log$7.debug('Making mTLS request:', {
+        log$8.debug('Making mTLS request:', {
             method: requestConfig.method || 'GET',
             url: requestConfig.url,
             headers: requestConfig.headers,
@@ -6217,7 +6226,7 @@ class ReactNativeMTLSAdapter {
             responseType: requestConfig.responseType,
         });
         if (requestConfig.data) {
-            log$7.debug('mTLS request body:', requestConfig.data);
+            log$8.debug('mTLS request body:', requestConfig.data);
         }
         try {
             const response = await this.expoMTLS.request(requestConfig.url, {
@@ -6226,7 +6235,7 @@ class ReactNativeMTLSAdapter {
                 body: requestConfig.data ? JSON.stringify(requestConfig.data) : undefined,
                 responseType: requestConfig.responseType,
             });
-            log$7.debug('mTLS request successful:', response);
+            log$8.debug('mTLS request successful:', response);
             if (!response.success) {
                 throw new MTLSError(MTLSErrorType$1.CONNECTION_FAILED, `mTLS request failed: ${response.statusMessage} (${response.statusCode})`, undefined, response.statusCode);
             }
@@ -6238,7 +6247,7 @@ class ReactNativeMTLSAdapter {
                     data = JSON.parse(response.body);
                 }
                 catch (parseError) {
-                    log$7.warn('Failed to parse JSON response:', parseError);
+                    log$8.warn('Failed to parse JSON response:', parseError);
                     // If parsing fails, keep raw body
                 }
             }
@@ -6255,7 +6264,7 @@ class ReactNativeMTLSAdapter {
             };
         }
         catch (error) {
-            log$7.error('mTLS request failed:', error);
+            log$8.error('mTLS request failed:', error);
             throw new MTLSError(MTLSErrorType$1.CONNECTION_FAILED, 'mTLS request failed', error);
         }
     }
@@ -6268,18 +6277,18 @@ class ReactNativeMTLSAdapter {
      */
     async testConnection() {
         if (!this.expoMTLS || !this.config) {
-            log$7.debug('Diagnostic test: No mTLS module or config available');
+            log$8.debug('Diagnostic test: No mTLS module or config available');
             return false;
         }
         try {
             const hasCert = await this.hasCertificate();
             if (!hasCert) {
-                log$7.debug('Diagnostic test: No certificate configured');
+                log$8.debug('Diagnostic test: No certificate configured');
                 return false;
             }
-            log$7.debug('Running diagnostic test (may fail even if mTLS works):', this.config.baseUrl);
+            log$8.debug('Running diagnostic test (may fail even if mTLS works):', this.config.baseUrl);
             const result = await this.expoMTLS.testConnection(this.config.baseUrl);
-            log$7.debug('Diagnostic test result (NOT validation):', {
+            log$8.debug('Diagnostic test result (NOT validation):', {
                 success: result.success,
                 statusCode: result.statusCode,
                 statusMessage: result.statusMessage,
@@ -6290,13 +6299,13 @@ class ReactNativeMTLSAdapter {
             return result.success;
         }
         catch (error) {
-            log$7.warn('Diagnostic test failed (this is expected):', error);
+            log$8.warn('Diagnostic test failed (this is expected):', error);
             return false;
         }
     }
     async removeCertificate() {
         if (!this.expoMTLS) {
-            log$7.debug('Remove certificate: Module not available');
+            log$8.debug('Remove certificate: Module not available');
             return;
         }
         try {
@@ -6305,10 +6314,10 @@ class ReactNativeMTLSAdapter {
             this.isConfigured = false;
             // Cleanup event listeners
             this.cleanupEventListeners();
-            log$7.debug('Certificate removed successfully');
+            log$8.debug('Certificate removed successfully');
         }
         catch (error) {
-            log$7.error('Failed to remove certificate:', error);
+            log$8.error('Failed to remove certificate:', error);
             throw new MTLSError(MTLSErrorType$1.CONFIGURATION_ERROR, 'Failed to remove certificate', error);
         }
     }
@@ -6317,7 +6326,7 @@ class ReactNativeMTLSAdapter {
      */
     cleanupEventListeners() {
         if (this.eventListeners.length > 0) {
-            log$7.debug(`Cleaning up ${this.eventListeners.length} event listeners`);
+            log$8.debug(`Cleaning up ${this.eventListeners.length} event listeners`);
         }
         // Remove individual listeners if they have remove methods
         this.eventListeners.forEach((listener) => {
@@ -6354,7 +6363,7 @@ class ReactNativeMTLSAdapter {
     }
 }
 
-const log$6 = createPrefixedLogger('WEB-MTLS');
+const log$7 = createPrefixedLogger('WEB-MTLS');
 /**
  * Web mTLS Adapter - Graceful fallback for web browsers
  *
@@ -6368,13 +6377,13 @@ const log$6 = createPrefixedLogger('WEB-MTLS');
  */
 class WebMTLSAdapter {
     constructor() {
-        log$6.warn('Web browsers do not support programmatic mTLS configuration');
-        log$6.info('Use JWT authentication or configure client certificates in browser settings');
+        log$7.warn('Web browsers do not support programmatic mTLS configuration');
+        log$7.info('Use JWT authentication or configure client certificates in browser settings');
     }
     async isMTLSSupported() {
         // mTLS is not supported programmatically in web browsers
         const supported = false;
-        log$6.debug('mTLS support check:', {
+        log$7.debug('mTLS support check:', {
             supported,
             platform: this.getPlatformInfo().platform,
             reason: 'Browser security model prevents programmatic certificate configuration',
@@ -6383,14 +6392,14 @@ class WebMTLSAdapter {
         return supported;
     }
     async initialize(config) {
-        log$6.warn('Initialized but mTLS not available in web browsers:', {
+        log$7.warn('Initialized but mTLS not available in web browsers:', {
             baseUrl: config.baseUrl,
             port: config.port,
             recommendation: 'Use standard HTTPS with JWT authentication',
         });
     }
     async configureCertificate(certificateData) {
-        log$6.error('Certificate configuration attempted:', {
+        log$7.error('Certificate configuration attempted:', {
             format: certificateData.format,
             reason: 'Not supported in web browsers',
             alternatives: [
@@ -6405,15 +6414,15 @@ class WebMTLSAdapter {
     }
     async hasCertificate() {
         // We cannot detect if the browser has certificates configured
-        log$6.debug('Certificate availability check: Cannot detect browser certificates programmatically');
+        log$7.debug('Certificate availability check: Cannot detect browser certificates programmatically');
         return false;
     }
     async getCertificateInfo() {
-        log$6.debug('Certificate info requested: Not accessible in web browsers');
+        log$7.debug('Certificate info requested: Not accessible in web browsers');
         return null;
     }
     async request(requestConfig) {
-        log$6.error('mTLS request attempted:', {
+        log$7.error('mTLS request attempted:', {
             method: requestConfig.method,
             url: requestConfig.url,
             reason: 'Not supported in web browsers',
@@ -6428,11 +6437,11 @@ class WebMTLSAdapter {
             'are properly configured in the browser certificate store.');
     }
     async testConnection() {
-        log$6.debug('Connection test: mTLS not available in web browsers');
+        log$7.debug('Connection test: mTLS not available in web browsers');
         return false;
     }
     async removeCertificate() {
-        log$6.debug('Remove certificate: No certificates to remove (not supported in web browsers)');
+        log$7.debug('Remove certificate: No certificates to remove (not supported in web browsers)');
         // No-op - cannot remove certificates programmatically in browsers
     }
     /**
@@ -6440,7 +6449,7 @@ class WebMTLSAdapter {
      * Always returns null for web browsers as mTLS is not supported
      */
     getBaseUrl() {
-        log$6.debug('Base URL requested: Not supported in web browsers');
+        log$7.debug('Base URL requested: Not supported in web browsers');
         return null;
     }
     getPlatformInfo() {
@@ -6473,7 +6482,7 @@ class WebMTLSAdapter {
     }
 }
 
-const log$5 = createPrefixedLogger('MTLS-LOADER');
+const log$6 = createPrefixedLogger('MTLS-LOADER');
 function loadMTLSAdapter(platform, config) {
     try {
         let adapter;
@@ -6507,7 +6516,7 @@ function loadMTLSAdapter(platform, config) {
         return adapter;
     }
     catch (error) {
-        log$5.warn(`mTLS adapter not available for platform ${platform}:`, error);
+        log$6.warn(`mTLS adapter not available for platform ${platform}:`, error);
         return null;
     }
 }
@@ -6517,7 +6526,7 @@ async function initializeAdapterAsync(adapter, config) {
         if (isSupported) {
             await adapter.initialize(config);
             const platformInfo = adapter.getPlatformInfo();
-            log$5.debug('mTLS adapter initialized:', {
+            log$6.debug('mTLS adapter initialized:', {
                 platform: platformInfo.platform,
                 mtlsSupported: platformInfo.mtlsSupported,
                 certificateStorage: platformInfo.certificateStorage,
@@ -6526,20 +6535,20 @@ async function initializeAdapterAsync(adapter, config) {
         }
     }
     catch (error) {
-        log$5.warn('Failed to initialize mTLS adapter:', error);
+        log$6.warn('Failed to initialize mTLS adapter:', error);
     }
 }
 
-const log$4 = createPrefixedLogger('ADAPTER-LOADER');
+const log$5 = createPrefixedLogger('ADAPTER-LOADER');
 function loadPlatformAdapters(options = {}) {
     const { mtlsConfig } = options;
     const { platform } = detectPlatform();
-    log$4.debug('Loading adapters for platform:', platform);
+    log$5.debug('Loading adapters for platform:', platform);
     const storageAdapters = loadStorageAdapters(platform);
     const networkMonitor = loadNetworkMonitor(platform);
     const cache = loadCacheAdapter(platform);
     const mtls = loadMTLSAdapter(platform, mtlsConfig);
-    log$4.debug('Adapters loaded:', {
+    log$5.debug('Adapters loaded:', {
         platform,
         hasStorage: !!storageAdapters.storage,
         hasSecureStorage: !!storageAdapters.secureStorage,
@@ -7565,7 +7574,7 @@ class TelemetryRepositoryImpl {
     }
 }
 
-const log$3 = createPrefixedLogger('CACHE-KEY');
+const log$4 = createPrefixedLogger('CACHE-KEY');
 const URL_PATTERNS = [
     // Receipt (mf1) - specific patterns first
     {
@@ -7658,7 +7667,7 @@ const DEFAULT_TTL = 5 * 60 * 1000; // 5 minutes
 class CacheKeyGenerator {
     constructor(customConfig) {
         this.config = { ...DEFAULT_TTL_CONFIG, ...customConfig };
-        log$3.info('CacheKeyGenerator initialized with config:', {
+        log$4.info('CacheKeyGenerator initialized with config:', {
             resources: Object.keys(this.config),
         });
     }
@@ -7668,7 +7677,7 @@ class CacheKeyGenerator {
             // Fallback: use URL as key
             const paramStr = params ? this.serializeParams(params) : '';
             const key = paramStr ? `${url}?${paramStr}` : url;
-            log$3.debug('URL not matched, using fallback key:', { url, key });
+            log$4.debug('URL not matched, using fallback key:', { url, key });
             return key;
         }
         const { resource, ids, action, isList, parent } = parsed;
@@ -7676,21 +7685,21 @@ class CacheKeyGenerator {
             const paramStr = params ? this.serializeParams(params) : '';
             const parentPart = parent && ids.length > 0 ? `${parent}=${ids[0]}&` : '';
             const key = `${resource}:list:${parentPart}${paramStr}`;
-            log$3.debug('Generated list cache key:', { url, key, resource });
+            log$4.debug('Generated list cache key:', { url, key, resource });
             return key;
         }
         // Single item
         if (ids.length === 0 && action) {
             // Special case for endpoints like /cashiers/me
             const key = `${resource}:${action}`;
-            log$3.debug('Generated special action cache key:', { url, key, resource, action });
+            log$4.debug('Generated special action cache key:', { url, key, resource, action });
             return key;
         }
         let key = `${resource}:${ids.join(':')}`;
         if (action) {
             key += `:${action}`;
         }
-        log$3.debug('Generated item cache key:', { url, key, resource, ids, action });
+        log$4.debug('Generated item cache key:', { url, key, resource, ids, action });
         return key;
     }
     parseResource(url) {
@@ -7700,23 +7709,23 @@ class CacheKeyGenerator {
     getTTL(url) {
         const resource = this.parseResource(url);
         if (!resource) {
-            log$3.debug('No resource found for URL, using default TTL:', { url, ttl: DEFAULT_TTL });
+            log$4.debug('No resource found for URL, using default TTL:', { url, ttl: DEFAULT_TTL });
             return DEFAULT_TTL;
         }
         const ttl = this.config[resource].ttlMs;
-        log$3.debug('TTL for resource:', { url, resource, ttlMs: ttl, ttlMin: ttl / 60000 });
+        log$4.debug('TTL for resource:', { url, resource, ttlMs: ttl, ttlMin: ttl / 60000 });
         return ttl;
     }
     shouldCache(url) {
         const parsed = this.parseUrl(url);
         if (!parsed) {
-            log$3.debug('URL not recognized, should not cache:', { url });
+            log$4.debug('URL not recognized, should not cache:', { url });
             return false;
         }
         const { resource, isList } = parsed;
         const config = this.config[resource];
         if (isList) {
-            log$3.debug('List endpoint cache decision:', {
+            log$4.debug('List endpoint cache decision:', {
                 url,
                 resource,
                 isList: true,
@@ -7724,7 +7733,7 @@ class CacheKeyGenerator {
             });
             return config.cacheList;
         }
-        log$3.debug('Item endpoint cache decision:', {
+        log$4.debug('Item endpoint cache decision:', {
             url,
             resource,
             isList: false,
@@ -7735,7 +7744,7 @@ class CacheKeyGenerator {
     getInvalidationPatterns(url, method) {
         const parsed = this.parseUrl(url);
         if (!parsed) {
-            log$3.debug('No patterns to invalidate for URL:', { url, method });
+            log$4.debug('No patterns to invalidate for URL:', { url, method });
             return [];
         }
         const { resource, ids, parent } = parsed;
@@ -7757,7 +7766,7 @@ class CacheKeyGenerator {
         if (resource === 'cashier' && (method === 'PUT' || method === 'DELETE')) {
             patterns.push('cashier:me');
         }
-        log$3.debug('Invalidation patterns:', { url, method, patterns });
+        log$4.debug('Invalidation patterns:', { url, method, patterns });
         return patterns;
     }
     parseUrl(url) {
@@ -7792,7 +7801,7 @@ class CacheKeyGenerator {
     }
 }
 
-const log$2 = createPrefixedLogger('CACHE');
+const log$3 = createPrefixedLogger('CACHE');
 class CachingHttpDecorator {
     constructor(http, cache, keyGenerator, networkMonitor, config = {}) {
         this.http = http;
@@ -7802,7 +7811,7 @@ class CachingHttpDecorator {
         this.config = config;
         this.currentOnlineState = true;
         this.authToken = null;
-        log$2.info('CachingHttpDecorator initialized', {
+        log$3.info('CachingHttpDecorator initialized', {
             enabled: config.enabled !== false,
             hasNetworkMonitor: !!networkMonitor,
         });
@@ -7812,7 +7821,7 @@ class CachingHttpDecorator {
         if (this.networkMonitor) {
             this.networkSubscription = this.networkMonitor.online$.subscribe((online) => {
                 if (this.currentOnlineState !== online) {
-                    log$2.info('Network state changed:', { online });
+                    log$3.info('Network state changed:', { online });
                 }
                 this.currentOnlineState = online;
             });
@@ -7831,19 +7840,19 @@ class CachingHttpDecorator {
         const startTime = Date.now();
         // Check if caching is disabled globally
         if (this.config.enabled === false) {
-            log$2.debug('GET (cache disabled globally):', { url });
+            log$3.debug('GET (cache disabled globally):', { url });
             return this.http.get(url, config);
         }
         // Check if this URL should be cached
         const shouldCache = this.keyGenerator.shouldCache(url);
         if (!shouldCache) {
-            log$2.debug('GET (not cacheable - likely a list endpoint):', { url });
+            log$3.debug('GET (not cacheable - likely a list endpoint):', { url });
             return this.http.get(url, config);
         }
         const cacheKey = this.keyGenerator.generate(url, config?.params);
         const ttl = this.keyGenerator.getTTL(url);
         const resource = this.keyGenerator.parseResource(url);
-        log$2.info('GET request starting:', {
+        log$3.info('GET request starting:', {
             url,
             resource,
             cacheKey,
@@ -7856,18 +7865,18 @@ class CachingHttpDecorator {
         try {
             cached = await this.cache.get(cacheKey);
             if (cached) {
-                log$2.debug('Cache entry found:', {
+                log$3.debug('Cache entry found:', {
                     cacheKey,
                     timestamp: new Date(cached.timestamp).toISOString(),
                     ageMs: Date.now() - cached.timestamp,
                 });
             }
             else {
-                log$2.debug('Cache entry not found:', { cacheKey });
+                log$3.debug('Cache entry not found:', { cacheKey });
             }
         }
         catch (error) {
-            log$2.warn('Cache lookup failed:', {
+            log$3.warn('Cache lookup failed:', {
                 cacheKey,
                 error: error instanceof Error ? error.message : error,
             });
@@ -7875,7 +7884,7 @@ class CachingHttpDecorator {
         if (cached) {
             const age = Date.now() - cached.timestamp;
             const isExpired = age >= ttl;
-            log$2.debug('Cache analysis:', {
+            log$3.debug('Cache analysis:', {
                 cacheKey,
                 ageMs: age,
                 ageSec: Math.round(age / 1000),
@@ -7886,7 +7895,7 @@ class CachingHttpDecorator {
             // If within TTL, return cached data
             if (!isExpired) {
                 const duration = Date.now() - startTime;
-                log$2.info('CACHE HIT:', {
+                log$3.info('CACHE HIT:', {
                     url,
                     cacheKey,
                     ageMs: age,
@@ -7901,7 +7910,7 @@ class CachingHttpDecorator {
             // If offline and cache is stale, return stale data
             if (!this.isOnline()) {
                 const duration = Date.now() - startTime;
-                log$2.info('CACHE STALE (offline):', {
+                log$3.info('CACHE STALE (offline):', {
                     url,
                     cacheKey,
                     ageMs: age,
@@ -7913,25 +7922,25 @@ class CachingHttpDecorator {
                     headers: { 'x-cache': 'STALE' },
                 };
             }
-            log$2.debug('Cache expired, fetching fresh data:', { cacheKey, ageMs: age, ttlMs: ttl });
+            log$3.debug('Cache expired, fetching fresh data:', { cacheKey, ageMs: age, ttlMs: ttl });
         }
         // Fetch fresh data
         try {
-            log$2.debug('Fetching from network:', { url });
+            log$3.debug('Fetching from network:', { url });
             const response = await this.http.get(url, config);
             // Cache the response
             try {
                 await this.cache.set(cacheKey, response.data);
-                log$2.debug('Response cached successfully:', { cacheKey });
+                log$3.debug('Response cached successfully:', { cacheKey });
             }
             catch (error) {
-                log$2.error('Failed to cache response:', {
+                log$3.error('Failed to cache response:', {
                     cacheKey,
                     error: error instanceof Error ? error.message : error,
                 });
             }
             const duration = Date.now() - startTime;
-            log$2.info('CACHE MISS (fetched fresh):', {
+            log$3.info('CACHE MISS (fetched fresh):', {
                 url,
                 cacheKey,
                 status: response.status,
@@ -7946,7 +7955,7 @@ class CachingHttpDecorator {
             // On error, return stale cache if available
             if (cached) {
                 const duration = Date.now() - startTime;
-                log$2.warn('CACHE STALE (network error):', {
+                log$3.warn('CACHE STALE (network error):', {
                     url,
                     cacheKey,
                     error: error instanceof Error ? error.message : 'Unknown error',
@@ -7958,7 +7967,7 @@ class CachingHttpDecorator {
                     headers: { 'x-cache': 'STALE' },
                 };
             }
-            log$2.error('Network error with no cache fallback:', {
+            log$3.error('Network error with no cache fallback:', {
                 url,
                 error: error instanceof Error ? error.message : error,
             });
@@ -7966,31 +7975,31 @@ class CachingHttpDecorator {
         }
     }
     async post(url, data, config) {
-        log$2.info('POST request:', { url });
+        log$3.info('POST request:', { url });
         const response = await this.http.post(url, data, config);
         await this.invalidateRelated(url, 'POST');
         return response;
     }
     async put(url, data, config) {
-        log$2.info('PUT request:', { url });
+        log$3.info('PUT request:', { url });
         const response = await this.http.put(url, data, config);
         await this.invalidateRelated(url, 'PUT');
         return response;
     }
     async patch(url, data, config) {
-        log$2.info('PATCH request:', { url });
+        log$3.info('PATCH request:', { url });
         const response = await this.http.patch(url, data, config);
         await this.invalidateRelated(url, 'PATCH');
         return response;
     }
     async delete(url, config) {
-        log$2.info('DELETE request:', { url });
+        log$3.info('DELETE request:', { url });
         const response = await this.http.delete(url, config);
         await this.invalidateRelated(url, 'DELETE');
         return response;
     }
     setAuthToken(token) {
-        log$2.debug('CachingHttpDecorator.setAuthToken called:', {
+        log$3.debug('CachingHttpDecorator.setAuthToken called:', {
             hasToken: !!token,
             tokenPrefix: token?.substring(0, 20),
             underlyingHttpType: this.http.constructor.name,
@@ -8004,17 +8013,17 @@ class CachingHttpDecorator {
     async invalidateRelated(url, method) {
         const patterns = this.keyGenerator.getInvalidationPatterns(url, method);
         if (patterns.length === 0) {
-            log$2.debug('No cache patterns to invalidate:', { url, method });
+            log$3.debug('No cache patterns to invalidate:', { url, method });
             return;
         }
-        log$2.info('Invalidating cache patterns:', { url, method, patterns });
+        log$3.info('Invalidating cache patterns:', { url, method, patterns });
         for (const pattern of patterns) {
             try {
                 await this.cache.invalidate(pattern);
-                log$2.debug('Cache pattern invalidated:', { pattern });
+                log$3.debug('Cache pattern invalidated:', { pattern });
             }
             catch (error) {
-                log$2.error('Failed to invalidate pattern:', {
+                log$3.error('Failed to invalidate pattern:', {
                     pattern,
                     error: error instanceof Error ? error.message : error,
                 });
@@ -8022,7 +8031,7 @@ class CachingHttpDecorator {
         }
     }
     destroy() {
-        log$2.debug('CachingHttpDecorator destroyed');
+        log$3.debug('CachingHttpDecorator destroyed');
         this.networkSubscription?.unsubscribe();
     }
 }
@@ -8398,7 +8407,7 @@ class SDKFactory {
     }
 }
 
-const log$1 = createPrefixedLogger('SDK');
+const log$2 = createPrefixedLogger('SDK');
 class ACubeSDK {
     constructor(config, customAdapters, events = {}) {
         this.events = events;
@@ -8412,22 +8421,22 @@ class ACubeSDK {
     }
     async initialize() {
         if (this.isInitialized) {
-            log$1.debug('SDK already initialized, skipping');
+            log$2.debug('SDK already initialized, skipping');
             return;
         }
-        log$1.info('Initializing SDK', {
+        log$2.info('Initializing SDK', {
             apiUrl: this.config.getApiUrl(),
             authUrl: this.config.getAuthUrl(),
             debugEnabled: this.config.isDebugEnabled(),
         });
         try {
             if (!this.adapters) {
-                log$1.debug('Loading platform adapters');
+                log$2.debug('Loading platform adapters');
                 const mtlsConfig = createACubeMTLSConfig(this.config.getApiUrl(), this.config.getTimeout(), true);
                 this.adapters = loadPlatformAdapters({
                     mtlsConfig,
                 });
-                log$1.info('Platform adapters loaded', {
+                log$2.info('Platform adapters loaded', {
                     hasCache: !!this.adapters.cache,
                     hasNetworkMonitor: !!this.adapters.networkMonitor,
                     hasMtls: !!this.adapters.mtls,
@@ -8440,30 +8449,30 @@ class ACubeSDK {
                 timeout: this.config.getTimeout(),
                 debugEnabled: this.config.isDebugEnabled(),
             };
-            log$1.debug('Creating DI container');
+            log$2.debug('Creating DI container');
             this.container = SDKFactory.createContainer(factoryConfig);
-            log$1.debug('Registering auth services');
+            log$2.debug('Registering auth services');
             SDKFactory.registerAuthServices(this.container, this.adapters.secureStorage, factoryConfig);
             if (this.adapters.cache) {
-                log$1.info('Registering cache services', {
+                log$2.info('Registering cache services', {
                     hasNetworkMonitor: !!this.adapters.networkMonitor,
                 });
                 SDKFactory.registerCacheServices(this.container, this.adapters.cache, this.adapters.networkMonitor);
             }
             else {
-                log$1.debug('No cache adapter available, caching disabled');
+                log$2.debug('No cache adapter available, caching disabled');
             }
-            log$1.debug('Initializing certificate service');
+            log$2.debug('Initializing certificate service');
             this.certificateService = new CertificateService(this.adapters.secureStorage);
             const tokenStorage = this.container.get(DI_TOKENS.TOKEN_STORAGE_PORT);
             const httpPort = this.container.get(DI_TOKENS.HTTP_PORT);
             const baseHttpPort = this.container.get(DI_TOKENS.BASE_HTTP_PORT);
-            log$1.debug('HTTP ports initialized', {
+            log$2.debug('HTTP ports initialized', {
                 httpPortType: httpPort.constructor.name,
                 baseHttpPortType: baseHttpPort.constructor.name,
                 areSameInstance: httpPort === baseHttpPort,
             });
-            log$1.debug('Initializing authentication service');
+            log$2.debug('Initializing authentication service');
             this.authService = new AuthenticationService(httpPort, tokenStorage, {
                 authUrl: this.config.getAuthUrl(),
                 timeout: this.config.getTimeout(),
@@ -8473,7 +8482,7 @@ class ACubeSDK {
                     this.events.onAuthError?.(new ACubeSDKError('AUTH_ERROR', error.message, error));
                 },
             });
-            log$1.debug('Initializing offline manager');
+            log$2.debug('Initializing offline manager');
             const queueEvents = {
                 onOperationAdded: (operation) => {
                     this.events.onOfflineOperationAdded?.(operation.id);
@@ -8496,28 +8505,28 @@ class ACubeSDK {
                 }
             });
             const isAuth = await this.authService.isAuthenticated();
-            log$1.debug('Checking authentication status during init', { isAuthenticated: isAuth });
+            log$2.debug('Checking authentication status during init', { isAuthenticated: isAuth });
             if (isAuth) {
                 const token = await this.authService.getAccessToken();
-                log$1.debug('Token retrieved during init', {
+                log$2.debug('Token retrieved during init', {
                     hasToken: !!token,
                     tokenPrefix: token?.substring(0, 20),
                 });
                 if (token) {
                     httpPort.setAuthToken(token);
-                    log$1.info('Auth token set on HTTP port during initialization');
+                    log$2.info('Auth token set on HTTP port during initialization');
                 }
             }
             else {
-                log$1.warn('User not authenticated during SDK init - token will be set after login');
+                log$2.warn('User not authenticated during SDK init - token will be set after login');
             }
             if (this.adapters?.mtls && 'setMTLSAdapter' in baseHttpPort) {
-                log$1.debug('Connecting mTLS adapter to HTTP port');
+                log$2.debug('Connecting mTLS adapter to HTTP port');
                 const httpWithMtls = baseHttpPort;
                 httpWithMtls.setMTLSAdapter(this.adapters.mtls);
             }
             if ('setAuthStrategy' in baseHttpPort) {
-                log$1.debug('Configuring auth strategy');
+                log$2.debug('Configuring auth strategy');
                 const jwtHandler = new JwtAuthHandler(tokenStorage);
                 const certificatePort = this.certificateService
                     ? {
@@ -8566,19 +8575,19 @@ class ACubeSDK {
                     }
                 }
                 catch (certError) {
-                    log$1.warn('Certificate auto-configuration failed, will retry on demand', {
+                    log$2.warn('Certificate auto-configuration failed, will retry on demand', {
                         error: certError instanceof Error ? certError.message : certError,
                     });
                 }
             }
             this.isInitialized = true;
-            log$1.info('SDK initialized successfully', {
+            log$2.info('SDK initialized successfully', {
                 hasCache: !!this.adapters.cache,
                 hasMtls: !!this.adapters.mtls,
             });
         }
         catch (error) {
-            log$1.error('SDK initialization failed', {
+            log$2.error('SDK initialization failed', {
                 error: error instanceof Error ? error.message : error,
             });
             throw new ACubeSDKError('SDK_INITIALIZATION_ERROR', `Failed to initialize SDK: ${error instanceof Error ? error.message : 'Unknown error'}`, error);
@@ -8634,19 +8643,19 @@ class ACubeSDK {
     }
     async login(credentials) {
         this.ensureInitialized();
-        log$1.info('Login attempt', { email: credentials.email });
+        log$2.info('Login attempt', { email: credentials.email });
         const user = await this.authService.login(credentials);
-        log$1.info('Login successful', { roles: user.roles });
+        log$2.info('Login successful', { roles: user.roles });
         const token = await this.authService.getAccessToken();
         if (token) {
             this.httpPort.setAuthToken(token);
-            log$1.debug('Auth token set on HTTP port');
+            log$2.debug('Auth token set on HTTP port');
         }
         return user;
     }
     async logout() {
         this.ensureInitialized();
-        log$1.info('Logout');
+        log$2.info('Logout');
         await this.authService.logout();
         this.httpPort.setAuthToken(null);
     }
@@ -8820,6 +8829,7 @@ const INITIAL_STATE = {
         remainingMs: 0,
     },
     lastNotification: null,
+    certificateMissing: false,
 };
 class AppStateService {
     get state$() {
@@ -8834,28 +8844,33 @@ class AppStateService {
     get warning$() {
         return this.state$.pipe(map((s) => s.warning), distinctUntilChanged((a, b) => a.active === b.active && a.remainingMs === b.remainingMs));
     }
-    constructor(notifications$, networkPort) {
+    get certificateMissing$() {
+        return this.state$.pipe(map((s) => s.certificateMissing), distinctUntilChanged());
+    }
+    constructor(notifications$, networkPort, certificateMissingInput$ = of(false)) {
         this.notifications$ = notifications$;
         this.networkPort = networkPort;
+        this.certificateMissingInput$ = certificateMissingInput$;
         this.stateSubject = new BehaviorSubject(INITIAL_STATE);
         this.destroy$ = new Subject();
         this.warningTimerId = null;
         this.setupSubscriptions();
     }
     setupSubscriptions() {
-        combineLatest([this.notifications$, this.networkPort.online$])
+        combineLatest([this.notifications$, this.networkPort.online$, this.certificateMissingInput$])
             .pipe(takeUntil(this.destroy$))
-            .subscribe(([notifications, isOnline]) => {
-            this.processState(notifications, isOnline);
+            .subscribe(([notifications, isOnline, certificateMissing]) => {
+            this.processState(notifications, isOnline, certificateMissing);
         });
     }
-    processState(notifications, isOnline) {
+    processState(notifications, isOnline, certificateMissing) {
         if (!isOnline) {
             this.updateState({
                 mode: 'OFFLINE',
                 isOnline: false,
                 warning: { active: false, blockAt: null, remainingMs: 0 },
                 lastNotification: null,
+                certificateMissing,
             });
             this.stopWarningTimer();
             return;
@@ -8917,6 +8932,7 @@ class AppStateService {
             isOnline: true,
             warning: warningState,
             lastNotification,
+            certificateMissing,
         });
     }
     getLatestNotificationByCode(notifications) {
@@ -9182,6 +9198,7 @@ class TelemetryService {
     }
 }
 
+const log$1 = createPrefixedLogger('SDK-MANAGER');
 /**
  * SDKManager - Singleton wrapper for ACubeSDK with simplified API
  *
@@ -9232,6 +9249,7 @@ class SDKManager {
         this.appStateService = null;
         this.isInitialized = false;
         this.isPollingActive = false;
+        this.certificateMissingSubject = new BehaviorSubject(false);
         /**
          * Handle user state changes (login/logout/token expiration)
          * Manages polling lifecycle based on user role
@@ -9242,9 +9260,14 @@ class SDKManager {
             if (!this.isInitialized)
                 return;
             if (user) {
-                // User logged in - check role and start polling if allowed
+                // User logged in - check role and certificate before starting polling
                 const canPoll = hasAnyRole(user.roles, ['ROLE_MERCHANT', 'ROLE_CASHIER']);
                 if (canPoll && !this.isPollingActive) {
+                    const hasCert = await this.checkCertificate();
+                    if (!hasCert) {
+                        log$1.warn('Certificate missing — polling blocked until certificate is installed');
+                        return;
+                    }
                     this.notificationService?.startPolling();
                     await this.startTelemetryPollingAuto();
                     this.isPollingActive = true;
@@ -9258,6 +9281,7 @@ class SDKManager {
                     this.telemetryService?.clearTelemetry();
                     this.isPollingActive = false;
                 }
+                this.certificateMissingSubject.next(false);
             }
         };
     }
@@ -9324,7 +9348,7 @@ class SDKManager {
         this.telemetryService = new TelemetryService(telemetryRepo, networkPort, {
             pollIntervalMs: this.config.telemetryPollIntervalMs ?? 60000,
         });
-        this.appStateService = new AppStateService(this.notificationService.notifications$, networkPort);
+        this.appStateService = new AppStateService(this.notificationService.notifications$, networkPort, this.certificateMissingSubject.asObservable());
         if (this.events?.onAppStateChanged) {
             this.appStateService.state$.subscribe(this.events.onAppStateChanged);
         }
@@ -9336,9 +9360,15 @@ class SDKManager {
         const user = await this.sdk.getCurrentUser();
         const canPoll = user && hasAnyRole(user.roles, ['ROLE_MERCHANT', 'ROLE_CASHIER']);
         if (canPoll) {
-            this.notificationService.startPolling();
-            await this.startTelemetryPollingAuto();
-            this.isPollingActive = true;
+            const hasCert = await this.checkCertificate();
+            if (hasCert) {
+                this.notificationService.startPolling();
+                await this.startTelemetryPollingAuto();
+                this.isPollingActive = true;
+            }
+            else {
+                log$1.warn('Certificate missing at init — polling blocked until certificate is installed');
+            }
         }
         // AppStateService remains active for all users (handles OFFLINE network state)
     }
@@ -9372,6 +9402,13 @@ class SDKManager {
         this.ensureInitialized();
         return this.appStateService.warning$;
     }
+    /**
+     * Observable stream indicating if certificate is missing
+     * When true, polling is blocked and the user should install a certificate
+     */
+    get certificateMissing$() {
+        return this.certificateMissingSubject.asObservable();
+    }
     /**
      * Observable stream of telemetry state (data, isLoading, isCached, error)
      */
@@ -9449,9 +9486,37 @@ class SDKManager {
             logout: () => sdk.logout(),
             getCurrentUser: () => sdk.getCurrentUser(),
             isAuthenticated: () => sdk.isAuthenticated(),
-            storeCertificate: (certificate, privateKey, options) => sdk.storeCertificate(certificate, privateKey, options),
+            storeCertificate: async (certificate, privateKey, options) => {
+                await sdk.storeCertificate(certificate, privateKey, options);
+                this.certificateMissingSubject.next(false);
+                // Start polling if user can poll and polling is not active
+                if (!this.isPollingActive) {
+                    const user = await sdk.getCurrentUser();
+                    const canPoll = user && hasAnyRole(user.roles, ['ROLE_MERCHANT', 'ROLE_CASHIER']);
+                    if (canPoll) {
+                        log$1.info('Certificate installed — starting polling');
+                        this.notificationService?.startPolling();
+                        await this.startTelemetryPollingAuto();
+                        this.isPollingActive = true;
+                    }
+                }
+            },
             hasCertificate: () => sdk.hasCertificate(),
-            clearCertificate: () => sdk.clearCertificate(),
+            clearCertificate: async () => {
+                await sdk.clearCertificate();
+                this.certificateMissingSubject.next(true);
+                // Stop polling since certificate is required
+                if (this.isPollingActive) {
+                    log$1.info('Certificate removed — stopping polling');
+                    this.notificationService?.stopPolling();
+                    this.telemetryService?.stopPolling();
+                    this.telemetryService?.clearTelemetry();
+                    this.isPollingActive = false;
+                }
+            },
+            getCertificate: () => sdk.getCertificate(),
+            getCertificatesInfo: () => sdk.getCertificatesInfo(),
+            notifications: sdk.notifications,
             isOnline: () => sdk.isOnline(),
         };
     }
@@ -9482,6 +9547,21 @@ class SDKManager {
         this.ensureInitialized();
         return this.sdk;
     }
+    /**
+     * Check certificate availability and update certificateMissing state.
+     * Returns true if certificate is available, false otherwise.
+     */
+    async checkCertificate() {
+        try {
+            const hasCert = await this.sdk.hasCertificate();
+            this.certificateMissingSubject.next(!hasCert);
+            return hasCert;
+        }
+        catch {
+            this.certificateMissingSubject.next(true);
+            return false;
+        }
+    }
     cleanup() {
         this.notificationService?.destroy();
         this.telemetryService?.destroy();