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

package/dist/index.cjs.js

@@ -2,8 +2,8 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var axios = require('axios');
 var z = require('zod');
+var axios = require('axios');
 
 function _interopNamespaceDefault(e) {
     var n = Object.create(null);
@@ -1415,6 +1415,15 @@ function from(input, scheduler) {
     return scheduler ? scheduled(input, scheduler) : innerFrom(input);
 }
 
+function of() {
+    var args = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+        args[_i] = arguments[_i];
+    }
+    var scheduler = popScheduler(args);
+    return from(args, scheduler);
+}
+
 function isValidDate(value) {
     return value instanceof Date && !isNaN(value);
 }
@@ -1861,131 +1870,436 @@ 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) {
+    // 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$h = 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$h.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$h.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$h.debug('getCurrentUser: No token in storage');
+            if (this.userSubject.value) {
+                this.userSubject.next(null);
+                this.authStateSubject.next('idle');
+            }
+            return null;
+        }
+        log$h.debug('getCurrentUser: Token found', {
+            tokenPrefix: token.substring(0, 30) + '...',
+            tokenLength: token.length,
+        });
+        const jwtPayload = parseJwt(token);
+        if (isTokenExpired(jwtPayload)) {
+            // Token expired - clear everything
+            log$h.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$h.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$h.debug('isAuthenticated: No token in storage');
+            return false;
+        }
+        const jwtPayload = parseJwt(token);
+        const expired = isTokenExpired(jwtPayload);
+        log$h.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');
@@ -2080,406 +2394,677 @@ 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__namespace.enum(VAT_RATE_CODE_OPTIONS);
+const GoodOrServiceSchema = z__namespace.enum(GOOD_OR_SERVICE_OPTIONS);
+const ReceiptProofTypeSchema = z__namespace.enum(RECEIPT_PROOF_TYPE_OPTIONS);
+// Receipt Item Schema
+const ReceiptItemSchema = z__namespace.object({
+    type: GoodOrServiceSchema.optional(),
+    quantity: z__namespace.string().min(1, { error: 'fieldIsRequired' }),
+    description: z__namespace.string().min(1, { error: 'fieldIsRequired' }),
+    unit_price: z__namespace.string().min(1, { error: 'fieldIsRequired' }),
+    vat_rate_code: VatRateCodeSchema.optional(),
+    simplified_vat_allocation: z__namespace.boolean().optional(),
+    discount: z__namespace.string().nullable().optional(),
+    is_down_payment_or_voucher_redemption: z__namespace.boolean().optional(),
+    complimentary: z__namespace.boolean().optional(),
+});
+// Main Receipt Input Schema
+const ReceiptInputSchema = z__namespace
+    .object({
+    items: z__namespace.array(ReceiptItemSchema).min(1, { error: 'arrayMin1' }),
+    customer_tax_code: z__namespace.string().optional(),
+    customer_lottery_code: z__namespace.string().optional(),
+    discount: z__namespace.string().nullable().optional(),
+    invoice_issuing: z__namespace.boolean().optional(),
+    uncollected_dcr_to_ssn: z__namespace.boolean().optional(),
+    services_uncollected_amount: z__namespace.string().nullable().optional(),
+    goods_uncollected_amount: z__namespace.string().nullable().optional(),
+    cash_payment_amount: z__namespace.string().nullable().optional(),
+    electronic_payment_amount: z__namespace.string().nullable().optional(),
+    ticket_restaurant_payment_amount: z__namespace.string().nullable().optional(),
+    ticket_restaurant_quantity: z__namespace.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__namespace.object({
+    device_id: z__namespace.string().optional(),
+    items: z__namespace.array(ReceiptItemSchema).min(1, { error: 'arrayMin1' }),
+    document_number: z__namespace.string().min(1, { error: 'fieldIsRequired' }),
+    document_datetime: z__namespace.string().optional(),
+    lottery_code: z__namespace.string().optional(),
+});
+// Receipt Return or Void with Proof Schema
+const ReceiptReturnOrVoidWithProofInputSchema = z__namespace.object({
+    items: z__namespace.array(ReceiptItemSchema).min(1, { error: 'arrayMin1' }),
+    proof: ReceiptProofTypeSchema,
+    document_datetime: z__namespace.string().min(1, { error: 'fieldIsRequired' }),
+});
+// Void Receipt Schema
+const VoidReceiptInputSchema = z__namespace.object({
+    document_number: z__namespace.string().min(1, { error: 'fieldIsRequired' }),
+});
+const ReceiptReturnItemSchema = z__namespace
+    .array(z__namespace.object({
+    id: z__namespace.number(),
+    quantity: z__namespace.string().min(1, { error: 'fieldIsRequired' }),
+}))
+    .min(1, { error: 'arrayMin1' });
+// Receipt Return Schema
+const ReceiptReturnInputSchema = z__namespace.object({
+    items: z__namespace.array(ReceiptReturnItemSchema).min(1, { error: 'arrayMin1' }),
+    document_number: z__namespace.string().min(1, { error: 'fieldIsRequired' }),
+});
+
+// Cashier Create Input Schema (MF1)
+const CashierCreateInputSchema = z__namespace.object({
+    email: z__namespace
+        .string()
+        .min(1, { error: 'fieldIsRequired' })
+        .max(255, { error: 'emailMaxLength' })
+        .email({ error: 'invalidEmail' }),
+    password: z__namespace
+        .string()
+        .min(8, { error: 'passwordMinLength' })
+        .max(40, { error: 'passwordMaxLength' }),
+    name: z__namespace.string().min(1, { error: 'fieldIsRequired' }).max(255, { error: 'nameMaxLength' }),
+    display_name: z__namespace
+        .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__namespace.object({
+    street_address: z__namespace.string().min(1, { error: 'fieldIsRequired' }),
+    street_number: z__namespace.string().min(1, { error: 'fieldIsRequired' }),
+    zip_code: z__namespace
+        .string()
+        .min(1, { error: 'fieldIsRequired' })
+        .regex(/^\d{5}$/, { error: 'invalidZipCode' }),
+    city: z__namespace.string().min(1, { error: 'fieldIsRequired' }),
+    province: z__namespace
+        .string()
+        .min(2, { error: 'provinceMinLength' })
+        .max(2, { error: 'provinceMaxLength' })
+        .toUpperCase(),
+});
+// PEM Status Schema
+const PEMStatusSchema = z__namespace.enum(PEM_STATUS_OPTIONS);
+// Activation Request Schema
+const ActivationRequestSchema = z__namespace.object({
+    registration_key: z__namespace.string().min(1, { error: 'fieldIsRequired' }),
+});
+// PEM Status Offline Request Schema
+const PEMStatusOfflineRequestSchema = z__namespace.object({
+    timestamp: z__namespace
+        .string()
+        .min(1, { error: 'fieldIsRequired' })
+        .refine((val) => !isNaN(Date.parse(val)), {
+        error: 'invalidDateFormat',
+    }),
+    reason: z__namespace.string().min(1, { error: 'fieldIsRequired' }),
+});
+
+// Cash Register Create Schema
+const CashRegisterCreateSchema = z__namespace.object({
+    pem_serial_number: z__namespace.string().min(1, { error: 'fieldIsRequired' }),
+    name: z__namespace.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__namespace
+    .object({
+    vat_number: z__namespace
+        .string()
+        .min(1, { error: 'fieldIsRequired' })
+        .regex(VAT_NUMBER_REGEX, { error: 'invalidVatNumber' }),
+    fiscal_code: z__namespace.string().regex(FISCAL_CODE_REGEX, { error: 'invalidFiscalCode' }).optional(),
+    business_name: z__namespace.string().max(200, { error: 'businessNameMaxLength' }).optional().nullable(),
+    first_name: z__namespace.string().max(100, { error: 'firstNameMaxLength' }).optional().nullable(),
+    last_name: z__namespace.string().max(100, { error: 'lastNameMaxLength' }).optional().nullable(),
+    email: z__namespace.string().min(1, { error: 'fieldIsRequired' }).email({ error: 'invalidEmail' }),
+    password: z__namespace
+        .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__namespace.object({
+    business_name: z__namespace.string().max(200, { error: 'businessNameMaxLength' }).optional().nullable(),
+    first_name: z__namespace.string().max(100, { error: 'firstNameMaxLength' }).optional().nullable(),
+    last_name: z__namespace.string().max(100, { error: 'lastNameMaxLength' }).optional().nullable(),
+    address: AddressSchema.optional().nullable(),
+});
 
-function getDefaultExportFromCjs (x) {
-	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
-}
+// Enum options arrays
+const PEM_TYPE_OPTIONS = ['AP', 'SP', 'TM', 'PV'];
+// PEM Data Schema
+const PemDataSchema = z__namespace.object({
+    version: z__namespace.string().min(1, { error: 'fieldIsRequired' }),
+    type: z__namespace.enum(PEM_TYPE_OPTIONS, {
+        error: 'invalidPemType',
+    }),
+});
+// PEM Create Input Schema
+const PemCreateInputSchema = z__namespace.object({
+    merchant_uuid: z__namespace.string().min(1, { error: 'fieldIsRequired' }).uuid({ error: 'invalidUuid' }),
+    address: AddressSchema.optional(),
+    /* external_pem_data: PemDataSchema.optional(), */
+});
 
-var picocolors_browser = {exports: {}};
+// 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__namespace.object({
+    fiscal_id: z__namespace
+        .string()
+        .min(1, { error: 'fieldIsRequired' })
+        .regex(FISCAL_ID_REGEX, { error: 'invalidFiscalId' })
+        .toUpperCase(),
+    name: z__namespace.string().min(1, { error: 'fieldIsRequired' }).max(200, { error: 'nameMaxLength' }),
+    address: AddressSchema.optional(),
+});
+// Supplier Update Input Schema
+const SupplierUpdateInputSchema = z__namespace.object({
+    name: z__namespace.string().min(1, { error: 'fieldIsRequired' }).max(200, { error: 'nameMaxLength' }),
+    address: AddressSchema.optional(),
+});
 
-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;
+// Journal Close Input Schema
+const JournalCloseInputSchema = z__namespace.object({
+    closing_timestamp: z__namespace
+        .string()
+        .min(1, { error: 'fieldIsRequired' })
+        .refine((val) => !isNaN(Date.parse(val)), {
+        error: 'invalidDateFormat',
+    }),
+    reason: z__namespace.string().max(255, { error: 'reasonMaxLength' }).optional(),
+});
 
-var picocolors_browserExports = picocolors_browser.exports;
-var pc = /*@__PURE__*/getDefaultExportFromCjs(picocolors_browserExports);
+// Daily Report Status Options
+const DAILY_REPORT_STATUS_OPTIONS = ['pending', 'sent', 'error'];
+// Daily Report Status Schema
+const DailyReportStatusSchema = z__namespace.enum(DAILY_REPORT_STATUS_OPTIONS, {
+    error: 'invalidDailyReportStatus',
+});
+// Daily Reports List Parameters Schema
+const DailyReportsParamsSchema = z__namespace.object({
+    pem_serial_number: z__namespace.string().min(1, { error: 'fieldIsRequired' }).optional(),
+    date_from: z__namespace
+        .string()
+        .refine((val) => !isNaN(Date.parse(val)), {
+        error: 'invalidDateFormat',
+    })
+        .optional(),
+    date_to: z__namespace
+        .string()
+        .refine((val) => !isNaN(Date.parse(val)), {
+        error: 'invalidDateFormat',
+    })
+        .optional(),
+    status: DailyReportStatusSchema.optional(),
+    page: z__namespace.number().min(1, { error: 'pageMinValue' }).optional(),
+});
+
+const NotificationScopeSchema = z__namespace.object({
+    type: z__namespace.literal('global'),
+});
+const PemStatusSchema = z__namespace.enum(['ONLINE', 'OFFLINE']);
+const NotificationDataBlockAtSchema = z__namespace.object({
+    block_at: z__namespace.string(),
+});
+const NotificationDataPemStatusSchema = z__namespace.object({
+    from: PemStatusSchema,
+    to: PemStatusSchema,
+});
+const NotificationBaseSchema = z__namespace.object({
+    uuid: z__namespace.string().uuid({ error: 'invalidUuid' }),
+    scope: NotificationScopeSchema,
+    source: z__namespace.enum(['system', 'Italian Tax Authority']),
+    level: z__namespace.enum(['info', 'warning', 'error', 'critical']),
+    created_at: z__namespace.string(),
+});
+const NotificationMf2UnreachableSchema = NotificationBaseSchema.extend({
+    type: z__namespace.literal('INTERNAL_COMMUNICATION_FAILURE'),
+    code: z__namespace.literal('SYS-W-01'),
+    data: NotificationDataBlockAtSchema,
+});
+const NotificationPemsBlockedSchema = NotificationBaseSchema.extend({
+    type: z__namespace.literal('PEM_STATUS_CHANGED'),
+    code: z__namespace.literal('SYS-C-01'),
+    data: NotificationDataPemStatusSchema,
+});
+const NotificationPemBackOnlineSchema = NotificationBaseSchema.extend({
+    type: z__namespace.literal('PEM_STATUS_CHANGED'),
+    code: z__namespace.literal('SYS-I-01'),
+    data: NotificationDataPemStatusSchema,
+});
+const NotificationSchema = z__namespace.discriminatedUnion('code', [
+    NotificationMf2UnreachableSchema,
+    NotificationPemsBlockedSchema,
+    NotificationPemBackOnlineSchema,
+]);
+const NotificationListResponseSchema = z__namespace.object({
+    members: z__namespace.array(NotificationSchema),
+});
+
+const TelemetryMerchantSchema = z__namespace.object({
+    vat_number: z__namespace.string(),
+    fiscal_code: z__namespace.string().nullable(),
+    business_name: z__namespace.string(),
+});
+const TelemetrySupplierSchema = z__namespace.object({
+    vat_number: z__namespace.string(),
+    fiscal_code: z__namespace.string().nullable(),
+    business_name: z__namespace.string(),
+});
+const TelemetrySoftwareVersionSchema = z__namespace.object({
+    version: z__namespace.string(),
+    swid: z__namespace.string(),
+    installed_at: z__namespace.string(),
+    status: z__namespace.enum(['active', 'inactive', 'archived']),
+});
+const TelemetrySoftwareSchema = z__namespace.object({
+    code: z__namespace.string(),
+    name: z__namespace.string(),
+    approval_reference: z__namespace.string(),
+    version_info: TelemetrySoftwareVersionSchema,
+});
+const PendingReceiptsSchema = z__namespace.object({
+    count: z__namespace.number().int().nonnegative(),
+    total_amount: z__namespace.string(),
+});
+const TransmissionSchema = z__namespace.object({
+    attempted_at: z__namespace.string(),
+    outcome: z__namespace.enum(['success', 'failed', 'pending']),
+});
+const MessageSchema = z__namespace.object({
+    received_at: z__namespace.string(),
+    content: z__namespace.string(),
+});
+const LotterySecretRequestSchema = z__namespace.object({
+    requested_at: z__namespace.string(),
+    outcome: z__namespace.enum(['success', 'failed', 'pending']),
+});
+const LotterySchema = z__namespace.object({
+    last_transmission: TransmissionSchema,
+    secret_request: LotterySecretRequestSchema,
+});
+const TelemetrySchema = z__namespace.object({
+    pem_id: z__namespace.string(),
+    pem_status: z__namespace.enum(['ONLINE', 'OFFLINE', 'ERROR']),
+    pem_status_changed_at: z__namespace.string(),
+    merchant: TelemetryMerchantSchema,
+    supplier: TelemetrySupplierSchema,
+    software: TelemetrySoftwareSchema,
+    last_communication_at: z__namespace.string(),
+    pending_receipts: PendingReceiptsSchema,
+    last_receipt_transmission: TransmissionSchema,
+    last_message_from_mf2: MessageSchema,
+    ade_corrispettivi_transmission: TransmissionSchema,
+    last_message_from_ade: MessageSchema,
+    lottery: LotterySchema,
+});
 
-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: '❌',
+// 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)',
 };
-/**
- * Format data for pretty display in logs
- */
-function formatData(data, level) {
-    if (data === undefined || data === null) {
-        return String(data);
-    }
-    // For primitive types, just return as string
-    if (typeof data !== 'object') {
-        return String(data);
+// 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,
+        };
     }
-    // For Error objects, format nicely
-    if (data instanceof Error) {
-        return `${data.name}: ${data.message}${data.stack ? `\n${pc.dim(data.stack)}` : ''}`;
+    return {
+        success: true,
+        errors: [],
+        data: result.data,
+    };
+};
+
+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;
     }
-    try {
-        // Apply level-specific coloring
-        const colors = levelColors[level];
-        return colors.data(JSON.stringify(data, null, 2));
+}
+
+const log$g = createPrefixedLogger('AUTH-STRATEGY');
+class AuthStrategy {
+    constructor(jwtHandler, mtlsHandler, userProvider, mtlsAdapter) {
+        this.jwtHandler = jwtHandler;
+        this.mtlsHandler = mtlsHandler;
+        this.userProvider = userProvider;
+        this.mtlsAdapter = mtlsAdapter;
     }
-    catch {
-        // Fallback to JSON.stringify if pretty-format fails
-        try {
-            return JSON.stringify(data, null, 2);
+    async determineAuthConfig(url, method, explicitMode) {
+        if (this.isNotificationEndpoint(url) || this.isTelemetryEndpoint(url)) {
+            return { mode: 'mtls', usePort444: true };
         }
-        catch {
-            return String(data);
+        const platform = this.detectPlatform();
+        const userRole = await this.getUserRole();
+        const isReceiptEndpoint = this.isReceiptEndpoint(url);
+        log$g.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 };
     }
-}
-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);
+    async getAuthHeaders() {
+        return this.jwtHandler.getAuthHeaders();
     }
-    info(prefix, message, data) {
-        if (!this.enabled)
-            return;
-        this.log('info', prefix, message, data);
+    getMtlsHandler() {
+        return this.mtlsHandler;
     }
-    warn(prefix, message, data) {
-        this.log('warn', prefix, message, data);
+    getJwtHandler() {
+        return this.jwtHandler;
     }
-    error(prefix, message, data) {
-        this.log('error', prefix, message, data);
+    detectPlatform() {
+        if (!this.mtlsAdapter) {
+            return 'web';
+        }
+        const platformInfo = this.mtlsAdapter.getPlatformInfo();
+        return platformInfo.platform === 'web' ? 'web' : 'mobile';
     }
-    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);
-            }
+    async getUserRole() {
+        if (!this.userProvider) {
+            return null;
         }
-        else {
-            consoleMethod(header);
+        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;
+    }
+    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$/));
+    }
+    isNotificationEndpoint(url) {
+        return url.includes('/mf1/notifications');
+    }
+    isTelemetryEndpoint(url) {
+        return !!url.match(/\/mf1\/pems\/[^/]+\/telemetry/);
     }
-}
-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);
+class JwtAuthHandler {
+    constructor(tokenStorage) {
+        this.tokenStorage = tokenStorage;
+    }
+    async getAuthConfig(_url, _method) {
+        return { mode: 'jwt', usePort444: false };
+    }
+    async getAuthHeaders() {
+        const token = await this.tokenStorage.getAccessToken();
+        if (!token) {
+            return {};
+        }
+        return { Authorization: `Bearer ${token}` };
+    }
 }
 
 const log$f = createPrefixedLogger('MTLS-HANDLER');
@@ -6012,92 +6597,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'),
@@ -7523,7 +8022,11 @@ class CachingHttpDecorator {
         return response;
     }
     setAuthToken(token) {
-        log$3.debug('Auth token updated:', { hasToken: !!token });
+        log$3.debug('CachingHttpDecorator.setAuthToken called:', {
+            hasToken: !!token,
+            tokenPrefix: token?.substring(0, 20),
+            underlyingHttpType: this.http.constructor.name,
+        });
         this.authToken = token;
         this.http.setAuthToken(token);
     }
@@ -7556,7 +8059,8 @@ class CachingHttpDecorator {
     }
 }
 
-const log$2 = createPrefixedLogger('HTTP-MTLS');
+const logJwt = createPrefixedLogger('HTTP-JWT');
+const logMtls = createPrefixedLogger('HTTP-MTLS');
 class AxiosHttpAdapter {
     constructor(config) {
         this.authToken = null;
@@ -7574,23 +8078,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) {
@@ -7603,10 +8114,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,
@@ -7615,15 +8126,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,
@@ -7632,11 +8143,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;
@@ -7651,36 +8162,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);
         });
@@ -7750,7 +8271,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() {
@@ -7906,7 +8430,7 @@ class SDKFactory {
     }
 }
 
-const log$1 = createPrefixedLogger('SDK');
+const log$2 = createPrefixedLogger('SDK');
 class ACubeSDK {
     constructor(config, customAdapters, events = {}) {
         this.events = events;
@@ -7920,22 +8444,22 @@ class ACubeSDK {
     }
     async initialize() {
         if (this.isInitialized) {
-            log$1.debug('SDK already initialized, skipping');
+            log$2.debug('SDK already initialized, skipping');
             return;
         }
-        log$1.info('Initializing SDK', {
+        log$2.info('Initializing SDK', {
             apiUrl: this.config.getApiUrl(),
             authUrl: this.config.getAuthUrl(),
             debugEnabled: this.config.isDebugEnabled(),
         });
         try {
             if (!this.adapters) {
-                log$1.debug('Loading platform adapters');
+                log$2.debug('Loading platform adapters');
                 const mtlsConfig = createACubeMTLSConfig(this.config.getApiUrl(), this.config.getTimeout(), true);
                 this.adapters = loadPlatformAdapters({
                     mtlsConfig,
                 });
-                log$1.info('Platform adapters loaded', {
+                log$2.info('Platform adapters loaded', {
                     hasCache: !!this.adapters.cache,
                     hasNetworkMonitor: !!this.adapters.networkMonitor,
                     hasMtls: !!this.adapters.mtls,
@@ -7948,25 +8472,30 @@ class ACubeSDK {
                 timeout: this.config.getTimeout(),
                 debugEnabled: this.config.isDebugEnabled(),
             };
-            log$1.debug('Creating DI container');
+            log$2.debug('Creating DI container');
             this.container = SDKFactory.createContainer(factoryConfig);
-            log$1.debug('Registering auth services');
+            log$2.debug('Registering auth services');
             SDKFactory.registerAuthServices(this.container, this.adapters.secureStorage, factoryConfig);
             if (this.adapters.cache) {
-                log$1.info('Registering cache services', {
+                log$2.info('Registering cache services', {
                     hasNetworkMonitor: !!this.adapters.networkMonitor,
                 });
                 SDKFactory.registerCacheServices(this.container, this.adapters.cache, this.adapters.networkMonitor);
             }
             else {
-                log$1.debug('No cache adapter available, caching disabled');
+                log$2.debug('No cache adapter available, caching disabled');
             }
-            log$1.debug('Initializing certificate service');
+            log$2.debug('Initializing certificate service');
             this.certificateService = new CertificateService(this.adapters.secureStorage);
             const tokenStorage = this.container.get(DI_TOKENS.TOKEN_STORAGE_PORT);
             const httpPort = this.container.get(DI_TOKENS.HTTP_PORT);
             const baseHttpPort = this.container.get(DI_TOKENS.BASE_HTTP_PORT);
-            log$1.debug('Initializing authentication service');
+            log$2.debug('HTTP ports initialized', {
+                httpPortType: httpPort.constructor.name,
+                baseHttpPortType: baseHttpPort.constructor.name,
+                areSameInstance: httpPort === baseHttpPort,
+            });
+            log$2.debug('Initializing authentication service');
             this.authService = new AuthenticationService(httpPort, tokenStorage, {
                 authUrl: this.config.getAuthUrl(),
                 timeout: this.config.getTimeout(),
@@ -7976,7 +8505,7 @@ class ACubeSDK {
                     this.events.onAuthError?.(new ACubeSDKError('AUTH_ERROR', error.message, error));
                 },
             });
-            log$1.debug('Initializing offline manager');
+            log$2.debug('Initializing offline manager');
             const queueEvents = {
                 onOperationAdded: (operation) => {
                     this.events.onOfflineOperationAdded?.(operation.id);
@@ -7998,19 +8527,29 @@ class ACubeSDK {
                     this.offlineManager.sync().catch(() => { });
                 }
             });
-            if (await this.authService.isAuthenticated()) {
+            const isAuth = await this.authService.isAuthenticated();
+            log$2.debug('Checking authentication status during init', { isAuthenticated: isAuth });
+            if (isAuth) {
                 const token = await this.authService.getAccessToken();
+                log$2.debug('Token retrieved during init', {
+                    hasToken: !!token,
+                    tokenPrefix: token?.substring(0, 20),
+                });
                 if (token) {
                     httpPort.setAuthToken(token);
+                    log$2.info('Auth token set on HTTP port during initialization');
                 }
             }
+            else {
+                log$2.warn('User not authenticated during SDK init - token will be set after login');
+            }
             if (this.adapters?.mtls && 'setMTLSAdapter' in baseHttpPort) {
-                log$1.debug('Connecting mTLS adapter to HTTP port');
+                log$2.debug('Connecting mTLS adapter to HTTP port');
                 const httpWithMtls = baseHttpPort;
                 httpWithMtls.setMTLSAdapter(this.adapters.mtls);
             }
             if ('setAuthStrategy' in baseHttpPort) {
-                log$1.debug('Configuring auth strategy');
+                log$2.debug('Configuring auth strategy');
                 const jwtHandler = new JwtAuthHandler(tokenStorage);
                 const certificatePort = this.certificateService
                     ? {
@@ -8059,19 +8598,19 @@ class ACubeSDK {
                     }
                 }
                 catch (certError) {
-                    log$1.warn('Certificate auto-configuration failed, will retry on demand', {
+                    log$2.warn('Certificate auto-configuration failed, will retry on demand', {
                         error: certError instanceof Error ? certError.message : certError,
                     });
                 }
             }
             this.isInitialized = true;
-            log$1.info('SDK initialized successfully', {
+            log$2.info('SDK initialized successfully', {
                 hasCache: !!this.adapters.cache,
                 hasMtls: !!this.adapters.mtls,
             });
         }
         catch (error) {
-            log$1.error('SDK initialization failed', {
+            log$2.error('SDK initialization failed', {
                 error: error instanceof Error ? error.message : error,
             });
             throw new ACubeSDKError('SDK_INITIALIZATION_ERROR', `Failed to initialize SDK: ${error instanceof Error ? error.message : 'Unknown error'}`, error);
@@ -8127,19 +8666,19 @@ class ACubeSDK {
     }
     async login(credentials) {
         this.ensureInitialized();
-        log$1.info('Login attempt', { email: credentials.email });
+        log$2.info('Login attempt', { email: credentials.email });
         const user = await this.authService.login(credentials);
-        log$1.info('Login successful', { roles: user.roles });
+        log$2.info('Login successful', { roles: user.roles });
         const token = await this.authService.getAccessToken();
         if (token) {
             this.httpPort.setAuthToken(token);
-            log$1.debug('Auth token set on HTTP port');
+            log$2.debug('Auth token set on HTTP port');
         }
         return user;
     }
     async logout() {
         this.ensureInitialized();
-        log$1.info('Logout');
+        log$2.info('Logout');
         await this.authService.logout();
         this.httpPort.setAuthToken(null);
     }
@@ -8313,6 +8852,7 @@ const INITIAL_STATE = {
         remainingMs: 0,
     },
     lastNotification: null,
+    certificateMissing: false,
 };
 class AppStateService {
     get state$() {
@@ -8327,28 +8867,33 @@ class AppStateService {
     get warning$() {
         return this.state$.pipe(map((s) => s.warning), distinctUntilChanged((a, b) => a.active === b.active && a.remainingMs === b.remainingMs));
     }
-    constructor(notifications$, networkPort) {
+    get certificateMissing$() {
+        return this.state$.pipe(map((s) => s.certificateMissing), distinctUntilChanged());
+    }
+    constructor(notifications$, networkPort, certificateMissingInput$ = of(false)) {
         this.notifications$ = notifications$;
         this.networkPort = networkPort;
+        this.certificateMissingInput$ = certificateMissingInput$;
         this.stateSubject = new BehaviorSubject(INITIAL_STATE);
         this.destroy$ = new Subject();
         this.warningTimerId = null;
         this.setupSubscriptions();
     }
     setupSubscriptions() {
-        combineLatest([this.notifications$, this.networkPort.online$])
+        combineLatest([this.notifications$, this.networkPort.online$, this.certificateMissingInput$])
             .pipe(takeUntil(this.destroy$))
-            .subscribe(([notifications, isOnline]) => {
-            this.processState(notifications, isOnline);
+            .subscribe(([notifications, isOnline, certificateMissing]) => {
+            this.processState(notifications, isOnline, certificateMissing);
         });
     }
-    processState(notifications, isOnline) {
+    processState(notifications, isOnline, certificateMissing) {
         if (!isOnline) {
             this.updateState({
                 mode: 'OFFLINE',
                 isOnline: false,
                 warning: { active: false, blockAt: null, remainingMs: 0 },
                 lastNotification: null,
+                certificateMissing,
             });
             this.stopWarningTimer();
             return;
@@ -8410,6 +8955,7 @@ class AppStateService {
             isOnline: true,
             warning: warningState,
             lastNotification,
+            certificateMissing,
         });
     }
     getLatestNotificationByCode(notifications) {
@@ -8675,6 +9221,7 @@ class TelemetryService {
     }
 }
 
+const log$1 = createPrefixedLogger('SDK-MANAGER');
 /**
  * SDKManager - Singleton wrapper for ACubeSDK with simplified API
  *
@@ -8725,6 +9272,7 @@ class SDKManager {
         this.appStateService = null;
         this.isInitialized = false;
         this.isPollingActive = false;
+        this.certificateMissingSubject = new BehaviorSubject(false);
         /**
          * Handle user state changes (login/logout/token expiration)
          * Manages polling lifecycle based on user role
@@ -8735,9 +9283,14 @@ class SDKManager {
             if (!this.isInitialized)
                 return;
             if (user) {
-                // User logged in - check role and start polling if allowed
+                // User logged in - check role and certificate before starting polling
                 const canPoll = hasAnyRole(user.roles, ['ROLE_MERCHANT', 'ROLE_CASHIER']);
                 if (canPoll && !this.isPollingActive) {
+                    const hasCert = await this.checkCertificate();
+                    if (!hasCert) {
+                        log$1.warn('Certificate missing — polling blocked until certificate is installed');
+                        return;
+                    }
                     this.notificationService?.startPolling();
                     await this.startTelemetryPollingAuto();
                     this.isPollingActive = true;
@@ -8751,6 +9304,7 @@ class SDKManager {
                     this.telemetryService?.clearTelemetry();
                     this.isPollingActive = false;
                 }
+                this.certificateMissingSubject.next(false);
             }
         };
     }
@@ -8817,7 +9371,7 @@ class SDKManager {
         this.telemetryService = new TelemetryService(telemetryRepo, networkPort, {
             pollIntervalMs: this.config.telemetryPollIntervalMs ?? 60000,
         });
-        this.appStateService = new AppStateService(this.notificationService.notifications$, networkPort);
+        this.appStateService = new AppStateService(this.notificationService.notifications$, networkPort, this.certificateMissingSubject.asObservable());
         if (this.events?.onAppStateChanged) {
             this.appStateService.state$.subscribe(this.events.onAppStateChanged);
         }
@@ -8829,9 +9383,15 @@ class SDKManager {
         const user = await this.sdk.getCurrentUser();
         const canPoll = user && hasAnyRole(user.roles, ['ROLE_MERCHANT', 'ROLE_CASHIER']);
         if (canPoll) {
-            this.notificationService.startPolling();
-            await this.startTelemetryPollingAuto();
-            this.isPollingActive = true;
+            const hasCert = await this.checkCertificate();
+            if (hasCert) {
+                this.notificationService.startPolling();
+                await this.startTelemetryPollingAuto();
+                this.isPollingActive = true;
+            }
+            else {
+                log$1.warn('Certificate missing at init — polling blocked until certificate is installed');
+            }
         }
         // AppStateService remains active for all users (handles OFFLINE network state)
     }
@@ -8844,820 +9404,429 @@ class SDKManager {
         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(),
-        };
+     * Observable stream of app mode only
+     * Emits AppMode with distinctUntilChanged
+     */
+    get mode$() {
+        this.ensureInitialized();
+        return this.appStateService.mode$;
     }
     /**
-     * Manually trigger a notification sync
+     * Observable stream indicating if app is blocked
      */
-    async syncNotifications() {
+    get isBlocked$() {
         this.ensureInitialized();
-        await this.notificationService.triggerSync();
+        return this.appStateService.isBlocked$;
     }
     /**
-     * Manually trigger a telemetry sync
+     * Observable stream of warning state with countdown
      */
-    async syncTelemetry() {
+    get warning$() {
         this.ensureInitialized();
-        return this.telemetryService.triggerSync();
+        return this.appStateService.warning$;
     }
     /**
-     * Check if the manager is initialized
+     * Observable stream indicating if certificate is missing
+     * When true, polling is blocked and the user should install a certificate
      */
-    getIsInitialized() {
-        return this.isInitialized;
+    get certificateMissing$() {
+        return this.certificateMissingSubject.asObservable();
     }
     /**
-     * Get the underlying SDK instance (for advanced use cases)
+     * Observable stream of telemetry state (data, isLoading, isCached, error)
      */
-    getSDK() {
+    get telemetryState$() {
         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');
-        }
-    }
-    generateCacheKey(url) {
-        return url;
+        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);
-}
-
-exports.ErrorCategory = void 0;
-(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";
-})(exports.ErrorCategory || (exports.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: exports.ErrorCategory.SERVER_ERROR,
-            statusCode,
-            message: errorMessage,
-            shouldRetry: false,
-            userMessage: `Server error (${statusCode}): The server encountered an error.`,
-        };
-    }
-    if (statusCode === 401 || statusCode === 403) {
-        return {
-            category: exports.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: exports.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: exports.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: exports.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: async (certificate, privateKey, options) => {
+                await sdk.storeCertificate(certificate, privateKey, options);
+                this.certificateMissingSubject.next(false);
+                // Start polling if user can poll and polling is not active
+                if (!this.isPollingActive) {
+                    const user = await sdk.getCurrentUser();
+                    const canPoll = user && hasAnyRole(user.roles, ['ROLE_MERCHANT', 'ROLE_CASHIER']);
+                    if (canPoll) {
+                        log$1.info('Certificate installed — starting polling');
+                        this.notificationService?.startPolling();
+                        await this.startTelemetryPollingAuto();
+                        this.isPollingActive = true;
+                    }
+                }
+            },
+            hasCertificate: () => sdk.hasCertificate(),
+            clearCertificate: async () => {
+                await sdk.clearCertificate();
+                this.certificateMissingSubject.next(true);
+                // Stop polling since certificate is required
+                if (this.isPollingActive) {
+                    log$1.info('Certificate removed — stopping polling');
+                    this.notificationService?.stopPolling();
+                    this.telemetryService?.stopPolling();
+                    this.telemetryService?.clearTelemetry();
+                    this.isPollingActive = false;
+                }
+            },
+            getCertificate: () => sdk.getCertificate(),
+            getCertificatesInfo: () => sdk.getCertificatesInfo(),
+            notifications: sdk.notifications,
+            isOnline: () => sdk.isOnline(),
         };
     }
-    return {
-        category: exports.ErrorCategory.UNKNOWN_ERROR,
-        statusCode,
-        message: errorMessage,
-        shouldRetry: false,
-        userMessage: `Unexpected error: ${errorMessage}`,
-    };
-}
-function shouldReconfigureCertificate(error) {
-    const classification = classifyError(error);
-    return classification.category === exports.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__namespace.enum(VAT_RATE_CODE_OPTIONS);
-const GoodOrServiceSchema = z__namespace.enum(GOOD_OR_SERVICE_OPTIONS);
-const ReceiptProofTypeSchema = z__namespace.enum(RECEIPT_PROOF_TYPE_OPTIONS);
-// Receipt Item Schema
-const ReceiptItemSchema = z__namespace.object({
-    type: GoodOrServiceSchema.optional(),
-    quantity: z__namespace.string().min(1, { error: 'fieldIsRequired' }),
-    description: z__namespace.string().min(1, { error: 'fieldIsRequired' }),
-    unit_price: z__namespace.string().min(1, { error: 'fieldIsRequired' }),
-    vat_rate_code: VatRateCodeSchema.optional(),
-    simplified_vat_allocation: z__namespace.boolean().optional(),
-    discount: z__namespace.string().nullable().optional(),
-    is_down_payment_or_voucher_redemption: z__namespace.boolean().optional(),
-    complimentary: z__namespace.boolean().optional(),
-});
-// Main Receipt Input Schema
-const ReceiptInputSchema = z__namespace
-    .object({
-    items: z__namespace.array(ReceiptItemSchema).min(1, { error: 'arrayMin1' }),
-    customer_tax_code: z__namespace.string().optional(),
-    customer_lottery_code: z__namespace.string().optional(),
-    discount: z__namespace.string().nullable().optional(),
-    invoice_issuing: z__namespace.boolean().optional(),
-    uncollected_dcr_to_ssn: z__namespace.boolean().optional(),
-    services_uncollected_amount: z__namespace.string().nullable().optional(),
-    goods_uncollected_amount: z__namespace.string().nullable().optional(),
-    cash_payment_amount: z__namespace.string().nullable().optional(),
-    electronic_payment_amount: z__namespace.string().nullable().optional(),
-    ticket_restaurant_payment_amount: z__namespace.string().nullable().optional(),
-    ticket_restaurant_quantity: z__namespace.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__namespace.object({
-    device_id: z__namespace.string().optional(),
-    items: z__namespace.array(ReceiptItemSchema).min(1, { error: 'arrayMin1' }),
-    document_number: z__namespace.string().min(1, { error: 'fieldIsRequired' }),
-    document_datetime: z__namespace.string().optional(),
-    lottery_code: z__namespace.string().optional(),
-});
-// Receipt Return or Void with Proof Schema
-const ReceiptReturnOrVoidWithProofInputSchema = z__namespace.object({
-    items: z__namespace.array(ReceiptItemSchema).min(1, { error: 'arrayMin1' }),
-    proof: ReceiptProofTypeSchema,
-    document_datetime: z__namespace.string().min(1, { error: 'fieldIsRequired' }),
-});
-// Void Receipt Schema
-const VoidReceiptInputSchema = z__namespace.object({
-    document_number: z__namespace.string().min(1, { error: 'fieldIsRequired' }),
-});
-const ReceiptReturnItemSchema = z__namespace
-    .array(z__namespace.object({
-    id: z__namespace.number(),
-    quantity: z__namespace.string().min(1, { error: 'fieldIsRequired' }),
-}))
-    .min(1, { error: 'arrayMin1' });
-// Receipt Return Schema
-const ReceiptReturnInputSchema = z__namespace.object({
-    items: z__namespace.array(ReceiptReturnItemSchema).min(1, { error: 'arrayMin1' }),
-    document_number: z__namespace.string().min(1, { error: 'fieldIsRequired' }),
-});
-
-// Cashier Create Input Schema (MF1)
-const CashierCreateInputSchema = z__namespace.object({
-    email: z__namespace
-        .string()
-        .min(1, { error: 'fieldIsRequired' })
-        .max(255, { error: 'emailMaxLength' })
-        .email({ error: 'invalidEmail' }),
-    password: z__namespace
-        .string()
-        .min(8, { error: 'passwordMinLength' })
-        .max(40, { error: 'passwordMaxLength' }),
-    name: z__namespace.string().min(1, { error: 'fieldIsRequired' }).max(255, { error: 'nameMaxLength' }),
-    display_name: z__namespace
-        .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__namespace.object({
-    street_address: z__namespace.string().min(1, { error: 'fieldIsRequired' }),
-    street_number: z__namespace.string().min(1, { error: 'fieldIsRequired' }),
-    zip_code: z__namespace
-        .string()
-        .min(1, { error: 'fieldIsRequired' })
-        .regex(/^\d{5}$/, { error: 'invalidZipCode' }),
-    city: z__namespace.string().min(1, { error: 'fieldIsRequired' }),
-    province: z__namespace
-        .string()
-        .min(2, { error: 'provinceMinLength' })
-        .max(2, { error: 'provinceMaxLength' })
-        .toUpperCase(),
-});
-// PEM Status Schema
-const PEMStatusSchema = z__namespace.enum(PEM_STATUS_OPTIONS);
-// Activation Request Schema
-const ActivationRequestSchema = z__namespace.object({
-    registration_key: z__namespace.string().min(1, { error: 'fieldIsRequired' }),
-});
-// PEM Status Offline Request Schema
-const PEMStatusOfflineRequestSchema = z__namespace.object({
-    timestamp: z__namespace
-        .string()
-        .min(1, { error: 'fieldIsRequired' })
-        .refine((val) => !isNaN(Date.parse(val)), {
-        error: 'invalidDateFormat',
-    }),
-    reason: z__namespace.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;
+    }
+    /**
+     * Check certificate availability and update certificateMissing state.
+     * Returns true if certificate is available, false otherwise.
+     */
+    async checkCertificate() {
+        try {
+            const hasCert = await this.sdk.hasCertificate();
+            this.certificateMissingSubject.next(!hasCert);
+            return hasCert;
+        }
+        catch {
+            this.certificateMissingSubject.next(true);
+            return false;
+        }
+    }
+    cleanup() {
+        this.notificationService?.destroy();
+        this.telemetryService?.destroy();
+        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__namespace.object({
-    pem_serial_number: z__namespace.string().min(1, { error: 'fieldIsRequired' }),
-    name: z__namespace.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__namespace
-    .object({
-    vat_number: z__namespace
-        .string()
-        .min(1, { error: 'fieldIsRequired' })
-        .regex(VAT_NUMBER_REGEX, { error: 'invalidVatNumber' }),
-    fiscal_code: z__namespace.string().regex(FISCAL_CODE_REGEX, { error: 'invalidFiscalCode' }).optional(),
-    business_name: z__namespace.string().max(200, { error: 'businessNameMaxLength' }).optional().nullable(),
-    first_name: z__namespace.string().max(100, { error: 'firstNameMaxLength' }).optional().nullable(),
-    last_name: z__namespace.string().max(100, { error: 'lastNameMaxLength' }).optional().nullable(),
-    email: z__namespace.string().min(1, { error: 'fieldIsRequired' }).email({ error: 'invalidEmail' }),
-    password: z__namespace
-        .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__namespace.object({
-    business_name: z__namespace.string().max(200, { error: 'businessNameMaxLength' }).optional().nullable(),
-    first_name: z__namespace.string().max(100, { error: 'firstNameMaxLength' }).optional().nullable(),
-    last_name: z__namespace.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__namespace.object({
-    version: z__namespace.string().min(1, { error: 'fieldIsRequired' }),
-    type: z__namespace.enum(PEM_TYPE_OPTIONS, {
-        error: 'invalidPemType',
-    }),
-});
-// PEM Create Input Schema
-const PemCreateInputSchema = z__namespace.object({
-    merchant_uuid: z__namespace.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__namespace.object({
-    fiscal_id: z__namespace
-        .string()
-        .min(1, { error: 'fieldIsRequired' })
-        .regex(FISCAL_ID_REGEX, { error: 'invalidFiscalId' })
-        .toUpperCase(),
-    name: z__namespace.string().min(1, { error: 'fieldIsRequired' }).max(200, { error: 'nameMaxLength' }),
-    address: AddressSchema.optional(),
-});
-// Supplier Update Input Schema
-const SupplierUpdateInputSchema = z__namespace.object({
-    name: z__namespace.string().min(1, { error: 'fieldIsRequired' }).max(200, { error: 'nameMaxLength' }),
-    address: AddressSchema.optional(),
-});
-
-// Journal Close Input Schema
-const JournalCloseInputSchema = z__namespace.object({
-    closing_timestamp: z__namespace
-        .string()
-        .min(1, { error: 'fieldIsRequired' })
-        .refine((val) => !isNaN(Date.parse(val)), {
-        error: 'invalidDateFormat',
-    }),
-    reason: z__namespace.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__namespace.enum(DAILY_REPORT_STATUS_OPTIONS, {
-    error: 'invalidDailyReportStatus',
-});
-// Daily Reports List Parameters Schema
-const DailyReportsParamsSchema = z__namespace.object({
-    pem_serial_number: z__namespace.string().min(1, { error: 'fieldIsRequired' }).optional(),
-    date_from: z__namespace
-        .string()
-        .refine((val) => !isNaN(Date.parse(val)), {
-        error: 'invalidDateFormat',
-    })
-        .optional(),
-    date_to: z__namespace
-        .string()
-        .refine((val) => !isNaN(Date.parse(val)), {
-        error: 'invalidDateFormat',
-    })
-        .optional(),
-    status: DailyReportStatusSchema.optional(),
-    page: z__namespace.number().min(1, { error: 'pageMinValue' }).optional(),
-});
-
-const NotificationScopeSchema = z__namespace.object({
-    type: z__namespace.literal('global'),
-});
-const PemStatusSchema = z__namespace.enum(['ONLINE', 'OFFLINE']);
-const NotificationDataBlockAtSchema = z__namespace.object({
-    block_at: z__namespace.string(),
-});
-const NotificationDataPemStatusSchema = z__namespace.object({
-    from: PemStatusSchema,
-    to: PemStatusSchema,
-});
-const NotificationBaseSchema = z__namespace.object({
-    uuid: z__namespace.string().uuid({ error: 'invalidUuid' }),
-    scope: NotificationScopeSchema,
-    source: z__namespace.enum(['system', 'Italian Tax Authority']),
-    level: z__namespace.enum(['info', 'warning', 'error', 'critical']),
-    created_at: z__namespace.string(),
-});
-const NotificationMf2UnreachableSchema = NotificationBaseSchema.extend({
-    type: z__namespace.literal('INTERNAL_COMMUNICATION_FAILURE'),
-    code: z__namespace.literal('SYS-W-01'),
-    data: NotificationDataBlockAtSchema,
-});
-const NotificationPemsBlockedSchema = NotificationBaseSchema.extend({
-    type: z__namespace.literal('PEM_STATUS_CHANGED'),
-    code: z__namespace.literal('SYS-C-01'),
-    data: NotificationDataPemStatusSchema,
-});
-const NotificationPemBackOnlineSchema = NotificationBaseSchema.extend({
-    type: z__namespace.literal('PEM_STATUS_CHANGED'),
-    code: z__namespace.literal('SYS-I-01'),
-    data: NotificationDataPemStatusSchema,
-});
-const NotificationSchema = z__namespace.discriminatedUnion('code', [
-    NotificationMf2UnreachableSchema,
-    NotificationPemsBlockedSchema,
-    NotificationPemBackOnlineSchema,
-]);
-const NotificationListResponseSchema = z__namespace.object({
-    members: z__namespace.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__namespace.object({
-    vat_number: z__namespace.string(),
-    fiscal_code: z__namespace.string().nullable(),
-    business_name: z__namespace.string(),
-});
-const TelemetrySupplierSchema = z__namespace.object({
-    vat_number: z__namespace.string(),
-    fiscal_code: z__namespace.string().nullable(),
-    business_name: z__namespace.string(),
-});
-const TelemetrySoftwareVersionSchema = z__namespace.object({
-    version: z__namespace.string(),
-    swid: z__namespace.string(),
-    installed_at: z__namespace.string(),
-    status: z__namespace.enum(['active', 'inactive', 'archived']),
-});
-const TelemetrySoftwareSchema = z__namespace.object({
-    code: z__namespace.string(),
-    name: z__namespace.string(),
-    approval_reference: z__namespace.string(),
-    version_info: TelemetrySoftwareVersionSchema,
-});
-const PendingReceiptsSchema = z__namespace.object({
-    count: z__namespace.number().int().nonnegative(),
-    total_amount: z__namespace.string(),
-});
-const TransmissionSchema = z__namespace.object({
-    attempted_at: z__namespace.string(),
-    outcome: z__namespace.enum(['success', 'failed', 'pending']),
-});
-const MessageSchema = z__namespace.object({
-    received_at: z__namespace.string(),
-    content: z__namespace.string(),
-});
-const LotterySecretRequestSchema = z__namespace.object({
-    requested_at: z__namespace.string(),
-    outcome: z__namespace.enum(['success', 'failed', 'pending']),
-});
-const LotterySchema = z__namespace.object({
-    last_transmission: TransmissionSchema,
-    secret_request: LotterySecretRequestSchema,
-});
-const TelemetrySchema = z__namespace.object({
-    pem_id: z__namespace.string(),
-    pem_status: z__namespace.enum(['ONLINE', 'OFFLINE', 'ERROR']),
-    pem_status_changed_at: z__namespace.string(),
-    merchant: TelemetryMerchantSchema,
-    supplier: TelemetrySupplierSchema,
-    software: TelemetrySoftwareSchema,
-    last_communication_at: z__namespace.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,
-        }));
+exports.ErrorCategory = void 0;
+(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";
+})(exports.ErrorCategory || (exports.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: exports.ErrorCategory.SERVER_ERROR,
+            statusCode,
+            message: errorMessage,
+            shouldRetry: false,
+            userMessage: `Server error (${statusCode}): The server encountered an error.`,
+        };
+    }
+    if (statusCode === 401 || statusCode === 403) {
+        return {
+            category: exports.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: exports.ErrorCategory.CLIENT_ERROR,
+            statusCode,
+            message: errorMessage,
+            shouldRetry: false,
+            userMessage: `Request error (${statusCode}): ${errorMessage}`,
+        };
+    }
+    if (error instanceof MTLSError) {
+        return {
+            category: exports.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: exports.ErrorCategory.NETWORK_ERROR,
+            message: errorMessage,
+            shouldRetry: true,
+            userMessage: 'Network error: Unable to connect to server.',
         };
     }
     return {
-        success: true,
-        errors: [],
-        data: result.data,
+        category: exports.ErrorCategory.UNKNOWN_ERROR,
+        statusCode,
+        message: errorMessage,
+        shouldRetry: false,
+        userMessage: `Unexpected error: ${errorMessage}`,
     };
-};
+}
+function shouldReconfigureCertificate(error) {
+    const classification = classifyError(error);
+    return classification.category === exports.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) {