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

package/dist/index.native.js

@@ -1,5 +1,5 @@
-import axios from 'axios';
 import * as z from 'zod';
+import axios from 'axios';
 
 /******************************************************************************
 Copyright (c) Microsoft Corporation.
@@ -1838,135 +1838,440 @@ function extractRoles(jwtRoles) {
     return allRoles;
 }
 
-class AuthenticationService {
-    get user$() {
-        return this.userSubject.asObservable();
-    }
-    get isAuthenticated$() {
-        return this.userSubject.pipe(map((user) => user !== null), distinctUntilChanged(), takeUntil(this.destroy$));
-    }
-    get authState$() {
-        return this.authStateSubject.asObservable();
+function clearObject(input) {
+    if (input === null || input === undefined || input === '') {
+        return undefined;
     }
-    constructor(httpPort, tokenStorage, config, events = {}) {
-        this.httpPort = httpPort;
-        this.tokenStorage = tokenStorage;
-        this.config = config;
-        this.events = events;
-        this.userSubject = new BehaviorSubject(null);
-        this.authStateSubject = new BehaviorSubject('idle');
-        this.destroy$ = new Subject();
+    if (Array.isArray(input)) {
+        const cleanedArray = input
+            .map((item) => clearObject(item))
+            .filter((item) => item !== undefined);
+        return cleanedArray;
     }
-    async login(credentials) {
-        this.authStateSubject.next('authenticating');
-        try {
-            const response = await this.httpPort.post(`${this.config.authUrl}/login`, {
-                email: credentials.email,
-                password: credentials.password,
-            });
-            const jwtPayload = parseJwt(response.data.token);
-            const expiresAt = jwtPayload.exp * 1000;
-            await this.tokenStorage.saveAccessToken(response.data.token, expiresAt);
-            const user = this.createUserFromPayload(jwtPayload);
-            await this.tokenStorage.saveUser(user);
-            this.userSubject.next(user);
-            this.authStateSubject.next('authenticated');
-            this.events.onUserChanged?.(user);
-            return user;
-        }
-        catch (error) {
-            this.authStateSubject.next('error');
-            throw error;
+    if (typeof input === 'object' && input.constructor === Object) {
+        const cleaned = {};
+        for (const [key, value] of Object.entries(input)) {
+            const cleanedValue = clearObject(value);
+            if (cleanedValue !== undefined) {
+                cleaned[key] = cleanedValue;
+            }
         }
+        return cleaned;
     }
-    async logout() {
-        await this.tokenStorage.clearTokens();
-        this.userSubject.next(null);
-        this.authStateSubject.next('idle');
-        this.events.onUserChanged?.(null);
+    return input;
+}
+function clearObjectShallow(obj) {
+    if (!obj || typeof obj !== 'object') {
+        return {};
     }
-    async getCurrentUser() {
-        const currentUser = this.userSubject.value;
-        if (currentUser) {
-            return currentUser;
-        }
-        const storedUser = await this.tokenStorage.getUser();
-        if (storedUser) {
-            this.userSubject.next(storedUser);
-            this.authStateSubject.next('authenticated');
-            return storedUser;
-        }
-        const token = await this.tokenStorage.getAccessToken();
-        if (!token) {
-            return null;
-        }
-        const jwtPayload = parseJwt(token);
-        if (isTokenExpired(jwtPayload)) {
-            await this.tokenStorage.clearTokens();
-            return null;
+    const cleaned = {};
+    for (const [key, value] of Object.entries(obj)) {
+        if (value !== null && value !== undefined && value !== '') {
+            cleaned[key] = value;
         }
-        const user = this.createUserFromPayload(jwtPayload);
-        await this.tokenStorage.saveUser(user);
-        this.userSubject.next(user);
-        this.authStateSubject.next('authenticated');
-        return user;
     }
-    async isAuthenticated() {
-        const token = await this.tokenStorage.getAccessToken();
-        if (!token) {
-            return false;
-        }
-        const jwtPayload = parseJwt(token);
-        return !isTokenExpired(jwtPayload);
+    return cleaned;
+}
+function isEmpty(value) {
+    return value === null || value === undefined || value === '';
+}
+function hasNonEmptyValues(obj) {
+    if (!obj || typeof obj !== 'object') {
+        return false;
     }
-    async getAccessToken() {
-        const token = await this.tokenStorage.getAccessToken();
-        if (!token) {
-            return null;
-        }
-        const jwtPayload = parseJwt(token);
-        if (isTokenExpired(jwtPayload)) {
-            await this.tokenStorage.clearTokens();
-            this.userSubject.next(null);
-            this.authStateSubject.next('idle');
-            this.events.onUserChanged?.(null);
-            return null;
-        }
-        return token;
+    return Object.values(obj).some((value) => !isEmpty(value));
+}
+
+/**
+ * Platform detection utilities
+ */
+/**
+ * Detect the current platform
+ */
+function detectPlatform() {
+    // Check for React Native
+    if (typeof global !== 'undefined' &&
+        global.__DEV__ !== undefined &&
+        typeof global.navigator !== 'undefined' &&
+        global.navigator.product === 'ReactNative') {
+        return {
+            platform: 'react-native',
+            isReactNative: true,
+            isWeb: false,
+            isNode: false,
+            isExpo: checkExpo(),
+        };
     }
-    createUserFromPayload(jwtPayload) {
+    // Check for Web/Browser
+    if (typeof window !== 'undefined' &&
+        typeof window.document !== 'undefined' &&
+        typeof window.navigator !== 'undefined') {
         return {
-            id: jwtPayload.uid.toString(),
-            email: jwtPayload.username,
-            username: jwtPayload.username,
-            roles: jwtPayload.roles,
-            fid: jwtPayload.fid,
-            pid: jwtPayload.pid,
-            expiresAt: jwtPayload.exp * 1000,
+            platform: 'web',
+            isReactNative: false,
+            isWeb: true,
+            isNode: false,
+            isExpo: false,
         };
     }
-    destroy() {
-        this.destroy$.next();
-        this.destroy$.complete();
+    // Check for Node.js
+    if (typeof process !== 'undefined' && process.versions && process.versions.node) {
+        return {
+            platform: 'node',
+            isReactNative: false,
+            isWeb: false,
+            isNode: true,
+            isExpo: false,
+        };
     }
+    // Unknown platform
+    return {
+        platform: 'unknown',
+        isReactNative: false,
+        isWeb: false,
+        isNode: false,
+        isExpo: false,
+    };
 }
-
-const CERTIFICATE_KEY = 'acube_certificate';
-class CertificateService {
-    get certificate$() {
-        return this.certificateSubject.asObservable();
+/**
+ * Check if running in Expo
+ */
+function checkExpo() {
+    try {
+        return (typeof global !== 'undefined' &&
+            (typeof global.Expo !== 'undefined' || typeof global.expo !== 'undefined'));
     }
-    get hasCertificate$() {
-        return this.certificateSubject.pipe(map((cert) => cert !== null), distinctUntilChanged());
+    catch {
+        return false;
     }
-    get state$() {
-        return this.stateSubject.asObservable();
+}
+
+function getDefaultExportFromCjs (x) {
+	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
+}
+
+var picocolors_browser = {exports: {}};
+
+var x=String;
+var create=function() {return {isColorSupported:false,reset:x,bold:x,dim:x,italic:x,underline:x,inverse:x,hidden:x,strikethrough:x,black:x,red:x,green:x,yellow:x,blue:x,magenta:x,cyan:x,white:x,gray:x,bgBlack:x,bgRed:x,bgGreen:x,bgYellow:x,bgBlue:x,bgMagenta:x,bgCyan:x,bgWhite:x,blackBright:x,redBright:x,greenBright:x,yellowBright:x,blueBright:x,magentaBright:x,cyanBright:x,whiteBright:x,bgBlackBright:x,bgRedBright:x,bgGreenBright:x,bgYellowBright:x,bgBlueBright:x,bgMagentaBright:x,bgCyanBright:x,bgWhiteBright:x}};
+picocolors_browser.exports=create();
+picocolors_browser.exports.createColors = create;
+
+var picocolors_browserExports = picocolors_browser.exports;
+var pc = /*@__PURE__*/getDefaultExportFromCjs(picocolors_browserExports);
+
+const levelColors = {
+    debug: {
+        prefix: pc.gray,
+        message: pc.gray,
+        data: pc.dim,
+    },
+    info: {
+        prefix: pc.cyan,
+        message: pc.white,
+        data: pc.dim,
+    },
+    warn: {
+        prefix: pc.yellow,
+        message: pc.yellow,
+        data: pc.dim,
+    },
+    error: {
+        prefix: pc.red,
+        message: pc.red,
+        data: pc.dim,
+    },
+};
+const levelIcons = {
+    debug: '🔍',
+    info: 'ℹ️ ',
+    warn: '⚠️ ',
+    error: '❌',
+};
+/**
+ * Format data for pretty display in logs
+ */
+function formatData(data, level) {
+    if (data === undefined || data === null) {
+        return String(data);
     }
-    constructor(secureStorage) {
-        this.secureStorage = secureStorage;
-        this.certificateSubject = new BehaviorSubject(null);
-        this.stateSubject = new BehaviorSubject('idle');
-        this.destroy$ = new Subject();
+    // For primitive types, just return as string
+    if (typeof data !== 'object') {
+        return String(data);
+    }
+    // For Error objects, format nicely
+    if (data instanceof Error) {
+        return `${data.name}: ${data.message}${data.stack ? `\n${pc.dim(data.stack)}` : ''}`;
+    }
+    try {
+        // Apply level-specific coloring
+        const colors = levelColors[level];
+        return colors.data(JSON.stringify(data, null, 2));
+    }
+    catch {
+        // Fallback to JSON.stringify if pretty-format fails
+        try {
+            return JSON.stringify(data, null, 2);
+        }
+        catch {
+            return String(data);
+        }
+    }
+}
+class Logger {
+    constructor() {
+        this.enabled = false;
+    }
+    setEnabled(enabled) {
+        this.enabled = enabled;
+    }
+    isEnabled() {
+        return this.enabled;
+    }
+    debug(prefix, message, data) {
+        if (!this.enabled)
+            return;
+        this.log('debug', prefix, message, data);
+    }
+    info(prefix, message, data) {
+        if (!this.enabled)
+            return;
+        this.log('info', prefix, message, data);
+    }
+    warn(prefix, message, data) {
+        this.log('warn', prefix, message, data);
+    }
+    error(prefix, message, data) {
+        this.log('error', prefix, message, data);
+    }
+    log(level, prefix, message, data) {
+        const colors = levelColors[level];
+        const icon = levelIcons[level];
+        const isoTime = new Date().toISOString().split('T')[1] ?? '';
+        const timestamp = pc.dim(isoTime.slice(0, 12));
+        const formattedPrefix = colors.prefix(`[${prefix}]`);
+        const formattedMessage = colors.message(message);
+        const consoleMethod = level === 'debug'
+            ? console.debug
+            : level === 'info'
+                ? console.info
+                : level === 'warn'
+                    ? console.warn
+                    : console.error;
+        const header = `${timestamp} ${icon} ${formattedPrefix} ${formattedMessage}`;
+        if (data !== undefined) {
+            const formattedData = formatData(data, level);
+            // Check if data is an object (multi-line) or primitive (single-line)
+            const isMultiLine = typeof data === 'object' && data !== null;
+            if (isMultiLine) {
+                consoleMethod(`${header}\n${formattedData}`);
+            }
+            else {
+                consoleMethod(`${header}`, formattedData);
+            }
+        }
+        else {
+            consoleMethod(header);
+        }
+    }
+}
+const logger = new Logger();
+function createPrefixedLogger(prefix) {
+    return {
+        debug: (message, data) => logger.debug(prefix, message, data),
+        info: (message, data) => logger.info(prefix, message, data),
+        warn: (message, data) => logger.warn(prefix, message, data),
+        error: (message, data) => logger.error(prefix, message, data),
+    };
+}
+
+/**
+ * Formats a numeric string value to have exactly the specified number of decimal places.
+ * E.g., "1" → "1.00", "10" → "10.00", "1.5" → "1.50"
+ * Returns undefined for undefined input (preserves optional fields).
+ *
+ * @param value - The string value to format
+ * @param decimals - Number of decimal places (default: 2)
+ * @returns Formatted string or undefined if input is undefined
+ */
+function formatDecimal(value, decimals = 2) {
+    if (value === undefined)
+        return undefined;
+    const num = parseFloat(value);
+    if (isNaN(num))
+        return value;
+    return num.toFixed(decimals);
+}
+
+const log$g = createPrefixedLogger('AUTH-SERVICE');
+class AuthenticationService {
+    get user$() {
+        return this.userSubject.asObservable();
+    }
+    get isAuthenticated$() {
+        return this.userSubject.pipe(map((user) => user !== null), distinctUntilChanged(), takeUntil(this.destroy$));
+    }
+    get authState$() {
+        return this.authStateSubject.asObservable();
+    }
+    constructor(httpPort, tokenStorage, config, events = {}) {
+        this.httpPort = httpPort;
+        this.tokenStorage = tokenStorage;
+        this.config = config;
+        this.events = events;
+        this.userSubject = new BehaviorSubject(null);
+        this.authStateSubject = new BehaviorSubject('idle');
+        this.destroy$ = new Subject();
+    }
+    async login(credentials) {
+        this.authStateSubject.next('authenticating');
+        log$g.info('Login attempt', {
+            authUrl: this.config.authUrl,
+            email: credentials.email,
+        });
+        try {
+            const response = await this.httpPort.post(`${this.config.authUrl}/login`, {
+                email: credentials.email,
+                password: credentials.password,
+            });
+            const jwtPayload = parseJwt(response.data.token);
+            const expiresAt = jwtPayload.exp * 1000;
+            log$g.info('Login successful', {
+                authUrl: this.config.authUrl,
+                tokenPrefix: response.data.token.substring(0, 30) + '...',
+                expiresAt: new Date(expiresAt).toISOString(),
+            });
+            await this.tokenStorage.saveAccessToken(response.data.token, expiresAt);
+            const user = this.createUserFromPayload(jwtPayload);
+            await this.tokenStorage.saveUser(user);
+            this.userSubject.next(user);
+            this.authStateSubject.next('authenticated');
+            this.events.onUserChanged?.(user);
+            return user;
+        }
+        catch (error) {
+            this.authStateSubject.next('error');
+            throw error;
+        }
+    }
+    async logout() {
+        await this.tokenStorage.clearTokens();
+        this.userSubject.next(null);
+        this.authStateSubject.next('idle');
+        this.events.onUserChanged?.(null);
+    }
+    async getCurrentUser() {
+        // Always verify token is valid before returning user
+        const token = await this.tokenStorage.getAccessToken();
+        if (!token) {
+            // No token - clear any stale user state
+            log$g.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', {
+            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');
+            await this.tokenStorage.clearTokens();
+            this.userSubject.next(null);
+            this.authStateSubject.next('idle');
+            this.events.onUserChanged?.(null);
+            return null;
+        }
+        // Token is valid - return cached user if available
+        const currentUser = this.userSubject.value;
+        if (currentUser) {
+            log$g.debug('getCurrentUser: Returning cached user', {
+                email: currentUser.email,
+                roles: currentUser.roles,
+            });
+            return currentUser;
+        }
+        // Check stored user
+        const storedUser = await this.tokenStorage.getUser();
+        if (storedUser) {
+            this.userSubject.next(storedUser);
+            this.authStateSubject.next('authenticated');
+            return storedUser;
+        }
+        // Create user from token
+        const user = this.createUserFromPayload(jwtPayload);
+        await this.tokenStorage.saveUser(user);
+        this.userSubject.next(user);
+        this.authStateSubject.next('authenticated');
+        return user;
+    }
+    async isAuthenticated() {
+        const token = await this.tokenStorage.getAccessToken();
+        if (!token) {
+            log$g.debug('isAuthenticated: No token in storage');
+            return false;
+        }
+        const jwtPayload = parseJwt(token);
+        const expired = isTokenExpired(jwtPayload);
+        log$g.debug('isAuthenticated: Token check', {
+            hasToken: true,
+            expired,
+            expiresAt: new Date(jwtPayload.exp * 1000).toISOString(),
+        });
+        return !expired;
+    }
+    async getAccessToken() {
+        const token = await this.tokenStorage.getAccessToken();
+        if (!token) {
+            return null;
+        }
+        const jwtPayload = parseJwt(token);
+        if (isTokenExpired(jwtPayload)) {
+            await this.tokenStorage.clearTokens();
+            this.userSubject.next(null);
+            this.authStateSubject.next('idle');
+            this.events.onUserChanged?.(null);
+            return null;
+        }
+        return token;
+    }
+    createUserFromPayload(jwtPayload) {
+        return {
+            id: jwtPayload.uid.toString(),
+            email: jwtPayload.username,
+            username: jwtPayload.username,
+            roles: jwtPayload.roles,
+            fid: jwtPayload.fid,
+            pid: jwtPayload.pid,
+            expiresAt: jwtPayload.exp * 1000,
+        };
+    }
+    destroy() {
+        this.destroy$.next();
+        this.destroy$.complete();
+    }
+}
+
+const CERTIFICATE_KEY = 'acube_certificate';
+class CertificateService {
+    get certificate$() {
+        return this.certificateSubject.asObservable();
+    }
+    get hasCertificate$() {
+        return this.certificateSubject.pipe(map((cert) => cert !== null), distinctUntilChanged());
+    }
+    get state$() {
+        return this.stateSubject.asObservable();
+    }
+    constructor(secureStorage) {
+        this.secureStorage = secureStorage;
+        this.certificateSubject = new BehaviorSubject(null);
+        this.stateSubject = new BehaviorSubject('idle');
+        this.destroy$ = new Subject();
     }
     async hasCertificate() {
         const cert = await this.getCertificate();
@@ -2057,409 +2362,680 @@ function hasAnyRole(userRoles, required) {
     return Object.values(userRoles).some((roles) => required.some((role) => roles.includes(role)));
 }
 
-class AuthStrategy {
-    constructor(jwtHandler, mtlsHandler, userProvider, mtlsAdapter) {
-        this.jwtHandler = jwtHandler;
-        this.mtlsHandler = mtlsHandler;
-        this.userProvider = userProvider;
-        this.mtlsAdapter = mtlsAdapter;
+class ConfigManager {
+    constructor(userConfig) {
+        this.config = this.buildConfig(userConfig);
     }
-    async determineAuthConfig(url, method, explicitMode) {
-        if (this.isNotificationEndpoint(url) || this.isTelemetryEndpoint(url)) {
-            return { mode: 'mtls', usePort444: true };
-        }
-        const platform = this.detectPlatform();
-        const userRole = await this.getUserRole();
-        const isReceiptEndpoint = this.isReceiptEndpoint(url);
-        if (userRole === 'SUPPLIER') {
-            return { mode: 'jwt', usePort444: false };
-        }
-        if (userRole === 'CASHIER') {
-            if (!isReceiptEndpoint) {
-                return { mode: 'jwt', usePort444: false };
-            }
-            if (platform === 'mobile') {
-                return { mode: 'mtls', usePort444: true };
-            }
-            return { mode: 'jwt', usePort444: true };
-        }
-        if (userRole === 'MERCHANT') {
-            if (!isReceiptEndpoint) {
-                return { mode: 'jwt', usePort444: false };
-            }
-            if (this.isReturnableItemsEndpoint(url)) {
-                return { mode: 'mtls', usePort444: true };
-            }
-            if (method === 'GET') {
-                if (this.isDetailedReceiptEndpoint(url)) {
-                    if (platform === 'mobile') {
-                        return { mode: 'mtls', usePort444: true };
-                    }
-                    return { mode: 'jwt', usePort444: true };
-                }
-                return { mode: 'jwt', usePort444: false };
-            }
-            if (['POST', 'PUT', 'PATCH', 'DELETE'].includes(method)) {
-                if (platform === 'mobile') {
-                    return { mode: 'mtls', usePort444: true };
-                }
-                return { mode: 'jwt', usePort444: true };
-            }
-            return { mode: 'jwt', usePort444: false };
-        }
-        if (explicitMode) {
-            if (userRole === 'SUPPLIER' && explicitMode === 'mtls') {
-                return { mode: 'jwt', usePort444: false };
-            }
-            return {
-                mode: explicitMode,
-                usePort444: explicitMode === 'mtls' || (platform === 'web' && isReceiptEndpoint),
-            };
-        }
-        if (platform === 'web') {
-            return { mode: 'jwt', usePort444: isReceiptEndpoint };
-        }
-        if (isReceiptEndpoint && platform === 'mobile') {
-            return { mode: 'mtls', usePort444: true };
-        }
-        return { mode: 'jwt', usePort444: false };
-    }
-    async getAuthHeaders() {
-        return this.jwtHandler.getAuthHeaders();
-    }
-    getMtlsHandler() {
-        return this.mtlsHandler;
-    }
-    getJwtHandler() {
-        return this.jwtHandler;
+    buildConfig(userConfig) {
+        return {
+            environment: userConfig.environment,
+            apiUrl: this.getDefaultApiUrl(userConfig.environment),
+            authUrl: this.getDefaultAuthUrl(userConfig.environment),
+            timeout: 30000,
+            retryAttempts: 3,
+            debug: userConfig.debug ?? false,
+            customHeaders: {},
+        };
     }
-    detectPlatform() {
-        if (!this.mtlsAdapter) {
-            return 'web';
+    getDefaultApiUrl(environment) {
+        switch (environment) {
+            case 'production':
+                return 'https://ereceipts-it.acubeapi.com';
+            case 'development':
+                return 'https://ereceipts-it.dev.acubeapi.com';
+            case 'sandbox':
+            default:
+                return 'https://ereceipts-it-sandbox.acubeapi.com';
         }
-        const platformInfo = this.mtlsAdapter.getPlatformInfo();
-        return platformInfo.platform === 'web' ? 'web' : 'mobile';
     }
-    async getUserRole() {
-        if (!this.userProvider) {
-            return null;
-        }
-        const user = await this.userProvider.getCurrentUser();
-        if (!user || !user.roles) {
-            return null;
-        }
-        if (hasRole(user.roles, 'ROLE_SUPPLIER')) {
-            return 'SUPPLIER';
-        }
-        if (hasRole(user.roles, 'ROLE_MERCHANT')) {
-            return 'MERCHANT';
-        }
-        if (hasRole(user.roles, 'ROLE_CASHIER')) {
-            return 'CASHIER';
+    getDefaultAuthUrl(environment) {
+        switch (environment) {
+            case 'production':
+                return 'https://common.api.acubeapi.com';
+            case 'development':
+            case 'sandbox':
+            default:
+                return 'https://common-sandbox.api.acubeapi.com';
         }
-        return null;
     }
-    isReceiptEndpoint(url) {
-        return url.includes('/receipts') || url.includes('/mf1/receipts');
-    }
-    isReturnableItemsEndpoint(url) {
-        return !!(url.match(/\/receipts\/[a-f0-9-]+\/returnable-items$/) ||
-            url.match(/\/mf1\/receipts\/[a-f0-9-]+\/returnable-items$/));
-    }
-    isDetailedReceiptEndpoint(url) {
-        return !!(url.match(/\/receipts\/[a-f0-9-]+\/details$/) ||
-            url.match(/\/mf1\/receipts\/[a-f0-9-]+\/details$/));
+    getConfig() {
+        return {
+            environment: this.config.environment,
+            debug: this.config.debug,
+        };
     }
-    isNotificationEndpoint(url) {
-        return url.includes('/mf1/notifications');
+    getApiUrl() {
+        return this.config.apiUrl;
     }
-    isTelemetryEndpoint(url) {
-        return !!url.match(/\/mf1\/pems\/[^/]+\/telemetry/);
+    getAuthUrl() {
+        return this.config.authUrl;
     }
-}
-
-class JwtAuthHandler {
-    constructor(tokenStorage) {
-        this.tokenStorage = tokenStorage;
+    getEnvironment() {
+        return this.config.environment;
     }
-    async getAuthConfig(_url, _method) {
-        return { mode: 'jwt', usePort444: false };
+    isDebugEnabled() {
+        return this.config.debug;
     }
-    async getAuthHeaders() {
-        const token = await this.tokenStorage.getAccessToken();
-        if (!token) {
-            return {};
-        }
-        return { Authorization: `Bearer ${token}` };
+    getTimeout() {
+        return this.config.timeout;
     }
-}
-
-function clearObject(input) {
-    if (input === null || input === undefined || input === '') {
-        return undefined;
+    getRetryAttempts() {
+        return this.config.retryAttempts;
     }
-    if (Array.isArray(input)) {
-        const cleanedArray = input
-            .map((item) => clearObject(item))
-            .filter((item) => item !== undefined);
-        return cleanedArray;
+    getCustomHeaders() {
+        return { ...this.config.customHeaders };
     }
-    if (typeof input === 'object' && input.constructor === Object) {
-        const cleaned = {};
-        for (const [key, value] of Object.entries(input)) {
-            const cleanedValue = clearObject(value);
-            if (cleanedValue !== undefined) {
-                cleaned[key] = cleanedValue;
-            }
+    updateConfig(updates) {
+        if (updates.environment) {
+            this.config.environment = updates.environment;
+            this.config.apiUrl = this.getDefaultApiUrl(updates.environment);
+            this.config.authUrl = this.getDefaultAuthUrl(updates.environment);
         }
-        return cleaned;
-    }
-    return input;
-}
-function clearObjectShallow(obj) {
-    if (!obj || typeof obj !== 'object') {
-        return {};
-    }
-    const cleaned = {};
-    for (const [key, value] of Object.entries(obj)) {
-        if (value !== null && value !== undefined && value !== '') {
-            cleaned[key] = value;
+        if (updates.debug !== undefined) {
+            this.config.debug = updates.debug;
         }
     }
-    return cleaned;
-}
-function isEmpty(value) {
-    return value === null || value === undefined || value === '';
-}
-function hasNonEmptyValues(obj) {
-    if (!obj || typeof obj !== 'object') {
-        return false;
-    }
-    return Object.values(obj).some((value) => !isEmpty(value));
 }
 
-/**
- * Platform detection utilities
- */
-/**
- * Detect the current platform
- */
-function detectPlatform() {
-    // Check for React Native
-    if (typeof global !== 'undefined' &&
-        global.__DEV__ !== undefined &&
-        typeof global.navigator !== 'undefined' &&
-        global.navigator.product === 'ReactNative') {
-        return {
-            platform: 'react-native',
-            isReactNative: true,
-            isWeb: false,
-            isNode: false,
-            isExpo: checkExpo(),
-        };
-    }
-    // Check for Web/Browser
-    if (typeof window !== 'undefined' &&
-        typeof window.document !== 'undefined' &&
-        typeof window.navigator !== 'undefined') {
-        return {
-            platform: 'web',
-            isReactNative: false,
-            isWeb: true,
-            isNode: false,
-            isExpo: false,
-        };
-    }
-    // Check for Node.js
-    if (typeof process !== 'undefined' && process.versions && process.versions.node) {
-        return {
-            platform: 'node',
-            isReactNative: false,
-            isWeb: false,
-            isNode: true,
-            isExpo: false,
-        };
-    }
-    // Unknown platform
-    return {
-        platform: 'unknown',
-        isReactNative: false,
-        isWeb: false,
-        isNode: false,
-        isExpo: false,
-    };
-}
-/**
- * Check if running in Expo
- */
-function checkExpo() {
-    try {
-        return (typeof global !== 'undefined' &&
-            (typeof global.Expo !== 'undefined' || typeof global.expo !== 'undefined'));
+// Enum options arrays
+const VAT_RATE_CODE_OPTIONS = [
+    '4.00',
+    '5.00',
+    '10.00',
+    '22.00',
+    '2.00',
+    '6.40',
+    '7.00',
+    '7.30',
+    '7.50',
+    '7.65',
+    '7.95',
+    '8.30',
+    '8.50',
+    '8.80',
+    '9.50',
+    '12.30',
+    'N1',
+    'N2',
+    'N3',
+    'N4',
+    'N5',
+    'N6',
+];
+const GOOD_OR_SERVICE_OPTIONS = ['goods', 'service'];
+const RECEIPT_PROOF_TYPE_OPTIONS = ['POS', 'VR', 'ND'];
+// Enum types for receipt validation
+const VatRateCodeSchema = z.enum(VAT_RATE_CODE_OPTIONS);
+const GoodOrServiceSchema = z.enum(GOOD_OR_SERVICE_OPTIONS);
+const ReceiptProofTypeSchema = z.enum(RECEIPT_PROOF_TYPE_OPTIONS);
+// Receipt Item Schema
+const ReceiptItemSchema = z.object({
+    type: GoodOrServiceSchema.optional(),
+    quantity: z.string().min(1, { error: 'fieldIsRequired' }),
+    description: z.string().min(1, { error: 'fieldIsRequired' }),
+    unit_price: z.string().min(1, { error: 'fieldIsRequired' }),
+    vat_rate_code: VatRateCodeSchema.optional(),
+    simplified_vat_allocation: z.boolean().optional(),
+    discount: z.string().nullable().optional(),
+    is_down_payment_or_voucher_redemption: z.boolean().optional(),
+    complimentary: z.boolean().optional(),
+});
+// Main Receipt Input Schema
+const ReceiptInputSchema = z
+    .object({
+    items: z.array(ReceiptItemSchema).min(1, { error: 'arrayMin1' }),
+    customer_tax_code: z.string().optional(),
+    customer_lottery_code: z.string().optional(),
+    discount: z.string().nullable().optional(),
+    invoice_issuing: z.boolean().optional(),
+    uncollected_dcr_to_ssn: z.boolean().optional(),
+    services_uncollected_amount: z.string().nullable().optional(),
+    goods_uncollected_amount: z.string().nullable().optional(),
+    cash_payment_amount: z.string().nullable().optional(),
+    electronic_payment_amount: z.string().nullable().optional(),
+    ticket_restaurant_payment_amount: z.string().nullable().optional(),
+    ticket_restaurant_quantity: z.number().optional(),
+})
+    .refine((data) => {
+    // At least one payment method should be provided
+    const hasCashPayment = data.cash_payment_amount && parseFloat(data.cash_payment_amount) > 0;
+    const hasElectronicPayment = data.electronic_payment_amount && parseFloat(data.electronic_payment_amount) > 0;
+    const hasTicketPayment = data.ticket_restaurant_payment_amount &&
+        parseFloat(data.ticket_restaurant_payment_amount) > 0;
+    return hasCashPayment || hasElectronicPayment || hasTicketPayment;
+}, {
+    error: 'At least one payment method is required',
+    path: ['payment_methods'],
+})
+    .refine((data) => {
+    // only one between customer_tax_code and customer_lottery_code can be provided
+    return !data.customer_tax_code || !data.customer_lottery_code;
+}, {
+    error: 'Only one between customer_tax_code and customer_lottery_code can be provided',
+    path: ['customer_tax_code', 'customer_lottery_code'],
+});
+// Receipt Return or Void via PEM Schema
+const ReceiptReturnOrVoidViaPEMInputSchema = z.object({
+    device_id: z.string().optional(),
+    items: z.array(ReceiptItemSchema).min(1, { error: 'arrayMin1' }),
+    document_number: z.string().min(1, { error: 'fieldIsRequired' }),
+    document_datetime: z.string().optional(),
+    lottery_code: z.string().optional(),
+});
+// Receipt Return or Void with Proof Schema
+const ReceiptReturnOrVoidWithProofInputSchema = z.object({
+    items: z.array(ReceiptItemSchema).min(1, { error: 'arrayMin1' }),
+    proof: ReceiptProofTypeSchema,
+    document_datetime: z.string().min(1, { error: 'fieldIsRequired' }),
+});
+// Void Receipt Schema
+const VoidReceiptInputSchema = z.object({
+    document_number: z.string().min(1, { error: 'fieldIsRequired' }),
+});
+const ReceiptReturnItemSchema = z
+    .array(z.object({
+    id: z.number(),
+    quantity: z.string().min(1, { error: 'fieldIsRequired' }),
+}))
+    .min(1, { error: 'arrayMin1' });
+// Receipt Return Schema
+const ReceiptReturnInputSchema = z.object({
+    items: z.array(ReceiptReturnItemSchema).min(1, { error: 'arrayMin1' }),
+    document_number: z.string().min(1, { error: 'fieldIsRequired' }),
+});
+
+// Cashier Create Input Schema (MF1)
+const CashierCreateInputSchema = z.object({
+    email: z
+        .string()
+        .min(1, { error: 'fieldIsRequired' })
+        .max(255, { error: 'emailMaxLength' })
+        .email({ error: 'invalidEmail' }),
+    password: z
+        .string()
+        .min(8, { error: 'passwordMinLength' })
+        .max(40, { error: 'passwordMaxLength' }),
+    name: z.string().min(1, { error: 'fieldIsRequired' }).max(255, { error: 'nameMaxLength' }),
+    display_name: z
+        .string()
+        .min(1, { error: 'fieldIsRequired' })
+        .max(255, { error: 'displayNameMaxLength' }),
+});
+
+// Enum options arrays
+const PEM_STATUS_OPTIONS = [
+    'NEW',
+    'REGISTERED',
+    'ACTIVATED',
+    'ONLINE',
+    'OFFLINE',
+    'DISCARDED',
+];
+// Address Schema (reusable)
+const AddressSchema = z.object({
+    street_address: z.string().min(1, { error: 'fieldIsRequired' }),
+    street_number: z.string().min(1, { error: 'fieldIsRequired' }),
+    zip_code: z
+        .string()
+        .min(1, { error: 'fieldIsRequired' })
+        .regex(/^\d{5}$/, { error: 'invalidZipCode' }),
+    city: z.string().min(1, { error: 'fieldIsRequired' }),
+    province: z
+        .string()
+        .min(2, { error: 'provinceMinLength' })
+        .max(2, { error: 'provinceMaxLength' })
+        .toUpperCase(),
+});
+// PEM Status Schema
+const PEMStatusSchema = z.enum(PEM_STATUS_OPTIONS);
+// Activation Request Schema
+const ActivationRequestSchema = z.object({
+    registration_key: z.string().min(1, { error: 'fieldIsRequired' }),
+});
+// PEM Status Offline Request Schema
+const PEMStatusOfflineRequestSchema = z.object({
+    timestamp: z
+        .string()
+        .min(1, { error: 'fieldIsRequired' })
+        .refine((val) => !isNaN(Date.parse(val)), {
+        error: 'invalidDateFormat',
+    }),
+    reason: z.string().min(1, { error: 'fieldIsRequired' }),
+});
+
+// Cash Register Create Schema
+const CashRegisterCreateSchema = z.object({
+    pem_serial_number: z.string().min(1, { error: 'fieldIsRequired' }),
+    name: z.string().min(1, { error: 'fieldIsRequired' }).max(100, { error: 'nameMaxLength' }),
+});
+
+// VAT number validation regex (Partita IVA - 11 digits)
+const VAT_NUMBER_REGEX = /^\d{11}$/;
+// Fiscal code validation regex (Codice Fiscale - 11 digits only for merchants)
+const FISCAL_CODE_REGEX = /^\d{11}$/;
+// Password validation regex (from OpenAPI spec)
+const PASSWORD_REGEX = /^((?=.*[A-Z])(?=.*[a-z])(?=.*[0-9])(?=.*[!@#$%^&*])(?=.{10,}).*)$/;
+// Merchant Create Input Schema
+const MerchantCreateInputSchema = z
+    .object({
+    vat_number: z
+        .string()
+        .min(1, { error: 'fieldIsRequired' })
+        .regex(VAT_NUMBER_REGEX, { error: 'invalidVatNumber' }),
+    fiscal_code: z.string().regex(FISCAL_CODE_REGEX, { error: 'invalidFiscalCode' }).optional(),
+    business_name: z.string().max(200, { error: 'businessNameMaxLength' }).optional().nullable(),
+    first_name: z.string().max(100, { error: 'firstNameMaxLength' }).optional().nullable(),
+    last_name: z.string().max(100, { error: 'lastNameMaxLength' }).optional().nullable(),
+    email: z.string().min(1, { error: 'fieldIsRequired' }).email({ error: 'invalidEmail' }),
+    password: z
+        .string()
+        .min(1, { error: 'fieldIsRequired' })
+        .regex(PASSWORD_REGEX, { error: 'passwordComplexity' }),
+    address: AddressSchema.optional(),
+})
+    .refine((data) => {
+    const hasBusinessName = data.business_name && data.business_name.trim() !== '';
+    const hasPersonalNames = (data.first_name && data.first_name.trim() !== '') ||
+        (data.last_name && data.last_name.trim() !== '');
+    // If business name is set, first/last name must not be provided
+    if (hasBusinessName && hasPersonalNames) {
+        return false;
     }
-    catch {
+    // At least one naming method must be provided
+    if (!hasBusinessName && !hasPersonalNames) {
         return false;
     }
-}
+    return true;
+}, {
+    error: 'businessNameOrPersonalNamesRequired',
+    path: ['business_name'],
+});
+// Merchant Update Input Schema
+const MerchantUpdateInputSchema = z.object({
+    business_name: z.string().max(200, { error: 'businessNameMaxLength' }).optional().nullable(),
+    first_name: z.string().max(100, { error: 'firstNameMaxLength' }).optional().nullable(),
+    last_name: z.string().max(100, { error: 'lastNameMaxLength' }).optional().nullable(),
+    address: AddressSchema.optional().nullable(),
+});
+
+// Enum options arrays
+const PEM_TYPE_OPTIONS = ['AP', 'SP', 'TM', 'PV'];
+// PEM Data Schema
+const PemDataSchema = z.object({
+    version: z.string().min(1, { error: 'fieldIsRequired' }),
+    type: z.enum(PEM_TYPE_OPTIONS, {
+        error: 'invalidPemType',
+    }),
+});
+// PEM Create Input Schema
+const PemCreateInputSchema = z.object({
+    merchant_uuid: z.string().min(1, { error: 'fieldIsRequired' }).uuid({ error: 'invalidUuid' }),
+    address: AddressSchema.optional(),
+    /* external_pem_data: PemDataSchema.optional(), */
+});
+
+// Italian Fiscal ID validation regex (Codice Fiscale for individuals or Partita IVA for companies)
+const FISCAL_ID_REGEX = /^([A-Z]{6}[0-9LMNPQRSTUV]{2}[ABCDEHLMPRST][0-9LMNPQRSTUV]{2}[A-Z][0-9LMNPQRSTUV]{3}[A-Z]|[0-9]{11})$/;
+// Supplier Create Input Schema
+const SupplierCreateInputSchema = z.object({
+    fiscal_id: z
+        .string()
+        .min(1, { error: 'fieldIsRequired' })
+        .regex(FISCAL_ID_REGEX, { error: 'invalidFiscalId' })
+        .toUpperCase(),
+    name: z.string().min(1, { error: 'fieldIsRequired' }).max(200, { error: 'nameMaxLength' }),
+    address: AddressSchema.optional(),
+});
+// Supplier Update Input Schema
+const SupplierUpdateInputSchema = z.object({
+    name: z.string().min(1, { error: 'fieldIsRequired' }).max(200, { error: 'nameMaxLength' }),
+    address: AddressSchema.optional(),
+});
+
+// Journal Close Input Schema
+const JournalCloseInputSchema = z.object({
+    closing_timestamp: z
+        .string()
+        .min(1, { error: 'fieldIsRequired' })
+        .refine((val) => !isNaN(Date.parse(val)), {
+        error: 'invalidDateFormat',
+    }),
+    reason: z.string().max(255, { error: 'reasonMaxLength' }).optional(),
+});
+
+// Daily Report Status Options
+const DAILY_REPORT_STATUS_OPTIONS = ['pending', 'sent', 'error'];
+// Daily Report Status Schema
+const DailyReportStatusSchema = z.enum(DAILY_REPORT_STATUS_OPTIONS, {
+    error: 'invalidDailyReportStatus',
+});
+// Daily Reports List Parameters Schema
+const DailyReportsParamsSchema = z.object({
+    pem_serial_number: z.string().min(1, { error: 'fieldIsRequired' }).optional(),
+    date_from: z
+        .string()
+        .refine((val) => !isNaN(Date.parse(val)), {
+        error: 'invalidDateFormat',
+    })
+        .optional(),
+    date_to: z
+        .string()
+        .refine((val) => !isNaN(Date.parse(val)), {
+        error: 'invalidDateFormat',
+    })
+        .optional(),
+    status: DailyReportStatusSchema.optional(),
+    page: z.number().min(1, { error: 'pageMinValue' }).optional(),
+});
+
+const NotificationScopeSchema = z.object({
+    type: z.literal('global'),
+});
+const PemStatusSchema = z.enum(['ONLINE', 'OFFLINE']);
+const NotificationDataBlockAtSchema = z.object({
+    block_at: z.string(),
+});
+const NotificationDataPemStatusSchema = z.object({
+    from: PemStatusSchema,
+    to: PemStatusSchema,
+});
+const NotificationBaseSchema = z.object({
+    uuid: z.string().uuid({ error: 'invalidUuid' }),
+    scope: NotificationScopeSchema,
+    source: z.enum(['system', 'Italian Tax Authority']),
+    level: z.enum(['info', 'warning', 'error', 'critical']),
+    created_at: z.string(),
+});
+const NotificationMf2UnreachableSchema = NotificationBaseSchema.extend({
+    type: z.literal('INTERNAL_COMMUNICATION_FAILURE'),
+    code: z.literal('SYS-W-01'),
+    data: NotificationDataBlockAtSchema,
+});
+const NotificationPemsBlockedSchema = NotificationBaseSchema.extend({
+    type: z.literal('PEM_STATUS_CHANGED'),
+    code: z.literal('SYS-C-01'),
+    data: NotificationDataPemStatusSchema,
+});
+const NotificationPemBackOnlineSchema = NotificationBaseSchema.extend({
+    type: z.literal('PEM_STATUS_CHANGED'),
+    code: z.literal('SYS-I-01'),
+    data: NotificationDataPemStatusSchema,
+});
+const NotificationSchema = z.discriminatedUnion('code', [
+    NotificationMf2UnreachableSchema,
+    NotificationPemsBlockedSchema,
+    NotificationPemBackOnlineSchema,
+]);
+const NotificationListResponseSchema = z.object({
+    members: z.array(NotificationSchema),
+});
+
+const TelemetryMerchantSchema = z.object({
+    vat_number: z.string(),
+    fiscal_code: z.string().nullable(),
+    business_name: z.string(),
+});
+const TelemetrySupplierSchema = z.object({
+    vat_number: z.string(),
+    fiscal_code: z.string().nullable(),
+    business_name: z.string(),
+});
+const TelemetrySoftwareVersionSchema = z.object({
+    version: z.string(),
+    swid: z.string(),
+    installed_at: z.string(),
+    status: z.enum(['active', 'inactive', 'archived']),
+});
+const TelemetrySoftwareSchema = z.object({
+    code: z.string(),
+    name: z.string(),
+    approval_reference: z.string(),
+    version_info: TelemetrySoftwareVersionSchema,
+});
+const PendingReceiptsSchema = z.object({
+    count: z.number().int().nonnegative(),
+    total_amount: z.string(),
+});
+const TransmissionSchema = z.object({
+    attempted_at: z.string(),
+    outcome: z.enum(['success', 'failed', 'pending']),
+});
+const MessageSchema = z.object({
+    received_at: z.string(),
+    content: z.string(),
+});
+const LotterySecretRequestSchema = z.object({
+    requested_at: z.string(),
+    outcome: z.enum(['success', 'failed', 'pending']),
+});
+const LotterySchema = z.object({
+    last_transmission: TransmissionSchema,
+    secret_request: LotterySecretRequestSchema,
+});
+const TelemetrySchema = z.object({
+    pem_id: z.string(),
+    pem_status: z.enum(['ONLINE', 'OFFLINE', 'ERROR']),
+    pem_status_changed_at: z.string(),
+    merchant: TelemetryMerchantSchema,
+    supplier: TelemetrySupplierSchema,
+    software: TelemetrySoftwareSchema,
+    last_communication_at: z.string(),
+    pending_receipts: PendingReceiptsSchema,
+    last_receipt_transmission: TransmissionSchema,
+    last_message_from_mf2: MessageSchema,
+    ade_corrispettivi_transmission: TransmissionSchema,
+    last_message_from_ade: MessageSchema,
+    lottery: LotterySchema,
+});
+
+// Receipt schemas and types
+// Common validation utilities
+const ValidationMessages = {
+    fieldIsRequired: 'This field is required',
+    arrayMin1: 'At least one item is required',
+    paymentMethodRequired: 'At least one payment method is required',
+    invalidEmail: 'Please enter a valid email address',
+    passwordMinLength: 'Password must be at least 8 characters long',
+    passwordComplexity: 'Password must contain at least one uppercase letter, one lowercase letter, one number, and one special character',
+    invalidZipCode: 'Please enter a valid 5-digit zip code',
+    provinceMinLength: 'Province code must be 2 characters',
+    provinceMaxLength: 'Province code must be 2 characters',
+    invalidDateFormat: 'Please enter a valid date',
+    nameMaxLength: 'Name is too long',
+    invalidFiscalId: 'Please enter a valid Italian fiscal ID (Codice Fiscale or Partita IVA)',
+    invalidVatNumber: 'Please enter a valid VAT number (11 digits)',
+    invalidFiscalCode: 'Please enter a valid fiscal code (11 digits)',
+    businessNameMaxLength: 'Business name is too long (max 200 characters)',
+    businessNameOrPersonalNamesRequired: 'Please provide either a business name or first/last name, but not both',
+    firstNameMaxLength: 'First name is too long (max 100 characters)',
+    lastNameMaxLength: 'Last name is too long (max 100 characters)',
+    invalidUuid: 'Please enter a valid UUID',
+    invalidPemType: 'PEM type must be one of: AP, SP, TM, PV',
+    reasonMaxLength: 'Reason is too long (max 255 characters)',
+    pageMinValue: 'Page number must be at least 1',
+    invalidDailyReportStatus: 'Daily report status must be one of: pending, sent, error',
+    displayNameMaxLength: 'Display name is too long (max 255 characters)',
+};
+// Validation helper functions
+const validateInput = (schema, data) => {
+    const result = schema.safeParse(data);
+    if (!result.success) {
+        const errors = result.error.issues.map((error) => ({
+            field: error.path.join('.'),
+            message: error.message,
+            code: error.code,
+        }));
+        return {
+            success: false,
+            errors,
+            data: null,
+        };
+    }
+    return {
+        success: true,
+        errors: [],
+        data: result.data,
+    };
+};
 
-function getDefaultExportFromCjs (x) {
-	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
+class ACubeSDKError extends Error {
+    constructor(type, message, originalError, statusCode, violations) {
+        super(message);
+        this.type = type;
+        this.originalError = originalError;
+        this.statusCode = statusCode;
+        this.name = 'ACubeSDKError';
+        this.violations = violations;
+    }
 }
 
-var picocolors_browser = {exports: {}};
-
-var x=String;
-var create=function() {return {isColorSupported:false,reset:x,bold:x,dim:x,italic:x,underline:x,inverse:x,hidden:x,strikethrough:x,black:x,red:x,green:x,yellow:x,blue:x,magenta:x,cyan:x,white:x,gray:x,bgBlack:x,bgRed:x,bgGreen:x,bgYellow:x,bgBlue:x,bgMagenta:x,bgCyan:x,bgWhite:x,blackBright:x,redBright:x,greenBright:x,yellowBright:x,blueBright:x,magentaBright:x,cyanBright:x,whiteBright:x,bgBlackBright:x,bgRedBright:x,bgGreenBright:x,bgYellowBright:x,bgBlueBright:x,bgMagentaBright:x,bgCyanBright:x,bgWhiteBright:x}};
-picocolors_browser.exports=create();
-picocolors_browser.exports.createColors = create;
-
-var picocolors_browserExports = picocolors_browser.exports;
-var pc = /*@__PURE__*/getDefaultExportFromCjs(picocolors_browserExports);
-
-const levelColors = {
-    debug: {
-        prefix: pc.gray,
-        message: pc.gray,
-        data: pc.dim,
-    },
-    info: {
-        prefix: pc.cyan,
-        message: pc.white,
-        data: pc.dim,
-    },
-    warn: {
-        prefix: pc.yellow,
-        message: pc.yellow,
-        data: pc.dim,
-    },
-    error: {
-        prefix: pc.red,
-        message: pc.red,
-        data: pc.dim,
-    },
-};
-const levelIcons = {
-    debug: '🔍',
-    info: 'ℹ️ ',
-    warn: '⚠️ ',
-    error: '❌',
-};
-/**
- * Format data for pretty display in logs
- */
-function formatData(data, level) {
-    if (data === undefined || data === null) {
-        return String(data);
+const log$f = createPrefixedLogger('AUTH-STRATEGY');
+class AuthStrategy {
+    constructor(jwtHandler, mtlsHandler, userProvider, mtlsAdapter) {
+        this.jwtHandler = jwtHandler;
+        this.mtlsHandler = mtlsHandler;
+        this.userProvider = userProvider;
+        this.mtlsAdapter = mtlsAdapter;
     }
-    // For primitive types, just return as string
-    if (typeof data !== 'object') {
-        return String(data);
+    async determineAuthConfig(url, method, explicitMode) {
+        if (this.isNotificationEndpoint(url) || this.isTelemetryEndpoint(url)) {
+            return { mode: 'mtls', usePort444: true };
+        }
+        const platform = this.detectPlatform();
+        const userRole = await this.getUserRole();
+        const isReceiptEndpoint = this.isReceiptEndpoint(url);
+        log$f.debug('Determining auth config', {
+            url,
+            method,
+            platform,
+            userRole,
+            isReceiptEndpoint,
+            explicitMode,
+        });
+        if (userRole === 'SUPPLIER') {
+            return { mode: 'jwt', usePort444: false };
+        }
+        if (userRole === 'CASHIER') {
+            if (!isReceiptEndpoint) {
+                return { mode: 'jwt', usePort444: false };
+            }
+            if (platform === 'mobile') {
+                return { mode: 'mtls', usePort444: true };
+            }
+            return { mode: 'jwt', usePort444: true };
+        }
+        if (userRole === 'MERCHANT') {
+            if (!isReceiptEndpoint) {
+                return { mode: 'jwt', usePort444: false };
+            }
+            if (this.isReturnableItemsEndpoint(url)) {
+                return { mode: 'mtls', usePort444: true };
+            }
+            if (method === 'GET') {
+                if (this.isDetailedReceiptEndpoint(url)) {
+                    if (platform === 'mobile') {
+                        return { mode: 'mtls', usePort444: true };
+                    }
+                    return { mode: 'jwt', usePort444: true };
+                }
+                return { mode: 'jwt', usePort444: false };
+            }
+            if (['POST', 'PUT', 'PATCH', 'DELETE'].includes(method)) {
+                if (platform === 'mobile') {
+                    return { mode: 'mtls', usePort444: true };
+                }
+                return { mode: 'jwt', usePort444: true };
+            }
+            return { mode: 'jwt', usePort444: false };
+        }
+        if (explicitMode) {
+            if (userRole === 'SUPPLIER' && explicitMode === 'mtls') {
+                return { mode: 'jwt', usePort444: false };
+            }
+            return {
+                mode: explicitMode,
+                usePort444: explicitMode === 'mtls' || (platform === 'web' && isReceiptEndpoint),
+            };
+        }
+        if (platform === 'web') {
+            return { mode: 'jwt', usePort444: isReceiptEndpoint };
+        }
+        if (isReceiptEndpoint && platform === 'mobile') {
+            return { mode: 'mtls', usePort444: true };
+        }
+        return { mode: 'jwt', usePort444: false };
     }
-    // For Error objects, format nicely
-    if (data instanceof Error) {
-        return `${data.name}: ${data.message}${data.stack ? `\n${pc.dim(data.stack)}` : ''}`;
+    async getAuthHeaders() {
+        return this.jwtHandler.getAuthHeaders();
     }
-    try {
-        // Apply level-specific coloring
-        const colors = levelColors[level];
-        return colors.data(JSON.stringify(data, null, 2));
+    getMtlsHandler() {
+        return this.mtlsHandler;
     }
-    catch {
-        // Fallback to JSON.stringify if pretty-format fails
-        try {
-            return JSON.stringify(data, null, 2);
+    getJwtHandler() {
+        return this.jwtHandler;
+    }
+    detectPlatform() {
+        if (!this.mtlsAdapter) {
+            return 'web';
         }
-        catch {
-            return String(data);
+        const platformInfo = this.mtlsAdapter.getPlatformInfo();
+        return platformInfo.platform === 'web' ? 'web' : 'mobile';
+    }
+    async getUserRole() {
+        if (!this.userProvider) {
+            return null;
+        }
+        const user = await this.userProvider.getCurrentUser();
+        if (!user || !user.roles) {
+            return null;
+        }
+        if (hasRole(user.roles, 'ROLE_SUPPLIER')) {
+            return 'SUPPLIER';
+        }
+        if (hasRole(user.roles, 'ROLE_MERCHANT')) {
+            return 'MERCHANT';
         }
+        if (hasRole(user.roles, 'ROLE_CASHIER')) {
+            return 'CASHIER';
+        }
+        return null;
     }
-}
-class Logger {
-    constructor() {
-        this.enabled = false;
+    isReceiptEndpoint(url) {
+        return url.includes('/receipts') || url.includes('/mf1/receipts');
     }
-    setEnabled(enabled) {
-        this.enabled = enabled;
+    isReturnableItemsEndpoint(url) {
+        return !!(url.match(/\/receipts\/[a-f0-9-]+\/returnable-items$/) ||
+            url.match(/\/mf1\/receipts\/[a-f0-9-]+\/returnable-items$/));
     }
-    isEnabled() {
-        return this.enabled;
+    isDetailedReceiptEndpoint(url) {
+        return !!(url.match(/\/receipts\/[a-f0-9-]+\/details$/) ||
+            url.match(/\/mf1\/receipts\/[a-f0-9-]+\/details$/));
     }
-    debug(prefix, message, data) {
-        if (!this.enabled)
-            return;
-        this.log('debug', prefix, message, data);
+    isNotificationEndpoint(url) {
+        return url.includes('/mf1/notifications');
     }
-    info(prefix, message, data) {
-        if (!this.enabled)
-            return;
-        this.log('info', prefix, message, data);
+    isTelemetryEndpoint(url) {
+        return !!url.match(/\/mf1\/pems\/[^/]+\/telemetry/);
     }
-    warn(prefix, message, data) {
-        this.log('warn', prefix, message, data);
+}
+
+class JwtAuthHandler {
+    constructor(tokenStorage) {
+        this.tokenStorage = tokenStorage;
     }
-    error(prefix, message, data) {
-        this.log('error', prefix, message, data);
+    async getAuthConfig(_url, _method) {
+        return { mode: 'jwt', usePort444: false };
     }
-    log(level, prefix, message, data) {
-        const colors = levelColors[level];
-        const icon = levelIcons[level];
-        const isoTime = new Date().toISOString().split('T')[1] ?? '';
-        const timestamp = pc.dim(isoTime.slice(0, 12));
-        const formattedPrefix = colors.prefix(`[${prefix}]`);
-        const formattedMessage = colors.message(message);
-        const consoleMethod = level === 'debug'
-            ? console.debug
-            : level === 'info'
-                ? console.info
-                : level === 'warn'
-                    ? console.warn
-                    : console.error;
-        const header = `${timestamp} ${icon} ${formattedPrefix} ${formattedMessage}`;
-        if (data !== undefined) {
-            const formattedData = formatData(data, level);
-            // Check if data is an object (multi-line) or primitive (single-line)
-            const isMultiLine = typeof data === 'object' && data !== null;
-            if (isMultiLine) {
-                consoleMethod(`${header}\n${formattedData}`);
-            }
-            else {
-                consoleMethod(`${header}`, formattedData);
-            }
-        }
-        else {
-            consoleMethod(header);
+    async getAuthHeaders() {
+        const token = await this.tokenStorage.getAccessToken();
+        if (!token) {
+            return {};
         }
+        return { Authorization: `Bearer ${token}` };
     }
 }
-const logger = new Logger();
-function createPrefixedLogger(prefix) {
-    return {
-        debug: (message, data) => logger.debug(prefix, message, data),
-        info: (message, data) => logger.info(prefix, message, data),
-        warn: (message, data) => logger.warn(prefix, message, data),
-        error: (message, data) => logger.error(prefix, message, data),
-    };
-}
-
-/**
- * Formats a numeric string value to have exactly the specified number of decimal places.
- * E.g., "1" → "1.00", "10" → "10.00", "1.5" → "1.50"
- * Returns undefined for undefined input (preserves optional fields).
- *
- * @param value - The string value to format
- * @param decimals - Number of decimal places (default: 2)
- * @returns Formatted string or undefined if input is undefined
- */
-function formatDecimal(value, decimals = 2) {
-    if (value === undefined)
-        return undefined;
-    const num = parseFloat(value);
-    if (isNaN(num))
-        return value;
-    return num.toFixed(decimals);
-}
 
-const log$f = createPrefixedLogger('MTLS-HANDLER');
+const log$e = createPrefixedLogger('MTLS-HANDLER');
 class MtlsAuthHandler {
     constructor(mtlsAdapter, certificatePort) {
         this.mtlsAdapter = mtlsAdapter;
@@ -2501,7 +3077,7 @@ class MtlsAuthHandler {
     async makeRequest(url, config, jwtToken) {
         const requestKey = this.generateRequestKey(url, config, jwtToken);
         if (this.pendingRequests.has(requestKey)) {
-            log$f.debug('Deduplicating concurrent request:', url);
+            log$e.debug('Deduplicating concurrent request:', url);
             return this.pendingRequests.get(requestKey);
         }
         const requestPromise = this.executeRequest(url, config, jwtToken, false);
@@ -2525,10 +3101,10 @@ class MtlsAuthHandler {
         };
         if (jwtToken) {
             headers['Authorization'] = `Bearer ${jwtToken}`;
-            log$f.debug('JWT token present:', jwtToken.substring(0, 20) + '...');
+            log$e.debug('JWT token present:', jwtToken.substring(0, 20) + '...');
         }
         else {
-            log$f.warn('No JWT token provided for mTLS request');
+            log$e.warn('No JWT token provided for mTLS request');
         }
         const fullUrl = this.constructMtlsUrl(url);
         const mtlsConfig = {
@@ -2539,25 +3115,25 @@ class MtlsAuthHandler {
             timeout: config.timeout,
             responseType: config.responseType,
         };
-        log$f.debug('header-mtls', headers);
-        log$f.debug(`${config.method} ${fullUrl}`);
+        log$e.debug('header-mtls', headers);
+        log$e.debug(`${config.method} ${fullUrl}`);
         if (config.data) {
-            log$f.debug('Request body:', config.data);
+            log$e.debug('Request body:', config.data);
         }
         try {
             const response = await this.mtlsAdapter.request(mtlsConfig);
-            log$f.debug(`Response ${response.status} from ${fullUrl}`);
+            log$e.debug(`Response ${response.status} from ${fullUrl}`);
             if (response.data) {
-                log$f.debug('Response body:', response.data);
+                log$e.debug('Response body:', response.data);
             }
             return response.data;
         }
         catch (error) {
-            log$f.error(`Response error from ${fullUrl}:`, error);
+            log$e.error(`Response error from ${fullUrl}:`, error);
             if (error && typeof error === 'object' && 'response' in error) {
                 const axiosError = error;
                 if (axiosError.response?.data) {
-                    log$f.error('Response body:', axiosError.response.data);
+                    log$e.error('Response body:', axiosError.response.data);
                 }
             }
             if (isRetryAttempt) {
@@ -2567,7 +3143,7 @@ class MtlsAuthHandler {
             if (!shouldRetry) {
                 throw error;
             }
-            log$f.debug('Request failed, reconfiguring certificate and retrying...');
+            log$e.debug('Request failed, reconfiguring certificate and retrying...');
             try {
                 await this.configureCertificate(certificate);
                 return await this.executeRequest(url, config, jwtToken, true);
@@ -3294,7 +3870,7 @@ function decompressData(data, compressed) {
     return new CompressionAdapter().decompress(data, compressed);
 }
 
-const log$e = createPrefixedLogger('CACHE-RN');
+const log$d = createPrefixedLogger('CACHE-RN');
 /**
  * React Native cache adapter using SQLite (Expo or react-native-sqlite-storage)
  * Cache never expires - data persists until explicitly invalidated
@@ -3378,26 +3954,26 @@ class ReactNativeCacheAdapter {
         await this.runMigrations();
     }
     async runMigrations() {
-        log$e.debug('Running database migrations...');
+        log$d.debug('Running database migrations...');
         try {
             // Check if compressed column exists
             this.hasCompressedColumn = await this.checkColumnExists('compressed');
             if (!this.hasCompressedColumn) {
-                log$e.debug('Adding compressed column to cache table');
+                log$d.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$e.debug('Successfully added compressed column');
+                log$d.debug('Successfully added compressed column');
             }
             else {
-                log$e.debug('Compressed column already exists');
+                log$d.debug('Compressed column already exists');
             }
-            log$e.debug('Database migrations completed', {
+            log$d.debug('Database migrations completed', {
                 hasCompressedColumn: this.hasCompressedColumn,
             });
         }
         catch (error) {
-            log$e.debug('Migration failed, disabling compression features', error);
+            log$d.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
@@ -3408,20 +3984,20 @@ class ReactNativeCacheAdapter {
             const pragmaSQL = `PRAGMA table_info(${ReactNativeCacheAdapter.TABLE_NAME})`;
             const results = await this.executeSql(pragmaSQL);
             const columns = this.normalizeResults(results);
-            log$e.debug('Table columns found', { columns: columns.map((c) => c.name) });
+            log$d.debug('Table columns found', { columns: columns.map((c) => c.name) });
             return columns.some((column) => column.name === columnName);
         }
         catch (error) {
-            log$e.debug('Error checking column existence', error);
+            log$d.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$e.debug('Executing get query', { sql, key });
+        log$d.debug('Executing get query', { sql, key });
         const results = await this.executeSql(sql, [key]);
-        log$e.debug('Get query results', { key, hasResults: !!results });
+        log$d.debug('Get query results', { key, hasResults: !!results });
         // Normalize results from different SQLite implementations
         const rows = this.normalizeResults(results);
         if (!rows || rows.length === 0) {
@@ -3444,7 +4020,7 @@ class ReactNativeCacheAdapter {
             data,
             timestamp: Date.now(),
         };
-        log$e.debug('Setting cache item', { key });
+        log$d.debug('Setting cache item', { key });
         return this.setItem(key, item);
     }
     async setItem(key, item) {
@@ -3457,7 +4033,7 @@ class ReactNativeCacheAdapter {
             const compressionResult = compressData(serializedData, this.options.compressionThreshold);
             finalData = compressionResult.data;
             isCompressed = compressionResult.compressed;
-            log$e.debug('Compression result', {
+            log$d.debug('Compression result', {
                 key,
                 originalSize: compressionResult.originalSize,
                 compressedSize: compressionResult.compressedSize,
@@ -3465,7 +4041,7 @@ class ReactNativeCacheAdapter {
                 savings: compressionResult.originalSize - compressionResult.compressedSize,
             });
         }
-        log$e.debug('Setting item with metadata', {
+        log$d.debug('Setting item with metadata', {
             key,
             timestamp: item.timestamp,
             compressed: isCompressed,
@@ -3491,14 +4067,14 @@ class ReactNativeCacheAdapter {
       `;
             params = [key, finalData, item.timestamp];
         }
-        log$e.debug('Executing setItem SQL', { key, paramsCount: params.length });
+        log$d.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$e.debug('Batch setting items', { count: items.length });
+        log$d.debug('Batch setting items', { count: items.length });
         if (this.isExpo) {
             await this.db.withTransactionAsync(async () => {
                 for (const [key, item] of items) {
@@ -3516,7 +4092,7 @@ class ReactNativeCacheAdapter {
                 }, reject, () => resolve());
             });
         }
-        log$e.debug('Batch operation completed', { count: items.length });
+        log$d.debug('Batch operation completed', { count: items.length });
     }
     async setBatchItem(key, item) {
         // Handle compression if enabled and compressed column is available
@@ -3690,10 +4266,10 @@ class MemoryCacheAdapter {
         return keySize + itemSize;
     }
     async get(key) {
-        log$e.debug('Getting cache item', { key });
+        log$d.debug('Getting cache item', { key });
         const item = this.cache.get(key);
         if (!item) {
-            log$e.debug('Cache miss', { key });
+            log$d.debug('Cache miss', { key });
             return null;
         }
         // Handle decompression if needed
@@ -3703,7 +4279,7 @@ class MemoryCacheAdapter {
             const decompressed = decompressData(item.data, true);
             finalData = JSON.parse(decompressed.data);
         }
-        log$e.debug('Cache hit', { key, compressed: isCompressed });
+        log$d.debug('Cache hit', { key, compressed: isCompressed });
         return {
             ...item,
             data: finalData,
@@ -3711,7 +4287,7 @@ class MemoryCacheAdapter {
         };
     }
     async set(key, data) {
-        log$e.debug('Setting cache item', { key });
+        log$d.debug('Setting cache item', { key });
         // Handle compression if enabled
         let finalData = data;
         let isCompressed = false;
@@ -3721,7 +4297,7 @@ class MemoryCacheAdapter {
             if (compressionResult.compressed) {
                 finalData = compressionResult.data;
                 isCompressed = true;
-                log$e.debug('Compression result', {
+                log$d.debug('Compression result', {
                     key,
                     originalSize: compressionResult.originalSize,
                     compressedSize: compressionResult.compressedSize,
@@ -3753,13 +4329,13 @@ class MemoryCacheAdapter {
                 const oldestItemSize = this.calculateItemSize(oldestKey, oldestItem);
                 this.totalBytes -= oldestItemSize;
                 this.cache.delete(oldestKey);
-                log$e.debug('Removed oldest item for capacity', { oldestKey, freedBytes: oldestItemSize });
+                log$d.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$e.debug('Updated cache size', {
+        log$d.debug('Updated cache size', {
             entries: this.cache.size,
             totalBytes: this.totalBytes,
             newItemSize,
@@ -3768,7 +4344,7 @@ class MemoryCacheAdapter {
     async setBatch(items) {
         if (items.length === 0)
             return;
-        log$e.debug('Batch setting items', { count: items.length });
+        log$d.debug('Batch setting items', { count: items.length });
         let totalNewBytes = 0;
         let totalOldBytes = 0;
         const itemsToRemove = [];
@@ -3797,7 +4373,7 @@ class MemoryCacheAdapter {
                 itemsToRemove.push(oldKey);
             }
             if (itemsToRemove.length > 0) {
-                log$e.debug('Removed items for batch capacity', {
+                log$d.debug('Removed items for batch capacity', {
                     removedCount: itemsToRemove.length,
                     removedKeys: itemsToRemove,
                 });
@@ -3809,7 +4385,7 @@ class MemoryCacheAdapter {
         for (const [key, item] of items) {
             this.cache.set(key, item);
         }
-        log$e.debug('Batch operation completed', {
+        log$d.debug('Batch operation completed', {
             count: items.length,
             totalBytes: this.totalBytes,
             entries: this.cache.size,
@@ -3831,7 +4407,7 @@ class MemoryCacheAdapter {
             }
         }
         if (removed > 0) {
-            log$e.debug('Invalidation completed', {
+            log$d.debug('Invalidation completed', {
                 pattern,
                 entriesRemoved: removed,
                 bytesFreed,
@@ -3843,7 +4419,7 @@ class MemoryCacheAdapter {
     async clear() {
         this.cache.clear();
         this.totalBytes = 0;
-        log$e.debug('Cache cleared', { entries: 0, bytes: 0 });
+        log$d.debug('Cache cleared', { entries: 0, bytes: 0 });
     }
     async getSize() {
         return {
@@ -4174,7 +4750,7 @@ replaceTraps((oldTraps) => ({
     },
 }));
 
-const log$d = createPrefixedLogger('CACHE-WEB');
+const log$c = createPrefixedLogger('CACHE-WEB');
 /**
  * Web cache adapter using IndexedDB with automatic error recovery
  * Cache never expires - data persists until explicitly invalidated
@@ -4197,18 +4773,18 @@ class WebCacheAdapter {
     async initialize() {
         if (this.db)
             return;
-        log$d.debug('Initializing IndexedDB cache', {
+        log$c.debug('Initializing IndexedDB cache', {
             dbName: WebCacheAdapter.DB_NAME,
             version: WebCacheAdapter.DB_VERSION,
         });
         try {
             this.db = await this.openDatabase();
-            log$d.debug('IndexedDB cache initialized successfully');
+            log$c.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$d.debug('Failed to initialize IndexedDB', { error: errorMessage });
+            log$c.debug('Failed to initialize IndexedDB', { error: errorMessage });
             // Check if this is a version conflict error
             if (this.isVersionConflictError(errorMessage)) {
                 await this.handleVersionConflict();
@@ -4221,32 +4797,32 @@ class WebCacheAdapter {
     async openDatabase() {
         return await openDB(WebCacheAdapter.DB_NAME, WebCacheAdapter.DB_VERSION, {
             upgrade: (db, oldVersion, newVersion, transaction) => {
-                log$d.debug('Database upgrade needed', { oldVersion, newVersion });
+                log$c.debug('Database upgrade needed', { oldVersion, newVersion });
                 this.handleUpgrade(db, oldVersion, newVersion, transaction);
             },
             blocked: () => {
-                log$d.debug('Database blocked - another tab may be open');
+                log$c.debug('Database blocked - another tab may be open');
             },
             blocking: () => {
-                log$d.debug('Database blocking - will close connection');
+                log$c.debug('Database blocking - will close connection');
                 if (this.db) {
                     this.db.close();
                     this.db = null;
                 }
             },
             terminated: () => {
-                log$d.debug('Database connection terminated unexpectedly');
+                log$c.debug('Database connection terminated unexpectedly');
                 this.db = null;
             },
         });
     }
     handleUpgrade(db, oldVersion, newVersion, transaction) {
-        log$d.debug('Handling database upgrade', { oldVersion, newVersion });
+        log$c.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$d.debug('Created cache store and timestamp index');
+            log$c.debug('Created cache store and timestamp index');
         }
         // Handle migration from version 1 to 2
         if (oldVersion < 2) {
@@ -4257,16 +4833,16 @@ class WebCacheAdapter {
                 try {
                     if (store.indexNames.contains(indexName)) {
                         store.deleteIndex(indexName);
-                        log$d.debug(`Removed unused index: ${indexName}`);
+                        log$c.debug(`Removed unused index: ${indexName}`);
                     }
                 }
                 catch (error) {
                     // Ignore errors if indexes don't exist
-                    log$d.debug(`Warning: Could not remove index ${indexName}`, error);
+                    log$c.debug(`Warning: Could not remove index ${indexName}`, error);
                 }
             });
         }
-        log$d.debug('Database upgrade completed');
+        log$c.debug('Database upgrade completed');
     }
     isVersionConflictError(errorMessage) {
         return (errorMessage.includes('less than the existing version') ||
@@ -4274,7 +4850,7 @@ class WebCacheAdapter {
             errorMessage.includes('VersionError'));
     }
     async handleVersionConflict() {
-        log$d.debug('Handling version conflict, attempting recovery...');
+        log$c.debug('Handling version conflict, attempting recovery...');
         if (this.retryCount >= this.maxRetries) {
             throw new Error('Failed to resolve IndexedDB version conflict after multiple attempts');
         }
@@ -4286,19 +4862,19 @@ class WebCacheAdapter {
                 this.db = null;
             }
             // Delete the problematic database
-            log$d.debug('Deleting problematic database to resolve version conflict');
+            log$c.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$d.debug(`Retrying database initialization (attempt ${this.retryCount}/${this.maxRetries})`);
+            log$c.debug(`Retrying database initialization (attempt ${this.retryCount}/${this.maxRetries})`);
             this.db = await this.openDatabase();
-            log$d.debug('Successfully recovered from version conflict');
+            log$c.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$d.debug('Recovery attempt failed', { attempt: this.retryCount, error: retryErrorMessage });
+            log$c.debug('Recovery attempt failed', { attempt: this.retryCount, error: retryErrorMessage });
             if (this.retryCount < this.maxRetries) {
                 // Try again
                 await this.handleVersionConflict();
@@ -4310,7 +4886,7 @@ class WebCacheAdapter {
     }
     async get(key) {
         await this.ensureInitialized();
-        log$d.debug('Getting cache item', { key });
+        log$c.debug('Getting cache item', { key });
         try {
             const transaction = this.db.transaction([WebCacheAdapter.STORE_NAME], 'readonly');
             const store = transaction.objectStore(WebCacheAdapter.STORE_NAME);
@@ -4336,7 +4912,7 @@ class WebCacheAdapter {
             };
         }
         catch (error) {
-            log$d.debug('Error getting cache item', { key, error });
+            log$c.debug('Error getting cache item', { key, error });
             return null; // Return null on error instead of throwing
         }
     }
@@ -4358,7 +4934,7 @@ class WebCacheAdapter {
             if (compressionResult.compressed) {
                 finalData = compressionResult.data;
                 isCompressed = true;
-                log$d.debug('Compression result', {
+                log$c.debug('Compression result', {
                     key,
                     originalSize: compressionResult.originalSize,
                     compressedSize: compressionResult.compressedSize,
@@ -4367,7 +4943,7 @@ class WebCacheAdapter {
                 });
             }
         }
-        log$d.debug('Setting cache item', { key, timestamp: item.timestamp, compressed: isCompressed });
+        log$c.debug('Setting cache item', { key, timestamp: item.timestamp, compressed: isCompressed });
         const storedItem = {
             key,
             data: finalData,
@@ -4380,7 +4956,7 @@ class WebCacheAdapter {
             await store.put(storedItem);
         }
         catch (error) {
-            log$d.debug('Error setting cache item', { key, error });
+            log$c.debug('Error setting cache item', { key, error });
             // Silently fail for cache writes
         }
     }
@@ -4388,7 +4964,7 @@ class WebCacheAdapter {
         if (items.length === 0)
             return;
         await this.ensureInitialized();
-        log$d.debug('Batch setting items', { count: items.length });
+        log$c.debug('Batch setting items', { count: items.length });
         try {
             const transaction = this.db.transaction([WebCacheAdapter.STORE_NAME], 'readwrite');
             const store = transaction.objectStore(WebCacheAdapter.STORE_NAME);
@@ -4398,10 +4974,10 @@ class WebCacheAdapter {
                 return store.put(storedItem);
             });
             await Promise.all(promises);
-            log$d.debug('Batch operation completed', { count: items.length });
+            log$c.debug('Batch operation completed', { count: items.length });
         }
         catch (error) {
-            log$d.debug('Error in batch operation', { count: items.length, error });
+            log$c.debug('Error in batch operation', { count: items.length, error });
             // Silently fail for batch writes
         }
     }
@@ -4436,10 +5012,10 @@ class WebCacheAdapter {
             const transaction = this.db.transaction([WebCacheAdapter.STORE_NAME], 'readwrite');
             const store = transaction.objectStore(WebCacheAdapter.STORE_NAME);
             await store.clear();
-            log$d.debug('Cache cleared successfully');
+            log$c.debug('Cache cleared successfully');
         }
         catch (error) {
-            log$d.debug('Error clearing cache', error);
+            log$c.debug('Error clearing cache', error);
             // Silently fail for cache clear
         }
     }
@@ -4465,7 +5041,7 @@ class WebCacheAdapter {
             };
         }
         catch (error) {
-            log$d.debug('Error getting cache size', error);
+            log$c.debug('Error getting cache size', error);
             return {
                 entries: 0,
                 bytes: 0,
@@ -4490,7 +5066,7 @@ class WebCacheAdapter {
             return allKeys.filter((key) => regex.test(key));
         }
         catch (error) {
-            log$d.debug('Error getting cache keys', error);
+            log$c.debug('Error getting cache keys', error);
             return [];
         }
     }
@@ -4503,7 +5079,7 @@ class WebCacheAdapter {
             return true;
         }
         catch (error) {
-            log$d.debug('Error deleting cache item', { key, error });
+            log$c.debug('Error deleting cache item', { key, error });
             return false;
         }
     }
@@ -4515,7 +5091,7 @@ class WebCacheAdapter {
             await this.initPromise;
         }
         catch (error) {
-            log$d.debug('Failed to ensure initialization', error);
+            log$c.debug('Failed to ensure initialization', error);
             // Reset and try once more
             this.initPromise = null;
             this.db = null;
@@ -4534,7 +5110,7 @@ WebCacheAdapter.DB_NAME = 'acube_cache';
 WebCacheAdapter.DB_VERSION = 2;
 WebCacheAdapter.STORE_NAME = 'cache_entries';
 
-const log$c = createPrefixedLogger('CACHE-LOADER');
+const log$b = createPrefixedLogger('CACHE-LOADER');
 function loadCacheAdapter(platform) {
     try {
         switch (platform) {
@@ -4566,7 +5142,7 @@ function loadCacheAdapter(platform) {
         }
     }
     catch (error) {
-        log$c.warn(`Cache adapter not available for platform ${platform}:`, error);
+        log$b.warn(`Cache adapter not available for platform ${platform}:`, error);
         return undefined;
     }
 }
@@ -4623,7 +5199,7 @@ class BaseSecureStorageAdapter {
     }
 }
 
-const log$b = createPrefixedLogger('NETWORK-BASE');
+const log$a = createPrefixedLogger('NETWORK-BASE');
 class NetworkBase {
     constructor(initialOnline = true, debounceMs = 300) {
         this.destroy$ = new Subject();
@@ -4643,14 +5219,14 @@ class NetworkBase {
         const current = this.statusSubject.getValue();
         if (current.online !== online) {
             this.statusSubject.next({ online, timestamp: Date.now() });
-            log$b.debug(`Network status changed: ${online ? 'online' : 'offline'}`);
+            log$a.debug(`Network status changed: ${online ? 'online' : 'offline'}`);
         }
     }
     destroy() {
         this.destroy$.next();
         this.destroy$.complete();
         this.statusSubject.complete();
-        log$b.debug('Network monitor destroyed');
+        log$a.debug('Network monitor destroyed');
     }
 }
 
@@ -4710,7 +5286,7 @@ class NodeSecureStorageAdapter extends BaseSecureStorageAdapter {
     }
 }
 
-const log$a = createPrefixedLogger('RN-STORAGE');
+const log$9 = createPrefixedLogger('RN-STORAGE');
 /**
  * React Native storage adapter using AsyncStorage
  * Note: Uses native batch operations for better performance (not base class)
@@ -4742,7 +5318,7 @@ class ReactNativeStorageAdapter {
             return await this.AsyncStorage.getItem(key);
         }
         catch (error) {
-            log$a.error('Failed to get item from AsyncStorage:', error);
+            log$9.error('Failed to get item from AsyncStorage:', error);
             return null;
         }
     }
@@ -4783,7 +5359,7 @@ class ReactNativeStorageAdapter {
             return await this.AsyncStorage.getAllKeys();
         }
         catch (error) {
-            log$a.error('Failed to get all keys:', error);
+            log$9.error('Failed to get all keys:', error);
             return [];
         }
     }
@@ -4800,7 +5376,7 @@ class ReactNativeStorageAdapter {
             return result;
         }
         catch (error) {
-            log$a.error('Failed to get multiple items:', error);
+            log$9.error('Failed to get multiple items:', error);
             const result = {};
             keys.forEach((key) => {
                 result[key] = null;
@@ -4850,7 +5426,7 @@ class ReactNativeSecureStorageAdapter extends BaseSecureStorageAdapter {
             return;
         }
         catch {
-            log$a.debug('expo-secure-store not available, trying react-native-keychain');
+            log$9.debug('expo-secure-store not available, trying react-native-keychain');
         }
         try {
             const Keychain = require('react-native-keychain');
@@ -4859,7 +5435,7 @@ class ReactNativeSecureStorageAdapter extends BaseSecureStorageAdapter {
             return;
         }
         catch {
-            log$a.error('react-native-keychain not available');
+            log$9.error('react-native-keychain not available');
         }
         throw new Error('No secure storage available. Please install expo-secure-store or react-native-keychain');
     }
@@ -4877,7 +5453,7 @@ class ReactNativeSecureStorageAdapter extends BaseSecureStorageAdapter {
             }
         }
         catch (error) {
-            log$a.error('Failed to get secure item:', error);
+            log$9.error('Failed to get secure item:', error);
         }
         return null;
     }
@@ -4914,10 +5490,10 @@ class ReactNativeSecureStorageAdapter extends BaseSecureStorageAdapter {
         }
     }
     async clear() {
-        log$a.warn('Clear all secure items not fully implemented for React Native');
+        log$9.warn('Clear all secure items not fully implemented for React Native');
     }
     async getAllKeys() {
-        log$a.warn('Get all secure keys not implemented for React Native');
+        log$9.warn('Get all secure keys not implemented for React Native');
         return [];
     }
     async isAvailable() {
@@ -5135,7 +5711,7 @@ class NodeNetworkMonitor extends NetworkBase {
     }
 }
 
-const log$9 = createPrefixedLogger('RN-NETWORK');
+const log$8 = createPrefixedLogger('RN-NETWORK');
 /**
  * React Native network monitor using RxJS
  * Supports both @react-native-community/netinfo and expo-network
@@ -5148,7 +5724,7 @@ class ReactNativeNetworkMonitor extends NetworkBase {
         this.moduleReady$ = new Subject();
         this.isExpo = detectPlatform().isExpo;
         this.init().catch((error) => {
-            log$9.error('Network monitor initialization failed:', error);
+            log$8.error('Network monitor initialization failed:', error);
         });
     }
     async init() {
@@ -5167,10 +5743,10 @@ class ReactNativeNetworkMonitor extends NetworkBase {
         try {
             const module = require('@react-native-community/netinfo');
             this.netInfoModule = module.default || module;
-            log$9.debug('Loaded @react-native-community/netinfo module');
+            log$8.debug('Loaded @react-native-community/netinfo module');
         }
         catch (error) {
-            log$9.error('Failed to load React Native NetInfo module:', error);
+            log$8.error('Failed to load React Native NetInfo module:', error);
             this.netInfoModule = null;
         }
     }
@@ -5178,10 +5754,10 @@ class ReactNativeNetworkMonitor extends NetworkBase {
         try {
             const module = require('expo-network');
             this.netInfoModule = module.default || module;
-            log$9.debug('Loaded expo-network module');
+            log$8.debug('Loaded expo-network module');
         }
         catch (error) {
-            log$9.error('Failed to load Expo Network module:', error);
+            log$8.error('Failed to load Expo Network module:', error);
             this.netInfoModule = null;
         }
     }
@@ -5198,16 +5774,16 @@ class ReactNativeNetworkMonitor extends NetworkBase {
             }
             const online = !!(state.isConnected && state.isInternetReachable !== false);
             this.updateStatus(online);
-            log$9.debug('Initial network state:', online ? 'online' : 'offline');
+            log$8.debug('Initial network state:', online ? 'online' : 'offline');
         }
         catch (error) {
-            log$9.warn('Could not fetch initial network state:', error);
+            log$8.warn('Could not fetch initial network state:', error);
         }
     }
     subscribeToStateChanges() {
         if (!this.netInfoModule)
             return;
-        log$9.debug('Subscribing to network state changes');
+        log$8.debug('Subscribing to network state changes');
         const handleState = (state) => {
             const online = !!(state.isConnected && (state.isInternetReachable ?? true));
             this.updateStatus(online);
@@ -5249,7 +5825,7 @@ class ReactNativeNetworkMonitor extends NetworkBase {
             };
         }
         catch (error) {
-            log$9.error('Failed to fetch detailed network info:', error);
+            log$8.error('Failed to fetch detailed network info:', error);
             return null;
         }
     }
@@ -5385,7 +5961,7 @@ class CertificateValidator {
     }
 }
 
-const log$8 = createPrefixedLogger('RN-MTLS');
+const log$7 = createPrefixedLogger('RN-MTLS');
 /**
  * React Native mTLS Adapter using @a-cube-io/expo-mutual-tls
  */
@@ -5407,7 +5983,7 @@ class ReactNativeMTLSAdapter {
             this.expoMTLS = ExpoMutualTls;
             // Set up debug logging with the correct event signature
             const debugListener = ExpoMutualTls.onDebugLog((event) => {
-                log$8.debug(`${event.type}: ${event.message}`, {
+                log$7.debug(`${event.type}: ${event.message}`, {
                     method: event.method,
                     url: event.url,
                     statusCode: event.statusCode,
@@ -5417,28 +5993,28 @@ class ReactNativeMTLSAdapter {
             this.eventListeners.push(debugListener);
             // Set up error logging with the correct event signature
             const errorListener = ExpoMutualTls.onError((event) => {
-                log$8.error(event.message, {
+                log$7.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$8.warn(`Certificate ${event.subject} expires at ${new Date(event.expiry)}`, {
+                log$7.warn(`Certificate ${event.subject} expires at ${new Date(event.expiry)}`, {
                     alias: event.alias,
                     warning: event.warning,
                 });
             });
             this.eventListeners.push(expiryListener);
-            log$8.debug('Expo mTLS module loaded successfully');
+            log$7.debug('Expo mTLS module loaded successfully');
         }
         catch (error) {
-            log$8.warn('@a-cube-io/expo-mutual-tls not available:', error);
+            log$7.warn('@a-cube-io/expo-mutual-tls not available:', error);
         }
     }
     async isMTLSSupported() {
         const supported = this.expoMTLS !== null;
-        log$8.debug('mTLS support check:', {
+        log$7.debug('mTLS support check:', {
             supported,
             platform: this.getPlatformInfo().platform,
             moduleAvailable: !!this.expoMTLS,
@@ -5450,7 +6026,7 @@ class ReactNativeMTLSAdapter {
             throw new MTLSError(MTLSErrorType$1.NOT_SUPPORTED, 'Expo mTLS module not available');
         }
         this.config = config;
-        log$8.debug('Initialized with config:', {
+        log$7.debug('Initialized with config:', {
             baseUrl: config.baseUrl,
             port: config.port,
             timeout: config.timeout,
@@ -5464,7 +6040,7 @@ class ReactNativeMTLSAdapter {
         if (!this.config) {
             throw new MTLSError(MTLSErrorType$1.CONFIGURATION_ERROR, 'Adapter not initialized. Call initialize() first.');
         }
-        log$8.debug('Configuring certificate:', {
+        log$7.debug('Configuring certificate:', {
             format: certificateData.format,
             hasPassword: !!certificateData.password,
             certificateLength: certificateData.certificate.length,
@@ -5481,14 +6057,14 @@ class ReactNativeMTLSAdapter {
                 'client-key-service', // keyService
                 true // enableLogging - let the native module handle its own debug logging
                 );
-                log$8.debug('PEM services configured:', configResult);
+                log$7.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$8.debug('PEM certificate store result:', storeResult);
+                log$7.debug('PEM certificate store result:', storeResult);
                 if (!storeResult) {
                     throw new MTLSError(MTLSErrorType$1.CERTIFICATE_INVALID, 'Failed to store PEM certificate');
                 }
@@ -5501,14 +6077,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$8.debug('P12 service configured:', configResult);
+                log$7.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$8.debug('P12 certificate store result:', storeResult);
+                log$7.debug('P12 certificate store result:', storeResult);
                 if (!storeResult) {
                     throw new MTLSError(MTLSErrorType$1.CERTIFICATE_INVALID, 'Failed to store P12 certificate');
                 }
@@ -5522,7 +6098,7 @@ class ReactNativeMTLSAdapter {
             if (error instanceof MTLSError) {
                 throw error;
             }
-            log$8.error('Certificate configuration failed:', error);
+            log$7.error('Certificate configuration failed:', error);
             throw new MTLSError(MTLSErrorType$1.CONFIGURATION_ERROR, 'Failed to configure certificate', error);
         }
     }
@@ -5533,38 +6109,38 @@ class ReactNativeMTLSAdapter {
         try {
             // Use static method call
             const hasCert = await this.expoMTLS.hasCertificate();
-            log$8.debug('Certificate availability check:', hasCert);
+            log$7.debug('Certificate availability check:', hasCert);
             return hasCert;
         }
         catch (error) {
-            log$8.error('Certificate check failed:', error);
+            log$7.error('Certificate check failed:', error);
             return false;
         }
     }
     async getCertificateInfo() {
         if (!this.expoMTLS) {
-            log$8.debug('Certificate info requested but module not available');
+            log$7.debug('Certificate info requested but module not available');
             return null;
         }
         try {
             const hasCert = await this.hasCertificate();
             if (!hasCert) {
-                log$8.debug('No certificate stored');
+                log$7.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$8.debug('No certificate information available');
+                log$7.debug('No certificate information available');
                 return null;
             }
             // Get the first certificate (primary client certificate)
             const cert = result.certificates[0];
             if (!cert) {
-                log$8.debug('Certificate data is empty');
+                log$7.debug('Certificate data is empty');
                 return null;
             }
-            log$8.debug('Retrieved certificate info:', {
+            log$7.debug('Retrieved certificate info:', {
                 subject: cert.subject.commonName,
                 issuer: cert.issuer.commonName,
                 validFrom: new Date(cert.validFrom),
@@ -5583,7 +6159,7 @@ class ReactNativeMTLSAdapter {
             };
         }
         catch (error) {
-            log$8.error('Failed to get certificate info:', error);
+            log$7.error('Failed to get certificate info:', error);
             return null;
         }
     }
@@ -5594,7 +6170,7 @@ class ReactNativeMTLSAdapter {
      */
     async parseCertificateData(certificateData) {
         if (!this.expoMTLS) {
-            log$8.debug('Parse certificate: Module not available');
+            log$7.debug('Parse certificate: Module not available');
             return null;
         }
         try {
@@ -5611,14 +6187,14 @@ class ReactNativeMTLSAdapter {
             else {
                 throw new MTLSError(MTLSErrorType$1.CERTIFICATE_INVALID, `Unsupported certificate format: ${certificateData.format}`);
             }
-            log$8.debug('Certificate parsed successfully:', {
+            log$7.debug('Certificate parsed successfully:', {
                 certificateCount: result.certificates.length,
                 subjects: result.certificates.map((cert) => cert.subject.commonName),
             });
             return result;
         }
         catch (error) {
-            log$8.error('Failed to parse certificate:', error);
+            log$7.error('Failed to parse certificate:', error);
             if (error instanceof MTLSError) {
                 throw error;
             }
@@ -5633,7 +6209,7 @@ class ReactNativeMTLSAdapter {
         if (!hasCert) {
             throw new MTLSError(MTLSErrorType$1.CERTIFICATE_NOT_FOUND, 'No certificate configured');
         }
-        log$8.debug('Making mTLS request:', {
+        log$7.debug('Making mTLS request:', {
             method: requestConfig.method || 'GET',
             url: requestConfig.url,
             headers: requestConfig.headers,
@@ -5641,7 +6217,7 @@ class ReactNativeMTLSAdapter {
             responseType: requestConfig.responseType,
         });
         if (requestConfig.data) {
-            log$8.debug('mTLS request body:', requestConfig.data);
+            log$7.debug('mTLS request body:', requestConfig.data);
         }
         try {
             const response = await this.expoMTLS.request(requestConfig.url, {
@@ -5650,7 +6226,7 @@ class ReactNativeMTLSAdapter {
                 body: requestConfig.data ? JSON.stringify(requestConfig.data) : undefined,
                 responseType: requestConfig.responseType,
             });
-            log$8.debug('mTLS request successful:', response);
+            log$7.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);
             }
@@ -5662,7 +6238,7 @@ class ReactNativeMTLSAdapter {
                     data = JSON.parse(response.body);
                 }
                 catch (parseError) {
-                    log$8.warn('Failed to parse JSON response:', parseError);
+                    log$7.warn('Failed to parse JSON response:', parseError);
                     // If parsing fails, keep raw body
                 }
             }
@@ -5679,7 +6255,7 @@ class ReactNativeMTLSAdapter {
             };
         }
         catch (error) {
-            log$8.error('mTLS request failed:', error);
+            log$7.error('mTLS request failed:', error);
             throw new MTLSError(MTLSErrorType$1.CONNECTION_FAILED, 'mTLS request failed', error);
         }
     }
@@ -5692,18 +6268,18 @@ class ReactNativeMTLSAdapter {
      */
     async testConnection() {
         if (!this.expoMTLS || !this.config) {
-            log$8.debug('Diagnostic test: No mTLS module or config available');
+            log$7.debug('Diagnostic test: No mTLS module or config available');
             return false;
         }
         try {
             const hasCert = await this.hasCertificate();
             if (!hasCert) {
-                log$8.debug('Diagnostic test: No certificate configured');
+                log$7.debug('Diagnostic test: No certificate configured');
                 return false;
             }
-            log$8.debug('Running diagnostic test (may fail even if mTLS works):', this.config.baseUrl);
+            log$7.debug('Running diagnostic test (may fail even if mTLS works):', this.config.baseUrl);
             const result = await this.expoMTLS.testConnection(this.config.baseUrl);
-            log$8.debug('Diagnostic test result (NOT validation):', {
+            log$7.debug('Diagnostic test result (NOT validation):', {
                 success: result.success,
                 statusCode: result.statusCode,
                 statusMessage: result.statusMessage,
@@ -5714,13 +6290,13 @@ class ReactNativeMTLSAdapter {
             return result.success;
         }
         catch (error) {
-            log$8.warn('Diagnostic test failed (this is expected):', error);
+            log$7.warn('Diagnostic test failed (this is expected):', error);
             return false;
         }
     }
     async removeCertificate() {
         if (!this.expoMTLS) {
-            log$8.debug('Remove certificate: Module not available');
+            log$7.debug('Remove certificate: Module not available');
             return;
         }
         try {
@@ -5729,10 +6305,10 @@ class ReactNativeMTLSAdapter {
             this.isConfigured = false;
             // Cleanup event listeners
             this.cleanupEventListeners();
-            log$8.debug('Certificate removed successfully');
+            log$7.debug('Certificate removed successfully');
         }
         catch (error) {
-            log$8.error('Failed to remove certificate:', error);
+            log$7.error('Failed to remove certificate:', error);
             throw new MTLSError(MTLSErrorType$1.CONFIGURATION_ERROR, 'Failed to remove certificate', error);
         }
     }
@@ -5741,7 +6317,7 @@ class ReactNativeMTLSAdapter {
      */
     cleanupEventListeners() {
         if (this.eventListeners.length > 0) {
-            log$8.debug(`Cleaning up ${this.eventListeners.length} event listeners`);
+            log$7.debug(`Cleaning up ${this.eventListeners.length} event listeners`);
         }
         // Remove individual listeners if they have remove methods
         this.eventListeners.forEach((listener) => {
@@ -5778,7 +6354,7 @@ class ReactNativeMTLSAdapter {
     }
 }
 
-const log$7 = createPrefixedLogger('WEB-MTLS');
+const log$6 = createPrefixedLogger('WEB-MTLS');
 /**
  * Web mTLS Adapter - Graceful fallback for web browsers
  *
@@ -5792,13 +6368,13 @@ const log$7 = createPrefixedLogger('WEB-MTLS');
  */
 class WebMTLSAdapter {
     constructor() {
-        log$7.warn('Web browsers do not support programmatic mTLS configuration');
-        log$7.info('Use JWT authentication or configure client certificates in browser settings');
+        log$6.warn('Web browsers do not support programmatic mTLS configuration');
+        log$6.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$7.debug('mTLS support check:', {
+        log$6.debug('mTLS support check:', {
             supported,
             platform: this.getPlatformInfo().platform,
             reason: 'Browser security model prevents programmatic certificate configuration',
@@ -5807,14 +6383,14 @@ class WebMTLSAdapter {
         return supported;
     }
     async initialize(config) {
-        log$7.warn('Initialized but mTLS not available in web browsers:', {
+        log$6.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$7.error('Certificate configuration attempted:', {
+        log$6.error('Certificate configuration attempted:', {
             format: certificateData.format,
             reason: 'Not supported in web browsers',
             alternatives: [
@@ -5829,15 +6405,15 @@ class WebMTLSAdapter {
     }
     async hasCertificate() {
         // We cannot detect if the browser has certificates configured
-        log$7.debug('Certificate availability check: Cannot detect browser certificates programmatically');
+        log$6.debug('Certificate availability check: Cannot detect browser certificates programmatically');
         return false;
     }
     async getCertificateInfo() {
-        log$7.debug('Certificate info requested: Not accessible in web browsers');
+        log$6.debug('Certificate info requested: Not accessible in web browsers');
         return null;
     }
     async request(requestConfig) {
-        log$7.error('mTLS request attempted:', {
+        log$6.error('mTLS request attempted:', {
             method: requestConfig.method,
             url: requestConfig.url,
             reason: 'Not supported in web browsers',
@@ -5852,11 +6428,11 @@ class WebMTLSAdapter {
             'are properly configured in the browser certificate store.');
     }
     async testConnection() {
-        log$7.debug('Connection test: mTLS not available in web browsers');
+        log$6.debug('Connection test: mTLS not available in web browsers');
         return false;
     }
     async removeCertificate() {
-        log$7.debug('Remove certificate: No certificates to remove (not supported in web browsers)');
+        log$6.debug('Remove certificate: No certificates to remove (not supported in web browsers)');
         // No-op - cannot remove certificates programmatically in browsers
     }
     /**
@@ -5864,7 +6440,7 @@ class WebMTLSAdapter {
      * Always returns null for web browsers as mTLS is not supported
      */
     getBaseUrl() {
-        log$7.debug('Base URL requested: Not supported in web browsers');
+        log$6.debug('Base URL requested: Not supported in web browsers');
         return null;
     }
     getPlatformInfo() {
@@ -5897,7 +6473,7 @@ class WebMTLSAdapter {
     }
 }
 
-const log$6 = createPrefixedLogger('MTLS-LOADER');
+const log$5 = createPrefixedLogger('MTLS-LOADER');
 function loadMTLSAdapter(platform, config) {
     try {
         let adapter;
@@ -5931,7 +6507,7 @@ function loadMTLSAdapter(platform, config) {
         return adapter;
     }
     catch (error) {
-        log$6.warn(`mTLS adapter not available for platform ${platform}:`, error);
+        log$5.warn(`mTLS adapter not available for platform ${platform}:`, error);
         return null;
     }
 }
@@ -5941,7 +6517,7 @@ async function initializeAdapterAsync(adapter, config) {
         if (isSupported) {
             await adapter.initialize(config);
             const platformInfo = adapter.getPlatformInfo();
-            log$6.debug('mTLS adapter initialized:', {
+            log$5.debug('mTLS adapter initialized:', {
                 platform: platformInfo.platform,
                 mtlsSupported: platformInfo.mtlsSupported,
                 certificateStorage: platformInfo.certificateStorage,
@@ -5950,20 +6526,20 @@ async function initializeAdapterAsync(adapter, config) {
         }
     }
     catch (error) {
-        log$6.warn('Failed to initialize mTLS adapter:', error);
+        log$5.warn('Failed to initialize mTLS adapter:', error);
     }
 }
 
-const log$5 = createPrefixedLogger('ADAPTER-LOADER');
+const log$4 = createPrefixedLogger('ADAPTER-LOADER');
 function loadPlatformAdapters(options = {}) {
     const { mtlsConfig } = options;
     const { platform } = detectPlatform();
-    log$5.debug('Loading adapters for platform:', platform);
+    log$4.debug('Loading adapters for platform:', platform);
     const storageAdapters = loadStorageAdapters(platform);
     const networkMonitor = loadNetworkMonitor(platform);
     const cache = loadCacheAdapter(platform);
     const mtls = loadMTLSAdapter(platform, mtlsConfig);
-    log$5.debug('Adapters loaded:', {
+    log$4.debug('Adapters loaded:', {
         platform,
         hasStorage: !!storageAdapters.storage,
         hasSecureStorage: !!storageAdapters.secureStorage,
@@ -5989,92 +6565,6 @@ function createACubeMTLSConfig(baseUrl, timeout, autoInitialize = true, forcePor
     };
 }
 
-class ConfigManager {
-    constructor(userConfig) {
-        this.config = this.buildConfig(userConfig);
-    }
-    buildConfig(userConfig) {
-        return {
-            environment: userConfig.environment,
-            apiUrl: this.getDefaultApiUrl(userConfig.environment),
-            authUrl: this.getDefaultAuthUrl(userConfig.environment),
-            timeout: 30000,
-            retryAttempts: 3,
-            debug: userConfig.debug ?? false,
-            customHeaders: {},
-        };
-    }
-    getDefaultApiUrl(environment) {
-        switch (environment) {
-            case 'production':
-                return 'https://ereceipts-it.acubeapi.com';
-            case 'development':
-                return 'https://ereceipts-it.dev.acubeapi.com';
-            case 'sandbox':
-            default:
-                return 'https://ereceipts-it-sandbox.acubeapi.com';
-        }
-    }
-    getDefaultAuthUrl(environment) {
-        switch (environment) {
-            case 'production':
-                return 'https://common.api.acubeapi.com';
-            case 'development':
-            case 'sandbox':
-            default:
-                return 'https://common-sandbox.api.acubeapi.com';
-        }
-    }
-    getConfig() {
-        return {
-            environment: this.config.environment,
-            debug: this.config.debug,
-        };
-    }
-    getApiUrl() {
-        return this.config.apiUrl;
-    }
-    getAuthUrl() {
-        return this.config.authUrl;
-    }
-    getEnvironment() {
-        return this.config.environment;
-    }
-    isDebugEnabled() {
-        return this.config.debug;
-    }
-    getTimeout() {
-        return this.config.timeout;
-    }
-    getRetryAttempts() {
-        return this.config.retryAttempts;
-    }
-    getCustomHeaders() {
-        return { ...this.config.customHeaders };
-    }
-    updateConfig(updates) {
-        if (updates.environment) {
-            this.config.environment = updates.environment;
-            this.config.apiUrl = this.getDefaultApiUrl(updates.environment);
-            this.config.authUrl = this.getDefaultAuthUrl(updates.environment);
-        }
-        if (updates.debug !== undefined) {
-            this.config.debug = updates.debug;
-        }
-    }
-}
-
-class ACubeSDKError extends Error {
-    constructor(type, message, originalError, statusCode, violations) {
-        super(message);
-        this.type = type;
-        this.originalError = originalError;
-        this.statusCode = statusCode;
-        this.name = 'ACubeSDKError';
-        this.violations = violations;
-    }
-}
-
 const DI_TOKENS = {
     HTTP_PORT: Symbol('HTTP_PORT'),
     BASE_HTTP_PORT: Symbol('BASE_HTTP_PORT'),
@@ -7075,7 +7565,7 @@ class TelemetryRepositoryImpl {
     }
 }
 
-const log$4 = createPrefixedLogger('CACHE-KEY');
+const log$3 = createPrefixedLogger('CACHE-KEY');
 const URL_PATTERNS = [
     // Receipt (mf1) - specific patterns first
     {
@@ -7168,7 +7658,7 @@ const DEFAULT_TTL = 5 * 60 * 1000; // 5 minutes
 class CacheKeyGenerator {
     constructor(customConfig) {
         this.config = { ...DEFAULT_TTL_CONFIG, ...customConfig };
-        log$4.info('CacheKeyGenerator initialized with config:', {
+        log$3.info('CacheKeyGenerator initialized with config:', {
             resources: Object.keys(this.config),
         });
     }
@@ -7178,7 +7668,7 @@ class CacheKeyGenerator {
             // Fallback: use URL as key
             const paramStr = params ? this.serializeParams(params) : '';
             const key = paramStr ? `${url}?${paramStr}` : url;
-            log$4.debug('URL not matched, using fallback key:', { url, key });
+            log$3.debug('URL not matched, using fallback key:', { url, key });
             return key;
         }
         const { resource, ids, action, isList, parent } = parsed;
@@ -7186,21 +7676,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$4.debug('Generated list cache key:', { url, key, resource });
+            log$3.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$4.debug('Generated special action cache key:', { url, key, resource, action });
+            log$3.debug('Generated special action cache key:', { url, key, resource, action });
             return key;
         }
         let key = `${resource}:${ids.join(':')}`;
         if (action) {
             key += `:${action}`;
         }
-        log$4.debug('Generated item cache key:', { url, key, resource, ids, action });
+        log$3.debug('Generated item cache key:', { url, key, resource, ids, action });
         return key;
     }
     parseResource(url) {
@@ -7210,23 +7700,23 @@ class CacheKeyGenerator {
     getTTL(url) {
         const resource = this.parseResource(url);
         if (!resource) {
-            log$4.debug('No resource found for URL, using default TTL:', { url, ttl: DEFAULT_TTL });
+            log$3.debug('No resource found for URL, using default TTL:', { url, ttl: DEFAULT_TTL });
             return DEFAULT_TTL;
         }
         const ttl = this.config[resource].ttlMs;
-        log$4.debug('TTL for resource:', { url, resource, ttlMs: ttl, ttlMin: ttl / 60000 });
+        log$3.debug('TTL for resource:', { url, resource, ttlMs: ttl, ttlMin: ttl / 60000 });
         return ttl;
     }
     shouldCache(url) {
         const parsed = this.parseUrl(url);
         if (!parsed) {
-            log$4.debug('URL not recognized, should not cache:', { url });
+            log$3.debug('URL not recognized, should not cache:', { url });
             return false;
         }
         const { resource, isList } = parsed;
         const config = this.config[resource];
         if (isList) {
-            log$4.debug('List endpoint cache decision:', {
+            log$3.debug('List endpoint cache decision:', {
                 url,
                 resource,
                 isList: true,
@@ -7234,7 +7724,7 @@ class CacheKeyGenerator {
             });
             return config.cacheList;
         }
-        log$4.debug('Item endpoint cache decision:', {
+        log$3.debug('Item endpoint cache decision:', {
             url,
             resource,
             isList: false,
@@ -7245,7 +7735,7 @@ class CacheKeyGenerator {
     getInvalidationPatterns(url, method) {
         const parsed = this.parseUrl(url);
         if (!parsed) {
-            log$4.debug('No patterns to invalidate for URL:', { url, method });
+            log$3.debug('No patterns to invalidate for URL:', { url, method });
             return [];
         }
         const { resource, ids, parent } = parsed;
@@ -7267,7 +7757,7 @@ class CacheKeyGenerator {
         if (resource === 'cashier' && (method === 'PUT' || method === 'DELETE')) {
             patterns.push('cashier:me');
         }
-        log$4.debug('Invalidation patterns:', { url, method, patterns });
+        log$3.debug('Invalidation patterns:', { url, method, patterns });
         return patterns;
     }
     parseUrl(url) {
@@ -7302,7 +7792,7 @@ class CacheKeyGenerator {
     }
 }
 
-const log$3 = createPrefixedLogger('CACHE');
+const log$2 = createPrefixedLogger('CACHE');
 class CachingHttpDecorator {
     constructor(http, cache, keyGenerator, networkMonitor, config = {}) {
         this.http = http;
@@ -7312,7 +7802,7 @@ class CachingHttpDecorator {
         this.config = config;
         this.currentOnlineState = true;
         this.authToken = null;
-        log$3.info('CachingHttpDecorator initialized', {
+        log$2.info('CachingHttpDecorator initialized', {
             enabled: config.enabled !== false,
             hasNetworkMonitor: !!networkMonitor,
         });
@@ -7322,7 +7812,7 @@ class CachingHttpDecorator {
         if (this.networkMonitor) {
             this.networkSubscription = this.networkMonitor.online$.subscribe((online) => {
                 if (this.currentOnlineState !== online) {
-                    log$3.info('Network state changed:', { online });
+                    log$2.info('Network state changed:', { online });
                 }
                 this.currentOnlineState = online;
             });
@@ -7341,19 +7831,19 @@ class CachingHttpDecorator {
         const startTime = Date.now();
         // Check if caching is disabled globally
         if (this.config.enabled === false) {
-            log$3.debug('GET (cache disabled globally):', { url });
+            log$2.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$3.debug('GET (not cacheable - likely a list endpoint):', { url });
+            log$2.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$3.info('GET request starting:', {
+        log$2.info('GET request starting:', {
             url,
             resource,
             cacheKey,
@@ -7366,18 +7856,18 @@ class CachingHttpDecorator {
         try {
             cached = await this.cache.get(cacheKey);
             if (cached) {
-                log$3.debug('Cache entry found:', {
+                log$2.debug('Cache entry found:', {
                     cacheKey,
                     timestamp: new Date(cached.timestamp).toISOString(),
                     ageMs: Date.now() - cached.timestamp,
                 });
             }
             else {
-                log$3.debug('Cache entry not found:', { cacheKey });
+                log$2.debug('Cache entry not found:', { cacheKey });
             }
         }
         catch (error) {
-            log$3.warn('Cache lookup failed:', {
+            log$2.warn('Cache lookup failed:', {
                 cacheKey,
                 error: error instanceof Error ? error.message : error,
             });
@@ -7385,7 +7875,7 @@ class CachingHttpDecorator {
         if (cached) {
             const age = Date.now() - cached.timestamp;
             const isExpired = age >= ttl;
-            log$3.debug('Cache analysis:', {
+            log$2.debug('Cache analysis:', {
                 cacheKey,
                 ageMs: age,
                 ageSec: Math.round(age / 1000),
@@ -7396,7 +7886,7 @@ class CachingHttpDecorator {
             // If within TTL, return cached data
             if (!isExpired) {
                 const duration = Date.now() - startTime;
-                log$3.info('CACHE HIT:', {
+                log$2.info('CACHE HIT:', {
                     url,
                     cacheKey,
                     ageMs: age,
@@ -7411,7 +7901,7 @@ class CachingHttpDecorator {
             // If offline and cache is stale, return stale data
             if (!this.isOnline()) {
                 const duration = Date.now() - startTime;
-                log$3.info('CACHE STALE (offline):', {
+                log$2.info('CACHE STALE (offline):', {
                     url,
                     cacheKey,
                     ageMs: age,
@@ -7423,25 +7913,25 @@ class CachingHttpDecorator {
                     headers: { 'x-cache': 'STALE' },
                 };
             }
-            log$3.debug('Cache expired, fetching fresh data:', { cacheKey, ageMs: age, ttlMs: ttl });
+            log$2.debug('Cache expired, fetching fresh data:', { cacheKey, ageMs: age, ttlMs: ttl });
         }
         // Fetch fresh data
         try {
-            log$3.debug('Fetching from network:', { url });
+            log$2.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$3.debug('Response cached successfully:', { cacheKey });
+                log$2.debug('Response cached successfully:', { cacheKey });
             }
             catch (error) {
-                log$3.error('Failed to cache response:', {
+                log$2.error('Failed to cache response:', {
                     cacheKey,
                     error: error instanceof Error ? error.message : error,
                 });
             }
             const duration = Date.now() - startTime;
-            log$3.info('CACHE MISS (fetched fresh):', {
+            log$2.info('CACHE MISS (fetched fresh):', {
                 url,
                 cacheKey,
                 status: response.status,
@@ -7456,7 +7946,7 @@ class CachingHttpDecorator {
             // On error, return stale cache if available
             if (cached) {
                 const duration = Date.now() - startTime;
-                log$3.warn('CACHE STALE (network error):', {
+                log$2.warn('CACHE STALE (network error):', {
                     url,
                     cacheKey,
                     error: error instanceof Error ? error.message : 'Unknown error',
@@ -7468,7 +7958,7 @@ class CachingHttpDecorator {
                     headers: { 'x-cache': 'STALE' },
                 };
             }
-            log$3.error('Network error with no cache fallback:', {
+            log$2.error('Network error with no cache fallback:', {
                 url,
                 error: error instanceof Error ? error.message : error,
             });
@@ -7476,31 +7966,35 @@ class CachingHttpDecorator {
         }
     }
     async post(url, data, config) {
-        log$3.info('POST request:', { url });
+        log$2.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$3.info('PUT request:', { url });
+        log$2.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$3.info('PATCH request:', { url });
+        log$2.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$3.info('DELETE request:', { url });
+        log$2.info('DELETE request:', { url });
         const response = await this.http.delete(url, config);
         await this.invalidateRelated(url, 'DELETE');
         return response;
     }
     setAuthToken(token) {
-        log$3.debug('Auth token updated:', { hasToken: !!token });
+        log$2.debug('CachingHttpDecorator.setAuthToken called:', {
+            hasToken: !!token,
+            tokenPrefix: token?.substring(0, 20),
+            underlyingHttpType: this.http.constructor.name,
+        });
         this.authToken = token;
         this.http.setAuthToken(token);
     }
@@ -7510,17 +8004,17 @@ class CachingHttpDecorator {
     async invalidateRelated(url, method) {
         const patterns = this.keyGenerator.getInvalidationPatterns(url, method);
         if (patterns.length === 0) {
-            log$3.debug('No cache patterns to invalidate:', { url, method });
+            log$2.debug('No cache patterns to invalidate:', { url, method });
             return;
         }
-        log$3.info('Invalidating cache patterns:', { url, method, patterns });
+        log$2.info('Invalidating cache patterns:', { url, method, patterns });
         for (const pattern of patterns) {
             try {
                 await this.cache.invalidate(pattern);
-                log$3.debug('Cache pattern invalidated:', { pattern });
+                log$2.debug('Cache pattern invalidated:', { pattern });
             }
             catch (error) {
-                log$3.error('Failed to invalidate pattern:', {
+                log$2.error('Failed to invalidate pattern:', {
                     pattern,
                     error: error instanceof Error ? error.message : error,
                 });
@@ -7528,12 +8022,13 @@ class CachingHttpDecorator {
         }
     }
     destroy() {
-        log$3.debug('CachingHttpDecorator destroyed');
+        log$2.debug('CachingHttpDecorator destroyed');
         this.networkSubscription?.unsubscribe();
     }
 }
 
-const log$2 = createPrefixedLogger('HTTP-MTLS');
+const logJwt = createPrefixedLogger('HTTP-JWT');
+const logMtls = createPrefixedLogger('HTTP-MTLS');
 class AxiosHttpAdapter {
     constructor(config) {
         this.authToken = null;
@@ -7551,23 +8046,30 @@ class AxiosHttpAdapter {
     }
     setMTLSAdapter(adapter) {
         this.mtlsAdapter = adapter;
-        log$2.debug('mTLS adapter configured:', !!adapter);
+        logMtls.debug('mTLS adapter configured:', !!adapter);
     }
     setAuthStrategy(strategy) {
         this.authStrategy = strategy;
-        log$2.debug('Auth strategy configured:', !!strategy);
+        logJwt.debug('Auth strategy configured:', !!strategy);
     }
     async shouldUseMTLS(url, method) {
         if (!this.mtlsAdapter) {
+            logJwt.debug(`No mTLS adapter, using JWT for ${method} ${url}`);
             return false;
         }
         if (this.authStrategy) {
             const config = await this.authStrategy.determineAuthConfig(url, method);
-            log$2.debug(`Auth config for ${method} ${url}:`, config);
+            const logger = config.mode === 'mtls' ? logMtls : logJwt;
+            logger.debug(`Auth config for ${method} ${url}:`, config);
             return config.mode === 'mtls';
         }
         // Fallback: use mTLS for mf1/mf2 endpoints if no strategy
-        return url.startsWith('/mf1') || url.startsWith('/mf2');
+        // This should rarely happen - only before SDK is fully initialized
+        const useMtls = url.startsWith('/mf1') || url.startsWith('/mf2');
+        if (useMtls) {
+            logMtls.warn(`No auth strategy set, falling back to mTLS for ${method} ${url}`);
+        }
+        return useMtls;
     }
     async makeMTLSRequest(url, method, data, config) {
         if (!this.mtlsAdapter) {
@@ -7580,10 +8082,10 @@ class AxiosHttpAdapter {
         };
         if (this.authToken) {
             headers['Authorization'] = `Bearer ${this.authToken}`;
-            log$2.debug('JWT token present for mTLS request');
+            logMtls.debug('JWT token present for mTLS request');
         }
         else {
-            log$2.warn('No JWT token for mTLS request');
+            logMtls.warn('No JWT token for mTLS request');
         }
         const mtlsConfig = {
             url: fullUrl,
@@ -7592,15 +8094,15 @@ class AxiosHttpAdapter {
             data,
             timeout: config?.timeout,
         };
-        log$2.debug(`mTLS ${method} ${fullUrl}`);
+        logMtls.debug(`mTLS ${method} ${fullUrl}`);
         if (data) {
-            log$2.debug('Request body:', data);
+            logMtls.debug('Request body:', data);
         }
         try {
             const response = await this.mtlsAdapter.request(mtlsConfig);
-            log$2.debug(`mTLS Response ${response.status} from ${fullUrl}`);
+            logMtls.debug(`mTLS Response ${response.status} from ${fullUrl}`);
             if (response.data) {
-                log$2.debug('Response body:', response.data);
+                logMtls.debug('Response body:', response.data);
             }
             return {
                 data: response.data,
@@ -7609,11 +8111,11 @@ class AxiosHttpAdapter {
             };
         }
         catch (error) {
-            log$2.error(`mTLS Response error from ${fullUrl}:`, error);
+            logMtls.error(`mTLS Response error from ${fullUrl}:`, error);
             if (error && typeof error === 'object' && 'response' in error) {
                 const axiosError = error;
                 if (axiosError.response?.data) {
-                    log$2.error('Response body:', axiosError.response.data);
+                    logMtls.error('Response body:', axiosError.response.data);
                 }
             }
             throw error;
@@ -7628,36 +8130,46 @@ class AxiosHttpAdapter {
         this.client.interceptors.request.use((config) => {
             if (this.authToken) {
                 config.headers.Authorization = `Bearer ${this.authToken}`;
-                log$2.debug('Adding JWT token to request');
+                logJwt.debug('Adding JWT token to request', {
+                    tokenPrefix: this.authToken.substring(0, 30) + '...',
+                    tokenLength: this.authToken.length,
+                });
             }
             else {
-                log$2.warn('No JWT token available for request:', { url: config.url });
+                logJwt.warn('No JWT token available for request:', { url: config.url });
             }
             const method = config.method?.toUpperCase() ?? 'UNKNOWN';
-            log$2.debug(`→ ${method} ${config.url}`);
+            const authHeader = config.headers.Authorization;
+            // Log full request details for debugging
+            logJwt.info(`→ ${method} ${config.url}`, {
+                baseURL: config.baseURL,
+                fullURL: `${config.baseURL}${config.url}`,
+                hasAuthHeader: !!authHeader,
+                authHeaderValue: authHeader ? `${String(authHeader).substring(0, 50)}...` : 'MISSING',
+            });
             if (config.params && Object.keys(config.params).length > 0) {
-                log$2.debug('Request params:', config.params);
+                logJwt.debug('Request params:', config.params);
             }
             if (config.data) {
-                log$2.debug('Request body:', config.data);
+                logJwt.debug('Request body:', config.data);
             }
             return config;
         }, (error) => {
-            log$2.error('Request error:', error);
+            logJwt.error('Request error:', error);
             return Promise.reject(error);
         });
         this.client.interceptors.response.use((response) => {
             const method = response.config.method?.toUpperCase() ?? 'UNKNOWN';
-            log$2.debug(`← ${method} ${response.status} ${response.config.url}`);
+            logJwt.debug(`← ${method} ${response.status} ${response.config.url}`);
             if (response.data) {
-                log$2.debug('Response body:', response.data);
+                logJwt.debug('Response body:', response.data);
             }
             return response;
         }, (error) => {
             const method = error.config?.method?.toUpperCase() ?? 'UNKNOWN';
-            log$2.error(`← ${method} ${error.response?.status ?? 'ERR'} ${error.config?.url ?? 'unknown'}`);
+            logJwt.error(`← ${method} ${error.response?.status ?? 'ERR'} ${error.config?.url ?? 'unknown'}`);
             if (error.response?.data) {
-                log$2.error('Response body:', error.response.data);
+                logJwt.error('Response body:', error.response.data);
             }
             return Promise.reject(error);
         });
@@ -7727,7 +8239,10 @@ class AxiosHttpAdapter {
         return this.mapResponse(response);
     }
     setAuthToken(token) {
-        log$2.info('setAuthToken called:', { hasToken: !!token, tokenPrefix: token?.substring(0, 20) });
+        logJwt.info('setAuthToken called:', {
+            hasToken: !!token,
+            tokenPrefix: token?.substring(0, 20),
+        });
         this.authToken = token;
     }
     getAuthToken() {
@@ -7943,6 +8458,11 @@ class ACubeSDK {
             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', {
+                httpPortType: httpPort.constructor.name,
+                baseHttpPortType: baseHttpPort.constructor.name,
+                areSameInstance: httpPort === baseHttpPort,
+            });
             log$1.debug('Initializing authentication service');
             this.authService = new AuthenticationService(httpPort, tokenStorage, {
                 authUrl: this.config.getAuthUrl(),
@@ -7975,12 +8495,22 @@ class ACubeSDK {
                     this.offlineManager.sync().catch(() => { });
                 }
             });
-            if (await this.authService.isAuthenticated()) {
+            const isAuth = await this.authService.isAuthenticated();
+            log$1.debug('Checking authentication status during init', { isAuthenticated: isAuth });
+            if (isAuth) {
                 const token = await this.authService.getAccessToken();
+                log$1.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');
                 }
             }
+            else {
+                log$1.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');
                 const httpWithMtls = baseHttpPort;
@@ -8799,842 +9329,401 @@ class SDKManager {
             this.appStateService.state$.subscribe(this.events.onAppStateChanged);
         }
         if (this.events?.onTelemetryStateChanged) {
-            this.telemetryService.state$.subscribe(this.events.onTelemetryStateChanged);
-        }
-        this.isInitialized = true;
-        // Only start polling for MERCHANT/CASHIER users (SUPPLIER gets 401 on these endpoints)
-        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;
-        }
-        // AppStateService remains active for all users (handles OFFLINE network state)
-    }
-    /**
-     * Observable stream of app state
-     * Emits AppState with mode (NORMAL, WARNING, BLOCKED, OFFLINE)
-     */
-    get appState$() {
-        this.ensureInitialized();
-        return this.appStateService.state$;
-    }
-    /**
-     * Observable stream of app mode only
-     * Emits AppMode with distinctUntilChanged
-     */
-    get mode$() {
-        this.ensureInitialized();
-        return this.appStateService.mode$;
-    }
-    /**
-     * Observable stream indicating if app is blocked
-     */
-    get isBlocked$() {
-        this.ensureInitialized();
-        return this.appStateService.isBlocked$;
-    }
-    /**
-     * Observable stream of warning state with countdown
-     */
-    get warning$() {
-        this.ensureInitialized();
-        return this.appStateService.warning$;
-    }
-    /**
-     * Observable stream of telemetry state (data, isLoading, isCached, error)
-     */
-    get telemetryState$() {
-        this.ensureInitialized();
-        return this.telemetryService.state$;
-    }
-    /**
-     * Get the pemId from the installed certificate
-     */
-    async getPemId() {
-        this.ensureInitialized();
-        try {
-            const certInfo = await this.sdk.getCertificatesInfo();
-            return certInfo?.pemId ?? null;
-        }
-        catch {
-            return null;
-        }
-    }
-    /**
-     * Start polling telemetry using the pemId from installed certificate
-     * Returns the pemId if successful, null if no certificate is installed
-     */
-    async startTelemetryPollingAuto() {
-        this.ensureInitialized();
-        const pemId = await this.getPemId();
-        if (pemId) {
-            this.telemetryService.startPolling(pemId);
-        }
-        return pemId;
-    }
-    /**
-     * Start polling telemetry for a specific PEM
-     */
-    startTelemetryPolling(pemId) {
-        this.ensureInitialized();
-        this.telemetryService.startPolling(pemId);
-    }
-    /**
-     * Stop telemetry polling
-     */
-    stopTelemetryPolling() {
-        this.ensureInitialized();
-        this.telemetryService.stopPolling();
-    }
-    /**
-     * Get simplified services for product use
-     */
-    getServices() {
-        this.ensureInitialized();
-        const sdk = this.sdk;
-        const telemetryService = this.telemetryService;
-        return {
-            receipts: sdk.receipts,
-            merchants: sdk.merchants,
-            cashiers: sdk.cashiers,
-            cashRegisters: sdk.cashRegisters,
-            pointOfSales: sdk.pointOfSales,
-            suppliers: sdk.suppliers,
-            pems: sdk.pems,
-            dailyReports: sdk.dailyReports,
-            journals: sdk.journals,
-            telemetry: {
-                startPollingAuto: () => this.startTelemetryPollingAuto(),
-                startPolling: (pemId) => telemetryService.startPolling(pemId),
-                stopPolling: () => telemetryService.stopPolling(),
-                getTelemetry: (pemId) => telemetryService.getTelemetry(pemId),
-                refreshTelemetry: (pemId) => telemetryService.refreshTelemetry(pemId),
-                triggerSync: () => telemetryService.triggerSync(),
-                clearTelemetry: () => telemetryService.clearTelemetry(),
-                getPemId: () => this.getPemId(),
-            },
-            login: (credentials) => sdk.login(credentials),
-            logout: () => sdk.logout(),
-            getCurrentUser: () => sdk.getCurrentUser(),
-            isAuthenticated: () => sdk.isAuthenticated(),
-            storeCertificate: (certificate, privateKey, options) => sdk.storeCertificate(certificate, privateKey, options),
-            hasCertificate: () => sdk.hasCertificate(),
-            clearCertificate: () => sdk.clearCertificate(),
-            isOnline: () => sdk.isOnline(),
-        };
+            this.telemetryService.state$.subscribe(this.events.onTelemetryStateChanged);
+        }
+        this.isInitialized = true;
+        // Only start polling for MERCHANT/CASHIER users (SUPPLIER gets 401 on these endpoints)
+        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;
+        }
+        // AppStateService remains active for all users (handles OFFLINE network state)
     }
     /**
-     * Manually trigger a notification sync
+     * Observable stream of app state
+     * Emits AppState with mode (NORMAL, WARNING, BLOCKED, OFFLINE)
      */
-    async syncNotifications() {
+    get appState$() {
         this.ensureInitialized();
-        await this.notificationService.triggerSync();
+        return this.appStateService.state$;
     }
     /**
-     * Manually trigger a telemetry sync
+     * Observable stream of app mode only
+     * Emits AppMode with distinctUntilChanged
      */
-    async syncTelemetry() {
+    get mode$() {
         this.ensureInitialized();
-        return this.telemetryService.triggerSync();
+        return this.appStateService.mode$;
     }
     /**
-     * Check if the manager is initialized
+     * Observable stream indicating if app is blocked
      */
-    getIsInitialized() {
-        return this.isInitialized;
+    get isBlocked$() {
+        this.ensureInitialized();
+        return this.appStateService.isBlocked$;
     }
     /**
-     * Get the underlying SDK instance (for advanced use cases)
+     * Observable stream of warning state with countdown
      */
-    getSDK() {
+    get warning$() {
         this.ensureInitialized();
-        return this.sdk;
-    }
-    cleanup() {
-        this.notificationService?.destroy();
-        this.telemetryService?.destroy();
-        this.appStateService?.destroy();
-        this.sdk?.destroy();
-        this.notificationService = null;
-        this.telemetryService = null;
-        this.appStateService = null;
-        this.sdk = null;
-        this.isInitialized = false;
-        this.isPollingActive = false;
-    }
-    ensureInitialized() {
-        if (!this.isInitialized) {
-            throw new ACubeSDKError('SDK_NOT_INITIALIZED', 'SDKManager not initialized. Call initialize() first.');
-        }
-    }
-}
-SDKManager.instance = null;
-
-const RECEIPT_READY = 'ready';
-const RECEIPT_SENT = 'sent';
-const RECEIPT_SORT_DESCENDING = 'descending';
-const RECEIPT_SORT_ASCENDING = 'ascending';
-
-const log = createPrefixedLogger('CACHE-HANDLER');
-class CacheHandler {
-    constructor(cache, networkMonitor) {
-        this.cache = cache;
-        this.networkMonitor = networkMonitor;
-        this.currentOnlineState = true;
-        this.setupNetworkMonitoring();
-    }
-    setupNetworkMonitoring() {
-        if (this.networkMonitor) {
-            this.networkSubscription = this.networkMonitor.online$.subscribe((online) => {
-                this.currentOnlineState = online;
-            });
-        }
-    }
-    isOnline() {
-        if (this.networkMonitor) {
-            return this.currentOnlineState;
-        }
-        if (typeof navigator !== 'undefined' && 'onLine' in navigator) {
-            return navigator.onLine;
-        }
-        return false;
-    }
-    async handleCachedRequest(url, requestFn, config) {
-        if (!this.cache || config?.useCache === false) {
-            const response = await requestFn();
-            return response.data;
-        }
-        const cacheKey = this.generateCacheKey(url);
-        const online = this.isOnline();
-        log.debug('Request:', { url, cacheKey, online });
-        if (online) {
-            try {
-                const response = await requestFn();
-                if (this.cache) {
-                    await this.cache.set(cacheKey, response.data).catch((error) => {
-                        log.error('Failed to cache:', error instanceof Error ? error.message : error);
-                    });
-                }
-                return response.data;
-            }
-            catch (error) {
-                const cached = await this.cache.get(cacheKey).catch(() => null);
-                if (cached) {
-                    log.debug('Network failed, using cache fallback');
-                    return cached.data;
-                }
-                throw error;
-            }
-        }
-        else {
-            const cached = await this.cache.get(cacheKey).catch(() => null);
-            if (cached) {
-                log.debug('Offline, returning cached data');
-                return cached.data;
-            }
-            throw new Error('Offline: No cached data available');
-        }
+        return this.appStateService.warning$;
     }
-    generateCacheKey(url) {
-        return url;
+    /**
+     * Observable stream of telemetry state (data, isLoading, isCached, error)
+     */
+    get telemetryState$() {
+        this.ensureInitialized();
+        return this.telemetryService.state$;
     }
-    async invalidateCache(pattern) {
-        if (!this.cache)
-            return;
+    /**
+     * Get the pemId from the installed certificate
+     */
+    async getPemId() {
+        this.ensureInitialized();
         try {
-            await this.cache.invalidate(pattern);
+            const certInfo = await this.sdk.getCertificatesInfo();
+            return certInfo?.pemId ?? null;
         }
-        catch (error) {
-            log.error('Invalidation failed:', error instanceof Error ? error.message : error);
+        catch {
+            return null;
         }
     }
-    getCacheStatus() {
-        return {
-            available: !!this.cache,
-            networkMonitorAvailable: !!this.networkMonitor,
-            isOnline: this.isOnline(),
-        };
-    }
-    destroy() {
-        this.networkSubscription?.unsubscribe();
-    }
-}
-
-function transformError(error) {
-    if (axios.isAxiosError(error)) {
-        const response = error.response;
-        if (!response) {
-            return new ACubeSDKError('NETWORK_ERROR', 'Network error occurred', error);
-        }
-        const status = response.status;
-        const data = response.data;
-        const violations = data?.violations;
-        let message = 'Unknown error occurred';
-        if (data?.detail) {
-            message = data.detail;
-        }
-        else if (data?.title) {
-            message = data.title;
-        }
-        else if (error.message) {
-            message = error.message;
-        }
-        switch (status) {
-            case 400:
-                return new ACubeSDKError('VALIDATION_ERROR', message, error, status, violations);
-            case 401:
-                return new ACubeSDKError('AUTH_ERROR', message, error, status, violations);
-            case 403:
-                return new ACubeSDKError('FORBIDDEN_ERROR', message, error, status, violations);
-            case 404:
-                return new ACubeSDKError('NOT_FOUND_ERROR', message, error, status, violations);
-            case 422:
-                return new ACubeSDKError('VALIDATION_ERROR', message, error, status, violations);
-            default:
-                return new ACubeSDKError('UNKNOWN_ERROR', message, error, status, violations);
+    /**
+     * Start polling telemetry using the pemId from installed certificate
+     * Returns the pemId if successful, null if no certificate is installed
+     */
+    async startTelemetryPollingAuto() {
+        this.ensureInitialized();
+        const pemId = await this.getPemId();
+        if (pemId) {
+            this.telemetryService.startPolling(pemId);
         }
+        return pemId;
     }
-    return new ACubeSDKError('UNKNOWN_ERROR', 'Unknown error occurred', error);
-}
-
-var ErrorCategory;
-(function (ErrorCategory) {
-    ErrorCategory["SERVER_ERROR"] = "SERVER_ERROR";
-    ErrorCategory["CLIENT_ERROR"] = "CLIENT_ERROR";
-    ErrorCategory["AUTH_ERROR"] = "AUTH_ERROR";
-    ErrorCategory["CERTIFICATE_ERROR"] = "CERTIFICATE_ERROR";
-    ErrorCategory["NETWORK_ERROR"] = "NETWORK_ERROR";
-    ErrorCategory["UNKNOWN_ERROR"] = "UNKNOWN_ERROR";
-})(ErrorCategory || (ErrorCategory = {}));
-function extractStatusCode(error) {
-    if (error instanceof MTLSError && error.statusCode) {
-        return error.statusCode;
-    }
-    const errorObj = error;
-    if (errorObj?.response?.status) {
-        return errorObj.response.status;
-    }
-    if (typeof errorObj?.statusCode === 'number') {
-        return errorObj.statusCode;
-    }
-    return undefined;
-}
-function classifyError(error) {
-    const statusCode = extractStatusCode(error);
-    const errorMessage = error instanceof Error ? error.message : String(error);
-    if (statusCode && statusCode >= 500 && statusCode < 600) {
-        return {
-            category: ErrorCategory.SERVER_ERROR,
-            statusCode,
-            message: errorMessage,
-            shouldRetry: false,
-            userMessage: `Server error (${statusCode}): The server encountered an error.`,
-        };
-    }
-    if (statusCode === 401 || statusCode === 403) {
-        return {
-            category: ErrorCategory.AUTH_ERROR,
-            statusCode,
-            message: errorMessage,
-            shouldRetry: false,
-            userMessage: `Authentication error (${statusCode}): Invalid credentials or insufficient permissions.`,
-        };
-    }
-    if (statusCode && statusCode >= 400 && statusCode < 500) {
-        return {
-            category: ErrorCategory.CLIENT_ERROR,
-            statusCode,
-            message: errorMessage,
-            shouldRetry: false,
-            userMessage: `Request error (${statusCode}): ${errorMessage}`,
-        };
+    /**
+     * Start polling telemetry for a specific PEM
+     */
+    startTelemetryPolling(pemId) {
+        this.ensureInitialized();
+        this.telemetryService.startPolling(pemId);
     }
-    if (error instanceof MTLSError) {
-        return {
-            category: ErrorCategory.CERTIFICATE_ERROR,
-            statusCode,
-            message: errorMessage,
-            shouldRetry: true,
-            userMessage: 'Certificate error: Unable to establish secure connection.',
-        };
+    /**
+     * Stop telemetry polling
+     */
+    stopTelemetryPolling() {
+        this.ensureInitialized();
+        this.telemetryService.stopPolling();
     }
-    if (!statusCode &&
-        (errorMessage.toLowerCase().includes('network') ||
-            errorMessage.toLowerCase().includes('timeout') ||
-            errorMessage.toLowerCase().includes('connection'))) {
+    /**
+     * Get simplified services for product use
+     */
+    getServices() {
+        this.ensureInitialized();
+        const sdk = this.sdk;
+        const telemetryService = this.telemetryService;
         return {
-            category: ErrorCategory.NETWORK_ERROR,
-            message: errorMessage,
-            shouldRetry: true,
-            userMessage: 'Network error: Unable to connect to server.',
+            receipts: sdk.receipts,
+            merchants: sdk.merchants,
+            cashiers: sdk.cashiers,
+            cashRegisters: sdk.cashRegisters,
+            pointOfSales: sdk.pointOfSales,
+            suppliers: sdk.suppliers,
+            pems: sdk.pems,
+            dailyReports: sdk.dailyReports,
+            journals: sdk.journals,
+            telemetry: {
+                startPollingAuto: () => this.startTelemetryPollingAuto(),
+                startPolling: (pemId) => telemetryService.startPolling(pemId),
+                stopPolling: () => telemetryService.stopPolling(),
+                getTelemetry: (pemId) => telemetryService.getTelemetry(pemId),
+                refreshTelemetry: (pemId) => telemetryService.refreshTelemetry(pemId),
+                triggerSync: () => telemetryService.triggerSync(),
+                clearTelemetry: () => telemetryService.clearTelemetry(),
+                getPemId: () => this.getPemId(),
+            },
+            login: (credentials) => sdk.login(credentials),
+            logout: () => sdk.logout(),
+            getCurrentUser: () => sdk.getCurrentUser(),
+            isAuthenticated: () => sdk.isAuthenticated(),
+            storeCertificate: (certificate, privateKey, options) => sdk.storeCertificate(certificate, privateKey, options),
+            hasCertificate: () => sdk.hasCertificate(),
+            clearCertificate: () => sdk.clearCertificate(),
+            isOnline: () => sdk.isOnline(),
         };
     }
-    return {
-        category: ErrorCategory.UNKNOWN_ERROR,
-        statusCode,
-        message: errorMessage,
-        shouldRetry: false,
-        userMessage: `Unexpected error: ${errorMessage}`,
-    };
-}
-function shouldReconfigureCertificate(error) {
-    const classification = classifyError(error);
-    return classification.category === ErrorCategory.CERTIFICATE_ERROR;
-}
-function shouldRetryRequest(error, isRetryAttempt) {
-    if (isRetryAttempt) {
-        return false;
+    /**
+     * Manually trigger a notification sync
+     */
+    async syncNotifications() {
+        this.ensureInitialized();
+        await this.notificationService.triggerSync();
     }
-    const classification = classifyError(error);
-    return classification.shouldRetry;
-}
-function getUserFriendlyMessage(error) {
-    const classification = classifyError(error);
-    return classification.userMessage;
-}
-
-// Enum options arrays
-const VAT_RATE_CODE_OPTIONS = [
-    '4.00',
-    '5.00',
-    '10.00',
-    '22.00',
-    '2.00',
-    '6.40',
-    '7.00',
-    '7.30',
-    '7.50',
-    '7.65',
-    '7.95',
-    '8.30',
-    '8.50',
-    '8.80',
-    '9.50',
-    '12.30',
-    'N1',
-    'N2',
-    'N3',
-    'N4',
-    'N5',
-    'N6',
-];
-const GOOD_OR_SERVICE_OPTIONS = ['goods', 'service'];
-const RECEIPT_PROOF_TYPE_OPTIONS = ['POS', 'VR', 'ND'];
-// Enum types for receipt validation
-const VatRateCodeSchema = z.enum(VAT_RATE_CODE_OPTIONS);
-const GoodOrServiceSchema = z.enum(GOOD_OR_SERVICE_OPTIONS);
-const ReceiptProofTypeSchema = z.enum(RECEIPT_PROOF_TYPE_OPTIONS);
-// Receipt Item Schema
-const ReceiptItemSchema = z.object({
-    type: GoodOrServiceSchema.optional(),
-    quantity: z.string().min(1, { error: 'fieldIsRequired' }),
-    description: z.string().min(1, { error: 'fieldIsRequired' }),
-    unit_price: z.string().min(1, { error: 'fieldIsRequired' }),
-    vat_rate_code: VatRateCodeSchema.optional(),
-    simplified_vat_allocation: z.boolean().optional(),
-    discount: z.string().nullable().optional(),
-    is_down_payment_or_voucher_redemption: z.boolean().optional(),
-    complimentary: z.boolean().optional(),
-});
-// Main Receipt Input Schema
-const ReceiptInputSchema = z
-    .object({
-    items: z.array(ReceiptItemSchema).min(1, { error: 'arrayMin1' }),
-    customer_tax_code: z.string().optional(),
-    customer_lottery_code: z.string().optional(),
-    discount: z.string().nullable().optional(),
-    invoice_issuing: z.boolean().optional(),
-    uncollected_dcr_to_ssn: z.boolean().optional(),
-    services_uncollected_amount: z.string().nullable().optional(),
-    goods_uncollected_amount: z.string().nullable().optional(),
-    cash_payment_amount: z.string().nullable().optional(),
-    electronic_payment_amount: z.string().nullable().optional(),
-    ticket_restaurant_payment_amount: z.string().nullable().optional(),
-    ticket_restaurant_quantity: z.number().optional(),
-})
-    .refine((data) => {
-    // At least one payment method should be provided
-    const hasCashPayment = data.cash_payment_amount && parseFloat(data.cash_payment_amount) > 0;
-    const hasElectronicPayment = data.electronic_payment_amount && parseFloat(data.electronic_payment_amount) > 0;
-    const hasTicketPayment = data.ticket_restaurant_payment_amount &&
-        parseFloat(data.ticket_restaurant_payment_amount) > 0;
-    return hasCashPayment || hasElectronicPayment || hasTicketPayment;
-}, {
-    error: 'At least one payment method is required',
-    path: ['payment_methods'],
-})
-    .refine((data) => {
-    // only one between customer_tax_code and customer_lottery_code can be provided
-    return !data.customer_tax_code || !data.customer_lottery_code;
-}, {
-    error: 'Only one between customer_tax_code and customer_lottery_code can be provided',
-    path: ['customer_tax_code', 'customer_lottery_code'],
-});
-// Receipt Return or Void via PEM Schema
-const ReceiptReturnOrVoidViaPEMInputSchema = z.object({
-    device_id: z.string().optional(),
-    items: z.array(ReceiptItemSchema).min(1, { error: 'arrayMin1' }),
-    document_number: z.string().min(1, { error: 'fieldIsRequired' }),
-    document_datetime: z.string().optional(),
-    lottery_code: z.string().optional(),
-});
-// Receipt Return or Void with Proof Schema
-const ReceiptReturnOrVoidWithProofInputSchema = z.object({
-    items: z.array(ReceiptItemSchema).min(1, { error: 'arrayMin1' }),
-    proof: ReceiptProofTypeSchema,
-    document_datetime: z.string().min(1, { error: 'fieldIsRequired' }),
-});
-// Void Receipt Schema
-const VoidReceiptInputSchema = z.object({
-    document_number: z.string().min(1, { error: 'fieldIsRequired' }),
-});
-const ReceiptReturnItemSchema = z
-    .array(z.object({
-    id: z.number(),
-    quantity: z.string().min(1, { error: 'fieldIsRequired' }),
-}))
-    .min(1, { error: 'arrayMin1' });
-// Receipt Return Schema
-const ReceiptReturnInputSchema = z.object({
-    items: z.array(ReceiptReturnItemSchema).min(1, { error: 'arrayMin1' }),
-    document_number: z.string().min(1, { error: 'fieldIsRequired' }),
-});
-
-// Cashier Create Input Schema (MF1)
-const CashierCreateInputSchema = z.object({
-    email: z
-        .string()
-        .min(1, { error: 'fieldIsRequired' })
-        .max(255, { error: 'emailMaxLength' })
-        .email({ error: 'invalidEmail' }),
-    password: z
-        .string()
-        .min(8, { error: 'passwordMinLength' })
-        .max(40, { error: 'passwordMaxLength' }),
-    name: z.string().min(1, { error: 'fieldIsRequired' }).max(255, { error: 'nameMaxLength' }),
-    display_name: z
-        .string()
-        .min(1, { error: 'fieldIsRequired' })
-        .max(255, { error: 'displayNameMaxLength' }),
-});
-
-// Enum options arrays
-const PEM_STATUS_OPTIONS = [
-    'NEW',
-    'REGISTERED',
-    'ACTIVATED',
-    'ONLINE',
-    'OFFLINE',
-    'DISCARDED',
-];
-// Address Schema (reusable)
-const AddressSchema = z.object({
-    street_address: z.string().min(1, { error: 'fieldIsRequired' }),
-    street_number: z.string().min(1, { error: 'fieldIsRequired' }),
-    zip_code: z
-        .string()
-        .min(1, { error: 'fieldIsRequired' })
-        .regex(/^\d{5}$/, { error: 'invalidZipCode' }),
-    city: z.string().min(1, { error: 'fieldIsRequired' }),
-    province: z
-        .string()
-        .min(2, { error: 'provinceMinLength' })
-        .max(2, { error: 'provinceMaxLength' })
-        .toUpperCase(),
-});
-// PEM Status Schema
-const PEMStatusSchema = z.enum(PEM_STATUS_OPTIONS);
-// Activation Request Schema
-const ActivationRequestSchema = z.object({
-    registration_key: z.string().min(1, { error: 'fieldIsRequired' }),
-});
-// PEM Status Offline Request Schema
-const PEMStatusOfflineRequestSchema = z.object({
-    timestamp: z
-        .string()
-        .min(1, { error: 'fieldIsRequired' })
-        .refine((val) => !isNaN(Date.parse(val)), {
-        error: 'invalidDateFormat',
-    }),
-    reason: z.string().min(1, { error: 'fieldIsRequired' }),
-});
+    /**
+     * Manually trigger a telemetry sync
+     */
+    async syncTelemetry() {
+        this.ensureInitialized();
+        return this.telemetryService.triggerSync();
+    }
+    /**
+     * Check if the manager is initialized
+     */
+    getIsInitialized() {
+        return this.isInitialized;
+    }
+    /**
+     * Get the underlying SDK instance (for advanced use cases)
+     */
+    getSDK() {
+        this.ensureInitialized();
+        return this.sdk;
+    }
+    cleanup() {
+        this.notificationService?.destroy();
+        this.telemetryService?.destroy();
+        this.appStateService?.destroy();
+        this.sdk?.destroy();
+        this.notificationService = null;
+        this.telemetryService = null;
+        this.appStateService = null;
+        this.sdk = null;
+        this.isInitialized = false;
+        this.isPollingActive = false;
+    }
+    ensureInitialized() {
+        if (!this.isInitialized) {
+            throw new ACubeSDKError('SDK_NOT_INITIALIZED', 'SDKManager not initialized. Call initialize() first.');
+        }
+    }
+}
+SDKManager.instance = null;
 
-// Cash Register Create Schema
-const CashRegisterCreateSchema = z.object({
-    pem_serial_number: z.string().min(1, { error: 'fieldIsRequired' }),
-    name: z.string().min(1, { error: 'fieldIsRequired' }).max(100, { error: 'nameMaxLength' }),
-});
+const RECEIPT_READY = 'ready';
+const RECEIPT_SENT = 'sent';
+const RECEIPT_SORT_DESCENDING = 'descending';
+const RECEIPT_SORT_ASCENDING = 'ascending';
 
-// VAT number validation regex (Partita IVA - 11 digits)
-const VAT_NUMBER_REGEX = /^\d{11}$/;
-// Fiscal code validation regex (Codice Fiscale - 11 digits only for merchants)
-const FISCAL_CODE_REGEX = /^\d{11}$/;
-// Password validation regex (from OpenAPI spec)
-const PASSWORD_REGEX = /^((?=.*[A-Z])(?=.*[a-z])(?=.*[0-9])(?=.*[!@#$%^&*])(?=.{10,}).*)$/;
-// Merchant Create Input Schema
-const MerchantCreateInputSchema = z
-    .object({
-    vat_number: z
-        .string()
-        .min(1, { error: 'fieldIsRequired' })
-        .regex(VAT_NUMBER_REGEX, { error: 'invalidVatNumber' }),
-    fiscal_code: z.string().regex(FISCAL_CODE_REGEX, { error: 'invalidFiscalCode' }).optional(),
-    business_name: z.string().max(200, { error: 'businessNameMaxLength' }).optional().nullable(),
-    first_name: z.string().max(100, { error: 'firstNameMaxLength' }).optional().nullable(),
-    last_name: z.string().max(100, { error: 'lastNameMaxLength' }).optional().nullable(),
-    email: z.string().min(1, { error: 'fieldIsRequired' }).email({ error: 'invalidEmail' }),
-    password: z
-        .string()
-        .min(1, { error: 'fieldIsRequired' })
-        .regex(PASSWORD_REGEX, { error: 'passwordComplexity' }),
-    address: AddressSchema.optional(),
-})
-    .refine((data) => {
-    const hasBusinessName = data.business_name && data.business_name.trim() !== '';
-    const hasPersonalNames = (data.first_name && data.first_name.trim() !== '') ||
-        (data.last_name && data.last_name.trim() !== '');
-    // If business name is set, first/last name must not be provided
-    if (hasBusinessName && hasPersonalNames) {
-        return false;
+const log = createPrefixedLogger('CACHE-HANDLER');
+class CacheHandler {
+    constructor(cache, networkMonitor) {
+        this.cache = cache;
+        this.networkMonitor = networkMonitor;
+        this.currentOnlineState = true;
+        this.setupNetworkMonitoring();
     }
-    // At least one naming method must be provided
-    if (!hasBusinessName && !hasPersonalNames) {
+    setupNetworkMonitoring() {
+        if (this.networkMonitor) {
+            this.networkSubscription = this.networkMonitor.online$.subscribe((online) => {
+                this.currentOnlineState = online;
+            });
+        }
+    }
+    isOnline() {
+        if (this.networkMonitor) {
+            return this.currentOnlineState;
+        }
+        if (typeof navigator !== 'undefined' && 'onLine' in navigator) {
+            return navigator.onLine;
+        }
         return false;
     }
-    return true;
-}, {
-    error: 'businessNameOrPersonalNamesRequired',
-    path: ['business_name'],
-});
-// Merchant Update Input Schema
-const MerchantUpdateInputSchema = z.object({
-    business_name: z.string().max(200, { error: 'businessNameMaxLength' }).optional().nullable(),
-    first_name: z.string().max(100, { error: 'firstNameMaxLength' }).optional().nullable(),
-    last_name: z.string().max(100, { error: 'lastNameMaxLength' }).optional().nullable(),
-    address: AddressSchema.optional().nullable(),
-});
-
-// Enum options arrays
-const PEM_TYPE_OPTIONS = ['AP', 'SP', 'TM', 'PV'];
-// PEM Data Schema
-const PemDataSchema = z.object({
-    version: z.string().min(1, { error: 'fieldIsRequired' }),
-    type: z.enum(PEM_TYPE_OPTIONS, {
-        error: 'invalidPemType',
-    }),
-});
-// PEM Create Input Schema
-const PemCreateInputSchema = z.object({
-    merchant_uuid: z.string().min(1, { error: 'fieldIsRequired' }).uuid({ error: 'invalidUuid' }),
-    address: AddressSchema.optional(),
-    /* external_pem_data: PemDataSchema.optional(), */
-});
-
-// Italian Fiscal ID validation regex (Codice Fiscale for individuals or Partita IVA for companies)
-const FISCAL_ID_REGEX = /^([A-Z]{6}[0-9LMNPQRSTUV]{2}[ABCDEHLMPRST][0-9LMNPQRSTUV]{2}[A-Z][0-9LMNPQRSTUV]{3}[A-Z]|[0-9]{11})$/;
-// Supplier Create Input Schema
-const SupplierCreateInputSchema = z.object({
-    fiscal_id: z
-        .string()
-        .min(1, { error: 'fieldIsRequired' })
-        .regex(FISCAL_ID_REGEX, { error: 'invalidFiscalId' })
-        .toUpperCase(),
-    name: z.string().min(1, { error: 'fieldIsRequired' }).max(200, { error: 'nameMaxLength' }),
-    address: AddressSchema.optional(),
-});
-// Supplier Update Input Schema
-const SupplierUpdateInputSchema = z.object({
-    name: z.string().min(1, { error: 'fieldIsRequired' }).max(200, { error: 'nameMaxLength' }),
-    address: AddressSchema.optional(),
-});
-
-// Journal Close Input Schema
-const JournalCloseInputSchema = z.object({
-    closing_timestamp: z
-        .string()
-        .min(1, { error: 'fieldIsRequired' })
-        .refine((val) => !isNaN(Date.parse(val)), {
-        error: 'invalidDateFormat',
-    }),
-    reason: z.string().max(255, { error: 'reasonMaxLength' }).optional(),
-});
-
-// Daily Report Status Options
-const DAILY_REPORT_STATUS_OPTIONS = ['pending', 'sent', 'error'];
-// Daily Report Status Schema
-const DailyReportStatusSchema = z.enum(DAILY_REPORT_STATUS_OPTIONS, {
-    error: 'invalidDailyReportStatus',
-});
-// Daily Reports List Parameters Schema
-const DailyReportsParamsSchema = z.object({
-    pem_serial_number: z.string().min(1, { error: 'fieldIsRequired' }).optional(),
-    date_from: z
-        .string()
-        .refine((val) => !isNaN(Date.parse(val)), {
-        error: 'invalidDateFormat',
-    })
-        .optional(),
-    date_to: z
-        .string()
-        .refine((val) => !isNaN(Date.parse(val)), {
-        error: 'invalidDateFormat',
-    })
-        .optional(),
-    status: DailyReportStatusSchema.optional(),
-    page: z.number().min(1, { error: 'pageMinValue' }).optional(),
-});
-
-const NotificationScopeSchema = z.object({
-    type: z.literal('global'),
-});
-const PemStatusSchema = z.enum(['ONLINE', 'OFFLINE']);
-const NotificationDataBlockAtSchema = z.object({
-    block_at: z.string(),
-});
-const NotificationDataPemStatusSchema = z.object({
-    from: PemStatusSchema,
-    to: PemStatusSchema,
-});
-const NotificationBaseSchema = z.object({
-    uuid: z.string().uuid({ error: 'invalidUuid' }),
-    scope: NotificationScopeSchema,
-    source: z.enum(['system', 'Italian Tax Authority']),
-    level: z.enum(['info', 'warning', 'error', 'critical']),
-    created_at: z.string(),
-});
-const NotificationMf2UnreachableSchema = NotificationBaseSchema.extend({
-    type: z.literal('INTERNAL_COMMUNICATION_FAILURE'),
-    code: z.literal('SYS-W-01'),
-    data: NotificationDataBlockAtSchema,
-});
-const NotificationPemsBlockedSchema = NotificationBaseSchema.extend({
-    type: z.literal('PEM_STATUS_CHANGED'),
-    code: z.literal('SYS-C-01'),
-    data: NotificationDataPemStatusSchema,
-});
-const NotificationPemBackOnlineSchema = NotificationBaseSchema.extend({
-    type: z.literal('PEM_STATUS_CHANGED'),
-    code: z.literal('SYS-I-01'),
-    data: NotificationDataPemStatusSchema,
-});
-const NotificationSchema = z.discriminatedUnion('code', [
-    NotificationMf2UnreachableSchema,
-    NotificationPemsBlockedSchema,
-    NotificationPemBackOnlineSchema,
-]);
-const NotificationListResponseSchema = z.object({
-    members: z.array(NotificationSchema),
-});
+    async handleCachedRequest(url, requestFn, config) {
+        if (!this.cache || config?.useCache === false) {
+            const response = await requestFn();
+            return response.data;
+        }
+        const cacheKey = this.generateCacheKey(url);
+        const online = this.isOnline();
+        log.debug('Request:', { url, cacheKey, online });
+        if (online) {
+            try {
+                const response = await requestFn();
+                if (this.cache) {
+                    await this.cache.set(cacheKey, response.data).catch((error) => {
+                        log.error('Failed to cache:', error instanceof Error ? error.message : error);
+                    });
+                }
+                return response.data;
+            }
+            catch (error) {
+                const cached = await this.cache.get(cacheKey).catch(() => null);
+                if (cached) {
+                    log.debug('Network failed, using cache fallback');
+                    return cached.data;
+                }
+                throw error;
+            }
+        }
+        else {
+            const cached = await this.cache.get(cacheKey).catch(() => null);
+            if (cached) {
+                log.debug('Offline, returning cached data');
+                return cached.data;
+            }
+            throw new Error('Offline: No cached data available');
+        }
+    }
+    generateCacheKey(url) {
+        return url;
+    }
+    async invalidateCache(pattern) {
+        if (!this.cache)
+            return;
+        try {
+            await this.cache.invalidate(pattern);
+        }
+        catch (error) {
+            log.error('Invalidation failed:', error instanceof Error ? error.message : error);
+        }
+    }
+    getCacheStatus() {
+        return {
+            available: !!this.cache,
+            networkMonitorAvailable: !!this.networkMonitor,
+            isOnline: this.isOnline(),
+        };
+    }
+    destroy() {
+        this.networkSubscription?.unsubscribe();
+    }
+}
 
-const TelemetryMerchantSchema = z.object({
-    vat_number: z.string(),
-    fiscal_code: z.string().nullable(),
-    business_name: z.string(),
-});
-const TelemetrySupplierSchema = z.object({
-    vat_number: z.string(),
-    fiscal_code: z.string().nullable(),
-    business_name: z.string(),
-});
-const TelemetrySoftwareVersionSchema = z.object({
-    version: z.string(),
-    swid: z.string(),
-    installed_at: z.string(),
-    status: z.enum(['active', 'inactive', 'archived']),
-});
-const TelemetrySoftwareSchema = z.object({
-    code: z.string(),
-    name: z.string(),
-    approval_reference: z.string(),
-    version_info: TelemetrySoftwareVersionSchema,
-});
-const PendingReceiptsSchema = z.object({
-    count: z.number().int().nonnegative(),
-    total_amount: z.string(),
-});
-const TransmissionSchema = z.object({
-    attempted_at: z.string(),
-    outcome: z.enum(['success', 'failed', 'pending']),
-});
-const MessageSchema = z.object({
-    received_at: z.string(),
-    content: z.string(),
-});
-const LotterySecretRequestSchema = z.object({
-    requested_at: z.string(),
-    outcome: z.enum(['success', 'failed', 'pending']),
-});
-const LotterySchema = z.object({
-    last_transmission: TransmissionSchema,
-    secret_request: LotterySecretRequestSchema,
-});
-const TelemetrySchema = z.object({
-    pem_id: z.string(),
-    pem_status: z.enum(['ONLINE', 'OFFLINE', 'ERROR']),
-    pem_status_changed_at: z.string(),
-    merchant: TelemetryMerchantSchema,
-    supplier: TelemetrySupplierSchema,
-    software: TelemetrySoftwareSchema,
-    last_communication_at: z.string(),
-    pending_receipts: PendingReceiptsSchema,
-    last_receipt_transmission: TransmissionSchema,
-    last_message_from_mf2: MessageSchema,
-    ade_corrispettivi_transmission: TransmissionSchema,
-    last_message_from_ade: MessageSchema,
-    lottery: LotterySchema,
-});
+function transformError(error) {
+    if (axios.isAxiosError(error)) {
+        const response = error.response;
+        if (!response) {
+            return new ACubeSDKError('NETWORK_ERROR', 'Network error occurred', error);
+        }
+        const status = response.status;
+        const data = response.data;
+        const violations = data?.violations;
+        let message = 'Unknown error occurred';
+        if (data?.detail) {
+            message = data.detail;
+        }
+        else if (data?.title) {
+            message = data.title;
+        }
+        else if (error.message) {
+            message = error.message;
+        }
+        switch (status) {
+            case 400:
+                return new ACubeSDKError('VALIDATION_ERROR', message, error, status, violations);
+            case 401:
+                return new ACubeSDKError('AUTH_ERROR', message, error, status, violations);
+            case 403:
+                return new ACubeSDKError('FORBIDDEN_ERROR', message, error, status, violations);
+            case 404:
+                return new ACubeSDKError('NOT_FOUND_ERROR', message, error, status, violations);
+            case 422:
+                return new ACubeSDKError('VALIDATION_ERROR', message, error, status, violations);
+            default:
+                return new ACubeSDKError('UNKNOWN_ERROR', message, error, status, violations);
+        }
+    }
+    return new ACubeSDKError('UNKNOWN_ERROR', 'Unknown error occurred', error);
+}
 
-// Receipt schemas and types
-// Common validation utilities
-const ValidationMessages = {
-    fieldIsRequired: 'This field is required',
-    arrayMin1: 'At least one item is required',
-    paymentMethodRequired: 'At least one payment method is required',
-    invalidEmail: 'Please enter a valid email address',
-    passwordMinLength: 'Password must be at least 8 characters long',
-    passwordComplexity: 'Password must contain at least one uppercase letter, one lowercase letter, one number, and one special character',
-    invalidZipCode: 'Please enter a valid 5-digit zip code',
-    provinceMinLength: 'Province code must be 2 characters',
-    provinceMaxLength: 'Province code must be 2 characters',
-    invalidDateFormat: 'Please enter a valid date',
-    nameMaxLength: 'Name is too long',
-    invalidFiscalId: 'Please enter a valid Italian fiscal ID (Codice Fiscale or Partita IVA)',
-    invalidVatNumber: 'Please enter a valid VAT number (11 digits)',
-    invalidFiscalCode: 'Please enter a valid fiscal code (11 digits)',
-    businessNameMaxLength: 'Business name is too long (max 200 characters)',
-    businessNameOrPersonalNamesRequired: 'Please provide either a business name or first/last name, but not both',
-    firstNameMaxLength: 'First name is too long (max 100 characters)',
-    lastNameMaxLength: 'Last name is too long (max 100 characters)',
-    invalidUuid: 'Please enter a valid UUID',
-    invalidPemType: 'PEM type must be one of: AP, SP, TM, PV',
-    reasonMaxLength: 'Reason is too long (max 255 characters)',
-    pageMinValue: 'Page number must be at least 1',
-    invalidDailyReportStatus: 'Daily report status must be one of: pending, sent, error',
-    displayNameMaxLength: 'Display name is too long (max 255 characters)',
-};
-// Validation helper functions
-const validateInput = (schema, data) => {
-    const result = schema.safeParse(data);
-    if (!result.success) {
-        const errors = result.error.issues.map((error) => ({
-            field: error.path.join('.'),
-            message: error.message,
-            code: error.code,
-        }));
+var ErrorCategory;
+(function (ErrorCategory) {
+    ErrorCategory["SERVER_ERROR"] = "SERVER_ERROR";
+    ErrorCategory["CLIENT_ERROR"] = "CLIENT_ERROR";
+    ErrorCategory["AUTH_ERROR"] = "AUTH_ERROR";
+    ErrorCategory["CERTIFICATE_ERROR"] = "CERTIFICATE_ERROR";
+    ErrorCategory["NETWORK_ERROR"] = "NETWORK_ERROR";
+    ErrorCategory["UNKNOWN_ERROR"] = "UNKNOWN_ERROR";
+})(ErrorCategory || (ErrorCategory = {}));
+function extractStatusCode(error) {
+    if (error instanceof MTLSError && error.statusCode) {
+        return error.statusCode;
+    }
+    const errorObj = error;
+    if (errorObj?.response?.status) {
+        return errorObj.response.status;
+    }
+    if (typeof errorObj?.statusCode === 'number') {
+        return errorObj.statusCode;
+    }
+    return undefined;
+}
+function classifyError(error) {
+    const statusCode = extractStatusCode(error);
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    if (statusCode && statusCode >= 500 && statusCode < 600) {
         return {
-            success: false,
-            errors,
-            data: null,
+            category: ErrorCategory.SERVER_ERROR,
+            statusCode,
+            message: errorMessage,
+            shouldRetry: false,
+            userMessage: `Server error (${statusCode}): The server encountered an error.`,
+        };
+    }
+    if (statusCode === 401 || statusCode === 403) {
+        return {
+            category: ErrorCategory.AUTH_ERROR,
+            statusCode,
+            message: errorMessage,
+            shouldRetry: false,
+            userMessage: `Authentication error (${statusCode}): Invalid credentials or insufficient permissions.`,
+        };
+    }
+    if (statusCode && statusCode >= 400 && statusCode < 500) {
+        return {
+            category: ErrorCategory.CLIENT_ERROR,
+            statusCode,
+            message: errorMessage,
+            shouldRetry: false,
+            userMessage: `Request error (${statusCode}): ${errorMessage}`,
+        };
+    }
+    if (error instanceof MTLSError) {
+        return {
+            category: ErrorCategory.CERTIFICATE_ERROR,
+            statusCode,
+            message: errorMessage,
+            shouldRetry: true,
+            userMessage: 'Certificate error: Unable to establish secure connection.',
+        };
+    }
+    if (!statusCode &&
+        (errorMessage.toLowerCase().includes('network') ||
+            errorMessage.toLowerCase().includes('timeout') ||
+            errorMessage.toLowerCase().includes('connection'))) {
+        return {
+            category: ErrorCategory.NETWORK_ERROR,
+            message: errorMessage,
+            shouldRetry: true,
+            userMessage: 'Network error: Unable to connect to server.',
         };
     }
     return {
-        success: true,
-        errors: [],
-        data: result.data,
+        category: ErrorCategory.UNKNOWN_ERROR,
+        statusCode,
+        message: errorMessage,
+        shouldRetry: false,
+        userMessage: `Unexpected error: ${errorMessage}`,
     };
-};
+}
+function shouldReconfigureCertificate(error) {
+    const classification = classifyError(error);
+    return classification.category === ErrorCategory.CERTIFICATE_ERROR;
+}
+function shouldRetryRequest(error, isRetryAttempt) {
+    if (isRetryAttempt) {
+        return false;
+    }
+    const classification = classifyError(error);
+    return classification.shouldRetry;
+}
+function getUserFriendlyMessage(error) {
+    const classification = classifyError(error);
+    return classification.userMessage;
+}
 
 var MTLSErrorType;
 (function (MTLSErrorType) {