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

package/dist/index.native.js

@@ -1869,27 +1869,6 @@ function clearObject(input) {
     }
     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;
-        }
-    }
-    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
@@ -2112,7 +2091,7 @@ function formatDecimal(value, decimals = 2) {
     return num.toFixed(decimals);
 }
 
-const log$h = createPrefixedLogger('AUTH-SERVICE');
+const log$b = createPrefixedLogger('AUTH-SERVICE');
 class AuthenticationService {
     get user$() {
         return this.userSubject.asObservable();
@@ -2134,7 +2113,7 @@ class AuthenticationService {
     }
     async login(credentials) {
         this.authStateSubject.next('authenticating');
-        log$h.info('Login attempt', {
+        log$b.info('Login attempt', {
             authUrl: this.config.authUrl,
             email: credentials.email,
         });
@@ -2145,7 +2124,7 @@ class AuthenticationService {
             });
             const jwtPayload = parseJwt(response.data.token);
             const expiresAt = jwtPayload.exp * 1000;
-            log$h.info('Login successful', {
+            log$b.info('Login successful', {
                 authUrl: this.config.authUrl,
                 tokenPrefix: response.data.token.substring(0, 30) + '...',
                 expiresAt: new Date(expiresAt).toISOString(),
@@ -2174,21 +2153,21 @@ class AuthenticationService {
         const token = await this.tokenStorage.getAccessToken();
         if (!token) {
             // No token - clear any stale user state
-            log$h.debug('getCurrentUser: No token in storage');
+            log$b.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', {
+        log$b.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');
+            log$b.warn('getCurrentUser: Token expired');
             await this.tokenStorage.clearTokens();
             this.userSubject.next(null);
             this.authStateSubject.next('idle');
@@ -2198,7 +2177,7 @@ class AuthenticationService {
         // Token is valid - return cached user if available
         const currentUser = this.userSubject.value;
         if (currentUser) {
-            log$h.debug('getCurrentUser: Returning cached user', {
+            log$b.debug('getCurrentUser: Returning cached user', {
                 email: currentUser.email,
                 roles: currentUser.roles,
             });
@@ -2221,12 +2200,12 @@ class AuthenticationService {
     async isAuthenticated() {
         const token = await this.tokenStorage.getAccessToken();
         if (!token) {
-            log$h.debug('isAuthenticated: No token in storage');
+            log$b.debug('isAuthenticated: No token in storage');
             return false;
         }
         const jwtPayload = parseJwt(token);
         const expired = isTokenExpired(jwtPayload);
-        log$h.debug('isAuthenticated: Token check', {
+        log$b.debug('isAuthenticated: Token check', {
             hasToken: true,
             expired,
             expiresAt: new Date(jwtPayload.exp * 1000).toISOString(),
@@ -2446,7 +2425,7 @@ class ConfigManager {
     }
 }
 
-// Enum options arrays
+// Enum options arrays (used by consumers for dropdowns and form validation)
 const VAT_RATE_CODE_OPTIONS = [
     '4.00',
     '5.00',
@@ -2473,103 +2452,10 @@ const VAT_RATE_CODE_OPTIONS = [
 ];
 const GOOD_OR_SERVICE_OPTIONS = ['goods', 'service'];
 const RECEIPT_PROOF_TYPE_OPTIONS = ['POS', 'VR', 'ND'];
-// Enum types for receipt validation
+// Enum schemas (used by consumers as building blocks for their own form schemas)
 const VatRateCodeSchema = z.enum(VAT_RATE_CODE_OPTIONS);
 const GoodOrServiceSchema = z.enum(GOOD_OR_SERVICE_OPTIONS);
 const ReceiptProofTypeSchema = z.enum(RECEIPT_PROOF_TYPE_OPTIONS);
-// Receipt Item Schema
-const ReceiptItemSchema = z.object({
-    type: GoodOrServiceSchema.optional(),
-    quantity: z.string().min(1, { error: 'fieldIsRequired' }),
-    description: z.string().min(1, { error: 'fieldIsRequired' }),
-    unit_price: z.string().min(1, { error: 'fieldIsRequired' }),
-    vat_rate_code: VatRateCodeSchema.optional(),
-    simplified_vat_allocation: z.boolean().optional(),
-    discount: z.string().nullable().optional(),
-    is_down_payment_or_voucher_redemption: z.boolean().optional(),
-    complimentary: z.boolean().optional(),
-});
-// Main Receipt Input Schema
-const ReceiptInputSchema = z
-    .object({
-    items: z.array(ReceiptItemSchema).min(1, { error: 'arrayMin1' }),
-    customer_tax_code: z.string().optional(),
-    customer_lottery_code: z.string().optional(),
-    discount: z.string().nullable().optional(),
-    invoice_issuing: z.boolean().optional(),
-    uncollected_dcr_to_ssn: z.boolean().optional(),
-    services_uncollected_amount: z.string().nullable().optional(),
-    goods_uncollected_amount: z.string().nullable().optional(),
-    cash_payment_amount: z.string().nullable().optional(),
-    electronic_payment_amount: z.string().nullable().optional(),
-    ticket_restaurant_payment_amount: z.string().nullable().optional(),
-    ticket_restaurant_quantity: z.number().optional(),
-})
-    .refine((data) => {
-    // At least one payment method should be provided
-    const hasCashPayment = data.cash_payment_amount && parseFloat(data.cash_payment_amount) > 0;
-    const hasElectronicPayment = data.electronic_payment_amount && parseFloat(data.electronic_payment_amount) > 0;
-    const hasTicketPayment = data.ticket_restaurant_payment_amount &&
-        parseFloat(data.ticket_restaurant_payment_amount) > 0;
-    return hasCashPayment || hasElectronicPayment || hasTicketPayment;
-}, {
-    error: 'At least one payment method is required',
-    path: ['payment_methods'],
-})
-    .refine((data) => {
-    // only one between customer_tax_code and customer_lottery_code can be provided
-    return !data.customer_tax_code || !data.customer_lottery_code;
-}, {
-    error: 'Only one between customer_tax_code and customer_lottery_code can be provided',
-    path: ['customer_tax_code', 'customer_lottery_code'],
-});
-// Receipt Return or Void via PEM Schema
-const ReceiptReturnOrVoidViaPEMInputSchema = z.object({
-    device_id: z.string().optional(),
-    items: z.array(ReceiptItemSchema).min(1, { error: 'arrayMin1' }),
-    document_number: z.string().min(1, { error: 'fieldIsRequired' }),
-    document_datetime: z.string().optional(),
-    lottery_code: z.string().optional(),
-});
-// Receipt Return or Void with Proof Schema
-const ReceiptReturnOrVoidWithProofInputSchema = z.object({
-    items: z.array(ReceiptItemSchema).min(1, { error: 'arrayMin1' }),
-    proof: ReceiptProofTypeSchema,
-    document_datetime: z.string().min(1, { error: 'fieldIsRequired' }),
-});
-// Void Receipt Schema
-const VoidReceiptInputSchema = z.object({
-    document_number: z.string().min(1, { error: 'fieldIsRequired' }),
-});
-const ReceiptReturnItemSchema = z
-    .array(z.object({
-    id: z.number(),
-    quantity: z.string().min(1, { error: 'fieldIsRequired' }),
-}))
-    .min(1, { error: 'arrayMin1' });
-// Receipt Return Schema
-const ReceiptReturnInputSchema = z.object({
-    items: z.array(ReceiptReturnItemSchema).min(1, { error: 'arrayMin1' }),
-    document_number: z.string().min(1, { error: 'fieldIsRequired' }),
-});
-
-// Cashier Create Input Schema (MF1)
-const CashierCreateInputSchema = z.object({
-    email: z
-        .string()
-        .min(1, { error: 'fieldIsRequired' })
-        .max(255, { error: 'emailMaxLength' })
-        .email({ error: 'invalidEmail' }),
-    password: z
-        .string()
-        .min(8, { error: 'passwordMinLength' })
-        .max(40, { error: 'passwordMaxLength' }),
-    name: z.string().min(1, { error: 'fieldIsRequired' }).max(255, { error: 'nameMaxLength' }),
-    display_name: z
-        .string()
-        .min(1, { error: 'fieldIsRequired' })
-        .max(255, { error: 'displayNameMaxLength' }),
-});
 
 // Enum options arrays
 const PEM_STATUS_OPTIONS = [
@@ -2580,312 +2466,12 @@ const PEM_STATUS_OPTIONS = [
     'OFFLINE',
     'DISCARDED',
 ];
-// Address Schema (reusable)
-const AddressSchema = z.object({
-    street_address: z.string().min(1, { error: 'fieldIsRequired' }),
-    street_number: z.string().min(1, { error: 'fieldIsRequired' }),
-    zip_code: z
-        .string()
-        .min(1, { error: 'fieldIsRequired' })
-        .regex(/^\d{5}$/, { error: 'invalidZipCode' }),
-    city: z.string().min(1, { error: 'fieldIsRequired' }),
-    province: z
-        .string()
-        .min(2, { error: 'provinceMinLength' })
-        .max(2, { error: 'provinceMaxLength' })
-        .toUpperCase(),
-});
-// PEM Status Schema
-const PEMStatusSchema = z.enum(PEM_STATUS_OPTIONS);
-// Activation Request Schema
-const ActivationRequestSchema = z.object({
-    registration_key: z.string().min(1, { error: 'fieldIsRequired' }),
-});
-// PEM Status Offline Request Schema
-const PEMStatusOfflineRequestSchema = z.object({
-    timestamp: z
-        .string()
-        .min(1, { error: 'fieldIsRequired' })
-        .refine((val) => !isNaN(Date.parse(val)), {
-        error: 'invalidDateFormat',
-    }),
-    reason: z.string().min(1, { error: 'fieldIsRequired' }),
-});
-
-// Cash Register Create Schema
-const CashRegisterCreateSchema = z.object({
-    pem_serial_number: z.string().min(1, { error: 'fieldIsRequired' }),
-    name: z.string().min(1, { error: 'fieldIsRequired' }).max(100, { error: 'nameMaxLength' }),
-});
-
-// VAT number validation regex (Partita IVA - 11 digits)
-const VAT_NUMBER_REGEX = /^\d{11}$/;
-// Fiscal code validation regex (Codice Fiscale - 11 digits only for merchants)
-const FISCAL_CODE_REGEX = /^\d{11}$/;
-// Password validation regex (from OpenAPI spec)
-const PASSWORD_REGEX = /^((?=.*[A-Z])(?=.*[a-z])(?=.*[0-9])(?=.*[!@#$%^&*])(?=.{10,}).*)$/;
-// Merchant Create Input Schema
-const MerchantCreateInputSchema = z
-    .object({
-    vat_number: z
-        .string()
-        .min(1, { error: 'fieldIsRequired' })
-        .regex(VAT_NUMBER_REGEX, { error: 'invalidVatNumber' }),
-    fiscal_code: z.string().regex(FISCAL_CODE_REGEX, { error: 'invalidFiscalCode' }).optional(),
-    business_name: z.string().max(200, { error: 'businessNameMaxLength' }).optional().nullable(),
-    first_name: z.string().max(100, { error: 'firstNameMaxLength' }).optional().nullable(),
-    last_name: z.string().max(100, { error: 'lastNameMaxLength' }).optional().nullable(),
-    email: z.string().min(1, { error: 'fieldIsRequired' }).email({ error: 'invalidEmail' }),
-    password: z
-        .string()
-        .min(1, { error: 'fieldIsRequired' })
-        .regex(PASSWORD_REGEX, { error: 'passwordComplexity' }),
-    address: AddressSchema.optional(),
-})
-    .refine((data) => {
-    const hasBusinessName = data.business_name && data.business_name.trim() !== '';
-    const hasPersonalNames = (data.first_name && data.first_name.trim() !== '') ||
-        (data.last_name && data.last_name.trim() !== '');
-    // If business name is set, first/last name must not be provided
-    if (hasBusinessName && hasPersonalNames) {
-        return false;
-    }
-    // At least one naming method must be provided
-    if (!hasBusinessName && !hasPersonalNames) {
-        return false;
-    }
-    return true;
-}, {
-    error: 'businessNameOrPersonalNamesRequired',
-    path: ['business_name'],
-});
-// Merchant Update Input Schema
-const MerchantUpdateInputSchema = z.object({
-    business_name: z.string().max(200, { error: 'businessNameMaxLength' }).optional().nullable(),
-    first_name: z.string().max(100, { error: 'firstNameMaxLength' }).optional().nullable(),
-    last_name: z.string().max(100, { error: 'lastNameMaxLength' }).optional().nullable(),
-    address: AddressSchema.optional().nullable(),
-});
 
 // Enum options arrays
 const PEM_TYPE_OPTIONS = ['AP', 'SP', 'TM', 'PV'];
-// PEM Data Schema
-const PemDataSchema = z.object({
-    version: z.string().min(1, { error: 'fieldIsRequired' }),
-    type: z.enum(PEM_TYPE_OPTIONS, {
-        error: 'invalidPemType',
-    }),
-});
-// PEM Create Input Schema
-const PemCreateInputSchema = z.object({
-    merchant_uuid: z.string().min(1, { error: 'fieldIsRequired' }).uuid({ error: 'invalidUuid' }),
-    address: AddressSchema.optional(),
-    /* external_pem_data: PemDataSchema.optional(), */
-});
 
-// Italian Fiscal ID validation regex (Codice Fiscale for individuals or Partita IVA for companies)
-const FISCAL_ID_REGEX = /^([A-Z]{6}[0-9LMNPQRSTUV]{2}[ABCDEHLMPRST][0-9LMNPQRSTUV]{2}[A-Z][0-9LMNPQRSTUV]{3}[A-Z]|[0-9]{11})$/;
-// Supplier Create Input Schema
-const SupplierCreateInputSchema = z.object({
-    fiscal_id: z
-        .string()
-        .min(1, { error: 'fieldIsRequired' })
-        .regex(FISCAL_ID_REGEX, { error: 'invalidFiscalId' })
-        .toUpperCase(),
-    name: z.string().min(1, { error: 'fieldIsRequired' }).max(200, { error: 'nameMaxLength' }),
-    address: AddressSchema.optional(),
-});
-// Supplier Update Input Schema
-const SupplierUpdateInputSchema = z.object({
-    name: z.string().min(1, { error: 'fieldIsRequired' }).max(200, { error: 'nameMaxLength' }),
-    address: AddressSchema.optional(),
-});
-
-// Journal Close Input Schema
-const JournalCloseInputSchema = z.object({
-    closing_timestamp: z
-        .string()
-        .min(1, { error: 'fieldIsRequired' })
-        .refine((val) => !isNaN(Date.parse(val)), {
-        error: 'invalidDateFormat',
-    }),
-    reason: z.string().max(255, { error: 'reasonMaxLength' }).optional(),
-});
-
-// Daily Report Status Options
+// Enum options arrays
 const DAILY_REPORT_STATUS_OPTIONS = ['pending', 'sent', 'error'];
-// Daily Report Status Schema
-const DailyReportStatusSchema = z.enum(DAILY_REPORT_STATUS_OPTIONS, {
-    error: 'invalidDailyReportStatus',
-});
-// Daily Reports List Parameters Schema
-const DailyReportsParamsSchema = z.object({
-    pem_serial_number: z.string().min(1, { error: 'fieldIsRequired' }).optional(),
-    date_from: z
-        .string()
-        .refine((val) => !isNaN(Date.parse(val)), {
-        error: 'invalidDateFormat',
-    })
-        .optional(),
-    date_to: z
-        .string()
-        .refine((val) => !isNaN(Date.parse(val)), {
-        error: 'invalidDateFormat',
-    })
-        .optional(),
-    status: DailyReportStatusSchema.optional(),
-    page: z.number().min(1, { error: 'pageMinValue' }).optional(),
-});
-
-const NotificationScopeSchema = z.object({
-    type: z.literal('global'),
-});
-const PemStatusSchema = z.enum(['ONLINE', 'OFFLINE']);
-const NotificationDataBlockAtSchema = z.object({
-    block_at: z.string(),
-});
-const NotificationDataPemStatusSchema = z.object({
-    from: PemStatusSchema,
-    to: PemStatusSchema,
-});
-const NotificationBaseSchema = z.object({
-    uuid: z.string().uuid({ error: 'invalidUuid' }),
-    scope: NotificationScopeSchema,
-    source: z.enum(['system', 'Italian Tax Authority']),
-    level: z.enum(['info', 'warning', 'error', 'critical']),
-    created_at: z.string(),
-});
-const NotificationMf2UnreachableSchema = NotificationBaseSchema.extend({
-    type: z.literal('INTERNAL_COMMUNICATION_FAILURE'),
-    code: z.literal('SYS-W-01'),
-    data: NotificationDataBlockAtSchema,
-});
-const NotificationPemsBlockedSchema = NotificationBaseSchema.extend({
-    type: z.literal('PEM_STATUS_CHANGED'),
-    code: z.literal('SYS-C-01'),
-    data: NotificationDataPemStatusSchema,
-});
-const NotificationPemBackOnlineSchema = NotificationBaseSchema.extend({
-    type: z.literal('PEM_STATUS_CHANGED'),
-    code: z.literal('SYS-I-01'),
-    data: NotificationDataPemStatusSchema,
-});
-const NotificationSchema = z.discriminatedUnion('code', [
-    NotificationMf2UnreachableSchema,
-    NotificationPemsBlockedSchema,
-    NotificationPemBackOnlineSchema,
-]);
-const NotificationListResponseSchema = z.object({
-    members: z.array(NotificationSchema),
-});
-
-const TelemetryMerchantSchema = z.object({
-    vat_number: z.string(),
-    fiscal_code: z.string().nullable(),
-    business_name: z.string(),
-});
-const TelemetrySupplierSchema = z.object({
-    vat_number: z.string(),
-    fiscal_code: z.string().nullable(),
-    business_name: z.string(),
-});
-const TelemetrySoftwareVersionSchema = z.object({
-    version: z.string(),
-    swid: z.string(),
-    installed_at: z.string(),
-    status: z.enum(['active', 'inactive', 'archived']),
-});
-const TelemetrySoftwareSchema = z.object({
-    code: z.string(),
-    name: z.string(),
-    approval_reference: z.string(),
-    version_info: TelemetrySoftwareVersionSchema,
-});
-const PendingReceiptsSchema = z.object({
-    count: z.number().int().nonnegative(),
-    total_amount: z.string(),
-});
-const TransmissionSchema = z.object({
-    attempted_at: z.string(),
-    outcome: z.enum(['success', 'failed', 'pending']),
-});
-const MessageSchema = z.object({
-    received_at: z.string(),
-    content: z.string(),
-});
-const LotterySecretRequestSchema = z.object({
-    requested_at: z.string(),
-    outcome: z.enum(['success', 'failed', 'pending']),
-});
-const LotterySchema = z.object({
-    last_transmission: TransmissionSchema,
-    secret_request: LotterySecretRequestSchema,
-});
-const TelemetrySchema = z.object({
-    pem_id: z.string(),
-    pem_status: z.enum(['ONLINE', 'OFFLINE', 'ERROR']),
-    pem_status_changed_at: z.string(),
-    merchant: TelemetryMerchantSchema,
-    supplier: TelemetrySupplierSchema,
-    software: TelemetrySoftwareSchema,
-    last_communication_at: z.string(),
-    pending_receipts: PendingReceiptsSchema,
-    last_receipt_transmission: TransmissionSchema,
-    last_message_from_mf2: MessageSchema,
-    ade_corrispettivi_transmission: TransmissionSchema,
-    last_message_from_ade: MessageSchema,
-    lottery: LotterySchema,
-});
-
-// Receipt schemas and types
-// Common validation utilities
-const ValidationMessages = {
-    fieldIsRequired: 'This field is required',
-    arrayMin1: 'At least one item is required',
-    paymentMethodRequired: 'At least one payment method is required',
-    invalidEmail: 'Please enter a valid email address',
-    passwordMinLength: 'Password must be at least 8 characters long',
-    passwordComplexity: 'Password must contain at least one uppercase letter, one lowercase letter, one number, and one special character',
-    invalidZipCode: 'Please enter a valid 5-digit zip code',
-    provinceMinLength: 'Province code must be 2 characters',
-    provinceMaxLength: 'Province code must be 2 characters',
-    invalidDateFormat: 'Please enter a valid date',
-    nameMaxLength: 'Name is too long',
-    invalidFiscalId: 'Please enter a valid Italian fiscal ID (Codice Fiscale or Partita IVA)',
-    invalidVatNumber: 'Please enter a valid VAT number (11 digits)',
-    invalidFiscalCode: 'Please enter a valid fiscal code (11 digits)',
-    businessNameMaxLength: 'Business name is too long (max 200 characters)',
-    businessNameOrPersonalNamesRequired: 'Please provide either a business name or first/last name, but not both',
-    firstNameMaxLength: 'First name is too long (max 100 characters)',
-    lastNameMaxLength: 'Last name is too long (max 100 characters)',
-    invalidUuid: 'Please enter a valid UUID',
-    invalidPemType: 'PEM type must be one of: AP, SP, TM, PV',
-    reasonMaxLength: 'Reason is too long (max 255 characters)',
-    pageMinValue: 'Page number must be at least 1',
-    invalidDailyReportStatus: 'Daily report status must be one of: pending, sent, error',
-    displayNameMaxLength: 'Display name is too long (max 255 characters)',
-};
-// Validation helper functions
-const validateInput = (schema, data) => {
-    const result = schema.safeParse(data);
-    if (!result.success) {
-        const errors = result.error.issues.map((error) => ({
-            field: error.path.join('.'),
-            message: error.message,
-            code: error.code,
-        }));
-        return {
-            success: false,
-            errors,
-            data: null,
-        };
-    }
-    return {
-        success: true,
-        errors: [],
-        data: result.data,
-    };
-};
 
 class ACubeSDKError extends Error {
     constructor(type, message, originalError, statusCode, violations) {
@@ -2898,7 +2484,7 @@ class ACubeSDKError extends Error {
     }
 }
 
-const log$g = createPrefixedLogger('AUTH-STRATEGY');
+const log$a = createPrefixedLogger('AUTH-STRATEGY');
 class AuthStrategy {
     constructor(jwtHandler, mtlsHandler, userProvider, mtlsAdapter) {
         this.jwtHandler = jwtHandler;
@@ -2913,7 +2499,7 @@ class AuthStrategy {
         const platform = this.detectPlatform();
         const userRole = await this.getUserRole();
         const isReceiptEndpoint = this.isReceiptEndpoint(url);
-        log$g.debug('Determining auth config', {
+        log$a.debug('Determining auth config', {
             url,
             method,
             platform,
@@ -3044,7 +2630,7 @@ class JwtAuthHandler {
     }
 }
 
-const log$f = createPrefixedLogger('MTLS-HANDLER');
+const log$9 = createPrefixedLogger('MTLS-HANDLER');
 class MtlsAuthHandler {
     constructor(mtlsAdapter, certificatePort) {
         this.mtlsAdapter = mtlsAdapter;
@@ -3086,7 +2672,7 @@ class MtlsAuthHandler {
     async makeRequest(url, config, jwtToken) {
         const requestKey = this.generateRequestKey(url, config, jwtToken);
         if (this.pendingRequests.has(requestKey)) {
-            log$f.debug('Deduplicating concurrent request:', url);
+            log$9.debug('Deduplicating concurrent request:', url);
             return this.pendingRequests.get(requestKey);
         }
         const requestPromise = this.executeRequest(url, config, jwtToken, false);
@@ -3110,10 +2696,10 @@ class MtlsAuthHandler {
         };
         if (jwtToken) {
             headers['Authorization'] = `Bearer ${jwtToken}`;
-            log$f.debug('JWT token present:', jwtToken.substring(0, 20) + '...');
+            log$9.debug('JWT token present:', jwtToken.substring(0, 20) + '...');
         }
         else {
-            log$f.warn('No JWT token provided for mTLS request');
+            log$9.warn('No JWT token provided for mTLS request');
         }
         const fullUrl = this.constructMtlsUrl(url);
         const mtlsConfig = {
@@ -3124,25 +2710,25 @@ class MtlsAuthHandler {
             timeout: config.timeout,
             responseType: config.responseType,
         };
-        log$f.debug('header-mtls', headers);
-        log$f.debug(`${config.method} ${fullUrl}`);
+        log$9.debug('header-mtls', headers);
+        log$9.debug(`${config.method} ${fullUrl}`);
         if (config.data) {
-            log$f.debug('Request body:', config.data);
+            log$9.debug('Request body:', config.data);
         }
         try {
             const response = await this.mtlsAdapter.request(mtlsConfig);
-            log$f.debug(`Response ${response.status} from ${fullUrl}`);
+            log$9.debug(`Response ${response.status} from ${fullUrl}`);
             if (response.data) {
-                log$f.debug('Response body:', response.data);
+                log$9.debug('Response body:', response.data);
             }
             return response.data;
         }
         catch (error) {
-            log$f.error(`Response error from ${fullUrl}:`, error);
+            log$9.error(`Response error from ${fullUrl}:`, error);
             if (error && typeof error === 'object' && 'response' in error) {
                 const axiosError = error;
                 if (axiosError.response?.data) {
-                    log$f.error('Response body:', axiosError.response.data);
+                    log$9.error('Response body:', axiosError.response.data);
                 }
             }
             if (isRetryAttempt) {
@@ -3152,7 +2738,7 @@ class MtlsAuthHandler {
             if (!shouldRetry) {
                 throw error;
             }
-            log$f.debug('Request failed, reconfiguring certificate and retrying...');
+            log$9.debug('Request failed, reconfiguring certificate and retrying...');
             try {
                 await this.configureCertificate(certificate);
                 return await this.executeRequest(url, config, jwtToken, true);
@@ -3167,2000 +2753,99 @@ class MtlsAuthHandler {
             const message = error.message.toLowerCase();
             return (message.includes('certificate') ||
                 message.includes('ssl') ||
-                message.includes('tls') ||
-                message.includes('handshake'));
-        }
-        return false;
-    }
-    async configureCertificate(certificate) {
-        if (!this.mtlsAdapter) {
-            throw new Error('mTLS adapter not available');
-        }
-        const certificateData = {
-            certificate: certificate.certificate,
-            privateKey: certificate.privateKey,
-            format: certificate.format.toUpperCase(),
-        };
-        await this.mtlsAdapter.configureCertificate(certificateData);
-    }
-    async storeCertificate(certificate, privateKey, options = {}) {
-        if (!this.certificatePort) {
-            throw new Error('Certificate port not available');
-        }
-        if (this.mtlsAdapter) {
-            try {
-                await this.mtlsAdapter.removeCertificate();
-            }
-            catch {
-                // No existing certificate to remove
-            }
-        }
-        const format = (options.format || 'pem');
-        await this.certificatePort.storeCertificate(certificate, privateKey, format);
-        if (this.mtlsAdapter) {
-            const certificateData = {
-                certificate,
-                privateKey,
-                format: format.toUpperCase(),
-            };
-            await this.mtlsAdapter.configureCertificate(certificateData);
-        }
-    }
-    async clearCertificate() {
-        if (this.mtlsAdapter) {
-            try {
-                await this.mtlsAdapter.removeCertificate();
-            }
-            catch {
-                // No certificate to remove
-            }
-        }
-        if (this.certificatePort) {
-            await this.certificatePort.clearCertificate();
-        }
-    }
-    async testConnection() {
-        if (!this.mtlsAdapter) {
-            return false;
-        }
-        return this.mtlsAdapter.testConnection();
-    }
-    getBaseUrl() {
-        if (!this.mtlsAdapter) {
-            return null;
-        }
-        return this.mtlsAdapter.getBaseUrl();
-    }
-    async getStatus() {
-        const status = {
-            adapterAvailable: !!this.mtlsAdapter,
-            certificatePortAvailable: !!this.certificatePort,
-            isReady: false,
-            hasCertificate: false,
-            certificateInfo: null,
-            platformInfo: this.mtlsAdapter?.getPlatformInfo() || null,
-            pendingRequestsCount: this.pendingRequests.size,
-        };
-        if (this.certificatePort) {
-            try {
-                status.hasCertificate = await this.certificatePort.hasCertificate();
-                if (status.hasCertificate) {
-                    status.certificateInfo = await this.certificatePort.getCertificateInfo();
-                }
-            }
-            catch {
-                // Ignore errors
-            }
-        }
-        status.isReady = await this.isMtlsReady();
-        return status;
-    }
-    clearPendingRequests() {
-        this.pendingRequests.clear();
-    }
-}
-
-const DEFAULT_QUEUE_CONFIG = {
-    maxRetries: 3,
-    retryDelay: 1000,
-    maxRetryDelay: 30000,
-    backoffMultiplier: 2,
-    maxQueueSize: 1000,
-    batchSize: 10,
-    syncInterval: 30000,
-};
-
-class OperationQueue {
-    constructor(storage, config = DEFAULT_QUEUE_CONFIG, events = {}) {
-        this.storage = storage;
-        this.config = config;
-        this.events = events;
-        this.queue = [];
-        this.processing = false;
-        this.config = { ...DEFAULT_QUEUE_CONFIG, ...config };
-        this.loadQueue();
-        if (this.config.syncInterval > 0) {
-            this.startAutoSync();
-        }
-    }
-    async addOperation(type, resource, endpoint, method, data, priority = 1) {
-        if (this.queue.length >= this.config.maxQueueSize) {
-            const lowPriorityIndex = this.queue.findIndex((op) => op.priority === 1);
-            if (lowPriorityIndex !== -1) {
-                this.queue.splice(lowPriorityIndex, 1);
-            }
-            else {
-                throw new Error('Queue is full');
-            }
-        }
-        const operation = {
-            id: this.generateId(),
-            type,
-            resource,
-            endpoint,
-            method,
-            data,
-            status: 'pending',
-            createdAt: Date.now(),
-            updatedAt: Date.now(),
-            retryCount: 0,
-            maxRetries: this.config.maxRetries,
-            priority,
-        };
-        const insertIndex = this.queue.findIndex((op) => op.priority < priority);
-        if (insertIndex === -1) {
-            this.queue.push(operation);
-        }
-        else {
-            this.queue.splice(insertIndex, 0, operation);
-        }
-        await this.saveQueue();
-        this.events.onOperationAdded?.(operation);
-        return operation.id;
-    }
-    getPendingOperations() {
-        return this.queue.filter((op) => op.status === 'pending' || op.status === 'failed');
-    }
-    getOperation(id) {
-        return this.queue.find((op) => op.id === id);
-    }
-    async removeOperation(id) {
-        const index = this.queue.findIndex((op) => op.id === id);
-        if (index === -1)
-            return false;
-        this.queue.splice(index, 1);
-        await this.saveQueue();
-        return true;
-    }
-    async updateOperation(id, updates) {
-        const operation = this.queue.find((op) => op.id === id);
-        if (!operation)
-            return false;
-        Object.assign(operation, { ...updates, updatedAt: Date.now() });
-        await this.saveQueue();
-        return true;
-    }
-    getStats() {
-        return {
-            total: this.queue.length,
-            pending: this.queue.filter((op) => op.status === 'pending').length,
-            processing: this.queue.filter((op) => op.status === 'processing').length,
-            completed: this.queue.filter((op) => op.status === 'completed').length,
-            failed: this.queue.filter((op) => op.status === 'failed').length,
-        };
-    }
-    async clearQueue() {
-        this.queue = [];
-        await this.saveQueue();
-    }
-    async clearCompleted() {
-        this.queue = this.queue.filter((op) => op.status !== 'completed');
-        await this.saveQueue();
-    }
-    async clearFailed() {
-        this.queue = this.queue.filter((op) => op.status !== 'failed');
-        await this.saveQueue();
-    }
-    async retryFailed() {
-        for (const operation of this.queue.filter((op) => op.status === 'failed')) {
-            if (operation.retryCount < operation.maxRetries) {
-                operation.status = 'pending';
-                operation.retryCount++;
-                operation.updatedAt = Date.now();
-                delete operation.error;
-            }
-        }
-        await this.saveQueue();
-    }
-    getNextBatch() {
-        return this.queue
-            .filter((op) => op.status === 'pending')
-            .sort((a, b) => b.priority - a.priority || a.createdAt - b.createdAt)
-            .slice(0, this.config.batchSize);
-    }
-    isEmpty() {
-        return this.getPendingOperations().length === 0;
-    }
-    startAutoSync() {
-        if (this.syncIntervalId)
-            return;
-        this.syncIntervalId = setInterval(() => {
-            if (!this.isEmpty() && !this.processing) {
-                this.events.onQueueEmpty?.();
-            }
-        }, this.config.syncInterval);
-    }
-    stopAutoSync() {
-        if (this.syncIntervalId) {
-            clearInterval(this.syncIntervalId);
-            this.syncIntervalId = undefined;
-        }
-    }
-    setProcessing(value) {
-        this.processing = value;
-    }
-    isCurrentlyProcessing() {
-        return this.processing;
-    }
-    async loadQueue() {
-        try {
-            const queueData = await this.storage.get(OperationQueue.QUEUE_KEY);
-            if (queueData) {
-                this.queue = JSON.parse(queueData);
-                this.queue.forEach((op) => {
-                    if (op.status === 'processing') {
-                        op.status = 'pending';
-                    }
-                });
-            }
-        }
-        catch {
-            this.queue = [];
-        }
-    }
-    async saveQueue() {
-        try {
-            await this.storage.set(OperationQueue.QUEUE_KEY, JSON.stringify(this.queue));
-        }
-        catch (error) {
-            this.events.onError?.(new Error(`Failed to save queue: ${error}`));
-        }
-    }
-    generateId() {
-        return `${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
-    }
-    destroy() {
-        this.stopAutoSync();
-    }
-}
-OperationQueue.QUEUE_KEY = 'acube_operation_queue';
-
-class SyncManager {
-    constructor(queue, httpPort, networkMonitor, config, events = {}) {
-        this.queue = queue;
-        this.httpPort = httpPort;
-        this.networkMonitor = networkMonitor;
-        this.config = config;
-        this.events = events;
-        this.isOnline = true;
-        this.destroy$ = new Subject();
-        this.setupNetworkMonitoring();
-    }
-    setupNetworkMonitoring() {
-        // Subscribe to online$ to track current state
-        this.networkSubscription = this.networkMonitor.online$
-            .pipe(startWith(true), // Assume online initially
-        pairwise(), filter(([wasOnline, isNowOnline]) => !wasOnline && isNowOnline), takeUntil(this.destroy$))
-            .subscribe(() => {
-            // Offline → Online transition detected
-            this.syncPendingOperations();
-        });
-        // Track current online state
-        this.networkMonitor.online$.pipe(takeUntil(this.destroy$)).subscribe((online) => {
-            this.isOnline = online;
-        });
-    }
-    async syncPendingOperations() {
-        if (!this.isOnline) {
-            throw new Error('Cannot sync while offline');
-        }
-        if (this.queue.isCurrentlyProcessing()) {
-            throw new Error('Sync already in progress');
-        }
-        this.queue.setProcessing(true);
-        try {
-            const results = [];
-            let successCount = 0;
-            let failureCount = 0;
-            while (!this.queue.isEmpty()) {
-                const batch = this.queue.getNextBatch();
-                if (batch.length === 0)
-                    break;
-                const batchPromises = batch.map((operation) => this.processOperation(operation));
-                const batchResults = await Promise.allSettled(batchPromises);
-                batchResults.forEach((result, index) => {
-                    const operation = batch[index];
-                    if (!operation)
-                        return;
-                    if (result.status === 'fulfilled') {
-                        const syncResult = result.value;
-                        results.push(syncResult);
-                        if (syncResult.success) {
-                            successCount++;
-                            this.events.onOperationCompleted?.(syncResult);
-                        }
-                        else {
-                            failureCount++;
-                            this.events.onOperationFailed?.(syncResult);
-                        }
-                    }
-                    else {
-                        const syncResult = {
-                            operation,
-                            success: false,
-                            error: result.reason?.message || 'Unknown error',
-                        };
-                        results.push(syncResult);
-                        failureCount++;
-                        this.events.onOperationFailed?.(syncResult);
-                        this.queue.updateOperation(operation.id, {
-                            status: 'failed',
-                            error: syncResult.error,
-                        });
-                    }
-                });
-                if (!this.queue.isEmpty()) {
-                    await this.delay(500);
-                }
-            }
-            const batchResult = {
-                totalOperations: results.length,
-                successCount,
-                failureCount,
-                results,
-            };
-            this.events.onBatchSyncCompleted?.(batchResult);
-            if (this.queue.isEmpty()) {
-                this.events.onQueueEmpty?.();
-            }
-            return batchResult;
-        }
-        finally {
-            this.queue.setProcessing(false);
-        }
-    }
-    async processOperation(operation) {
-        await this.queue.updateOperation(operation.id, { status: 'processing' });
-        try {
-            const response = await this.executeOperation(operation);
-            await this.queue.updateOperation(operation.id, { status: 'completed' });
-            return { operation, success: true, response };
-        }
-        catch (error) {
-            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
-            if (operation.retryCount < operation.maxRetries && this.isRetryableError(error)) {
-                const delay = this.calculateRetryDelay(operation.retryCount);
-                await this.queue.updateOperation(operation.id, {
-                    status: 'pending',
-                    retryCount: operation.retryCount + 1,
-                    error: errorMessage,
-                });
-                setTimeout(() => {
-                    if (this.isOnline && !this.queue.isCurrentlyProcessing()) {
-                        this.syncPendingOperations();
-                    }
-                }, delay);
-                return { operation, success: false, error: `Retrying: ${errorMessage}` };
-            }
-            else {
-                await this.queue.updateOperation(operation.id, {
-                    status: 'failed',
-                    error: errorMessage,
-                });
-                return { operation, success: false, error: errorMessage };
-            }
-        }
-    }
-    async executeOperation(operation) {
-        const { method, endpoint, data, headers } = operation;
-        const config = headers ? { headers } : undefined;
-        switch (method) {
-            case 'GET':
-                return (await this.httpPort.get(endpoint, config)).data;
-            case 'POST':
-                return (await this.httpPort.post(endpoint, data, config)).data;
-            case 'PUT':
-                return (await this.httpPort.put(endpoint, data, config)).data;
-            case 'PATCH':
-                return (await this.httpPort.patch(endpoint, data, config)).data;
-            case 'DELETE':
-                return (await this.httpPort.delete(endpoint, config)).data;
-            default:
-                throw new Error(`Unsupported HTTP method: ${method}`);
-        }
-    }
-    isRetryableError(error) {
-        const errorObj = error;
-        if (errorObj.code === 'NETWORK_ERROR')
-            return true;
-        if (errorObj.statusCode && errorObj.statusCode >= 500)
-            return true;
-        if (errorObj.statusCode === 429)
-            return true;
-        const errorMessage = error?.message;
-        if (errorObj.code === 'ECONNABORTED' || errorMessage?.includes('timeout'))
-            return true;
-        return false;
-    }
-    calculateRetryDelay(retryCount) {
-        const delay = this.config.retryDelay * Math.pow(this.config.backoffMultiplier, retryCount);
-        return Math.min(delay, this.config.maxRetryDelay);
-    }
-    delay(ms) {
-        return new Promise((resolve) => setTimeout(resolve, ms));
-    }
-    isCurrentlyOnline() {
-        return this.isOnline;
-    }
-    async triggerSync() {
-        if (!this.isOnline)
-            return null;
-        if (this.queue.isEmpty()) {
-            return { totalOperations: 0, successCount: 0, failureCount: 0, results: [] };
-        }
-        return await this.syncPendingOperations();
-    }
-    getSyncStatus() {
-        return {
-            isOnline: this.isOnline,
-            isProcessing: this.queue.isCurrentlyProcessing(),
-            queueStats: this.queue.getStats(),
-        };
-    }
-    destroy() {
-        this.destroy$.next();
-        this.destroy$.complete();
-        this.networkSubscription?.unsubscribe();
-    }
-}
-
-class OfflineManager {
-    get queue$() {
-        return this.queueSubject.asObservable();
-    }
-    get syncStatus$() {
-        return this.syncStatusSubject.asObservable();
-    }
-    constructor(storage, httpPort, networkMonitor, config = {}, events = {}, _cache) {
-        this.queueSubject = new BehaviorSubject([]);
-        this.syncStatusSubject = new BehaviorSubject({
-            isOnline: true,
-            isProcessing: false,
-            queueStats: { total: 0, pending: 0, processing: 0, completed: 0, failed: 0 },
-        });
-        this.destroy$ = new Subject();
-        const finalConfig = { ...DEFAULT_QUEUE_CONFIG, ...config };
-        const wrappedEvents = {
-            ...events,
-            onOperationAdded: (op) => {
-                this.updateQueueState();
-                events.onOperationAdded?.(op);
-            },
-            onOperationCompleted: (result) => {
-                this.updateQueueState();
-                events.onOperationCompleted?.(result);
-            },
-            onOperationFailed: (result) => {
-                this.updateQueueState();
-                events.onOperationFailed?.(result);
-            },
-            onBatchSyncCompleted: (result) => {
-                this.updateQueueState();
-                events.onBatchSyncCompleted?.(result);
-            },
-        };
-        this.queue = new OperationQueue(storage, finalConfig, wrappedEvents);
-        this.syncManager = new SyncManager(this.queue, httpPort, networkMonitor, finalConfig, wrappedEvents);
-        this.updateQueueState();
-    }
-    updateQueueState() {
-        this.queueSubject.next(this.queue.getPendingOperations());
-        this.syncStatusSubject.next(this.syncManager.getSyncStatus());
-    }
-    async queueOperation(type, resource, endpoint, method, data, priority = 1) {
-        const id = await this.queue.addOperation(type, resource, endpoint, method, data, priority);
-        this.updateQueueState();
-        return id;
-    }
-    async queueReceiptCreation(receiptData, priority = 2) {
-        return await this.queueOperation('CREATE', 'receipt', '/mf1/receipts', 'POST', receiptData, priority);
-    }
-    async queueReceiptVoid(voidData, priority = 3) {
-        return await this.queueOperation('DELETE', 'receipt', '/mf1/receipts', 'DELETE', voidData, priority);
-    }
-    async queueReceiptReturn(returnData, priority = 3) {
-        return await this.queueOperation('CREATE', 'receipt', '/mf1/receipts/return', 'POST', returnData, priority);
-    }
-    async queueCashierCreation(cashierData, priority = 1) {
-        return await this.queueOperation('CREATE', 'cashier', '/mf1/cashiers', 'POST', cashierData, priority);
-    }
-    isOnline() {
-        return this.syncManager.isCurrentlyOnline();
-    }
-    getStatus() {
-        return this.syncManager.getSyncStatus();
-    }
-    getPendingCount() {
-        return this.queue.getPendingOperations().length;
-    }
-    isEmpty() {
-        return this.queue.isEmpty();
-    }
-    async sync() {
-        const result = await this.syncManager.triggerSync();
-        this.updateQueueState();
-        return result;
-    }
-    async retryFailed() {
-        await this.queue.retryFailed();
-        this.updateQueueState();
-        if (this.isOnline()) {
-            await this.sync();
-        }
-    }
-    async clearCompleted() {
-        await this.queue.clearCompleted();
-        this.updateQueueState();
-    }
-    async clearFailed() {
-        await this.queue.clearFailed();
-        this.updateQueueState();
-    }
-    async clearAll() {
-        await this.queue.clearQueue();
-        this.updateQueueState();
-    }
-    getOperation(id) {
-        return this.queue.getOperation(id);
-    }
-    async removeOperation(id) {
-        const result = await this.queue.removeOperation(id);
-        this.updateQueueState();
-        return result;
-    }
-    getQueueStats() {
-        return this.queue.getStats();
-    }
-    startAutoSync() {
-        this.queue.startAutoSync();
-    }
-    stopAutoSync() {
-        this.queue.stopAutoSync();
-    }
-    destroy() {
-        this.destroy$.next();
-        this.destroy$.complete();
-        this.queue.destroy();
-        this.syncManager.destroy();
-    }
-}
-
-class CompressionAdapter {
-    compress(data, threshold = 1024) {
-        const originalSize = data.length * 2;
-        if (originalSize < threshold) {
-            return {
-                data,
-                compressed: false,
-                originalSize,
-                compressedSize: originalSize,
-            };
-        }
-        try {
-            const compressed = this.compressString(data);
-            const compressedSize = compressed.length * 2;
-            if (compressedSize < originalSize) {
-                return {
-                    data: compressed,
-                    compressed: true,
-                    originalSize,
-                    compressedSize,
-                };
-            }
-            return {
-                data,
-                compressed: false,
-                originalSize,
-                compressedSize: originalSize,
-            };
-        }
-        catch {
-            return {
-                data,
-                compressed: false,
-                originalSize,
-                compressedSize: originalSize,
-            };
-        }
-    }
-    decompress(data, compressed) {
-        if (!compressed) {
-            return { data, wasCompressed: false };
-        }
-        try {
-            const decompressed = this.decompressString(data);
-            return { data: decompressed, wasCompressed: true };
-        }
-        catch {
-            return { data, wasCompressed: false };
-        }
-    }
-    estimateSavings(data) {
-        const repeated = data.match(/(.)\1{3,}/g);
-        if (!repeated)
-            return 0;
-        let savings = 0;
-        for (const match of repeated) {
-            const originalBytes = match.length * 2;
-            const compressedBytes = 6;
-            if (originalBytes > compressedBytes) {
-                savings += originalBytes - compressedBytes;
-            }
-        }
-        return Math.min(savings, data.length * 2 * 0.5);
-    }
-    compressString(input) {
-        let compressed = '';
-        let i = 0;
-        while (i < input.length) {
-            let count = 1;
-            const char = input[i];
-            while (i + count < input.length && input[i + count] === char && count < 255) {
-                count++;
-            }
-            if (count > 3) {
-                compressed += `~${count}${char}`;
-            }
-            else {
-                for (let j = 0; j < count; j++) {
-                    compressed += char;
-                }
-            }
-            i += count;
-        }
-        return `COMP:${btoa(compressed)}`;
-    }
-    decompressString(input) {
-        if (!input.startsWith('COMP:')) {
-            return input;
-        }
-        const encodedData = input.substring(5);
-        if (!encodedData) {
-            return input;
-        }
-        const compressed = atob(encodedData);
-        let decompressed = '';
-        let i = 0;
-        while (i < compressed.length) {
-            if (compressed[i] === '~' && i + 2 < compressed.length) {
-                let countStr = '';
-                i++;
-                while (i < compressed.length) {
-                    const char = compressed[i];
-                    if (char && /\d/.test(char)) {
-                        countStr += char;
-                        i++;
-                    }
-                    else {
-                        break;
-                    }
-                }
-                if (countStr && i < compressed.length) {
-                    const count = parseInt(countStr, 10);
-                    const char = compressed[i];
-                    for (let j = 0; j < count; j++) {
-                        decompressed += char;
-                    }
-                    i++;
-                }
-            }
-            else {
-                decompressed += compressed[i];
-                i++;
-            }
-        }
-        return decompressed;
-    }
-}
-function compressData(data, threshold = 1024) {
-    return new CompressionAdapter().compress(data, threshold);
-}
-function decompressData(data, compressed) {
-    return new CompressionAdapter().decompress(data, compressed);
-}
-
-const log$e = createPrefixedLogger('CACHE-RN');
-/**
- * React Native cache adapter using SQLite (Expo or react-native-sqlite-storage)
- * Cache never expires - data persists until explicitly invalidated
- */
-class ReactNativeCacheAdapter {
-    constructor(options = {}) {
-        this.db = null;
-        this.initPromise = null;
-        this.isExpo = false;
-        this.hasCompressedColumn = false;
-        this.options = {
-            maxSize: 50 * 1024 * 1024, // 50MB
-            maxEntries: 10000,
-            compression: false,
-            compressionThreshold: 1024,
-            ...options,
-        };
-        this.initPromise = this.initialize();
-    }
-    normalizeResults(results) {
-        if (this.isExpo) {
-            const expoResults = results;
-            if (Array.isArray(expoResults)) {
-                return expoResults;
-            }
-            return expoResults.results || [];
-        }
-        else {
-            const rnResults = results;
-            const rows = rnResults.rows;
-            if (!rows || rows.length === 0)
-                return [];
-            const normalizedRows = [];
-            for (let i = 0; i < rows.length; i++) {
-                normalizedRows.push(rows.item(i));
-            }
-            return normalizedRows;
-        }
-    }
-    async initialize() {
-        if (this.db)
-            return;
-        try {
-            // Try Expo SQLite first
-            const ExpoSQLite = require('expo-sqlite');
-            this.db = await ExpoSQLite.openDatabaseAsync(ReactNativeCacheAdapter.DB_NAME);
-            this.isExpo = true;
-            await this.createTables();
-        }
-        catch (expoError) {
-            try {
-                // Fallback to react-native-sqlite-storage
-                const SQLite = require('react-native-sqlite-storage');
-                this.db = await new Promise((resolve, reject) => {
-                    SQLite.openDatabase({
-                        name: ReactNativeCacheAdapter.DB_NAME,
-                        location: 'default',
-                    }, resolve, reject);
-                });
-                this.isExpo = false;
-                await this.createTables();
-            }
-            catch (rnError) {
-                throw new Error(`Failed to initialize SQLite: Expo error: ${expoError}, RN error: ${rnError}`);
-            }
-        }
-    }
-    async createTables() {
-        // Create table with simplified schema (no TTL)
-        const createTableSQL = `
-      CREATE TABLE IF NOT EXISTS ${ReactNativeCacheAdapter.TABLE_NAME} (
-        cache_key TEXT PRIMARY KEY,
-        data TEXT NOT NULL,
-        timestamp INTEGER NOT NULL
-      );
-
-      CREATE INDEX IF NOT EXISTS idx_timestamp ON ${ReactNativeCacheAdapter.TABLE_NAME}(timestamp);
-    `;
-        await this.executeSql(createTableSQL);
-        // Then, run migrations to add new columns if they don't exist
-        await this.runMigrations();
-    }
-    async runMigrations() {
-        log$e.debug('Running database migrations...');
-        try {
-            // Check if compressed column exists
-            this.hasCompressedColumn = await this.checkColumnExists('compressed');
-            if (!this.hasCompressedColumn) {
-                log$e.debug('Adding compressed column to cache table');
-                const addColumnSQL = `ALTER TABLE ${ReactNativeCacheAdapter.TABLE_NAME} ADD COLUMN compressed INTEGER DEFAULT 0`;
-                await this.executeSql(addColumnSQL);
-                this.hasCompressedColumn = true;
-                log$e.debug('Successfully added compressed column');
-            }
-            else {
-                log$e.debug('Compressed column already exists');
-            }
-            log$e.debug('Database migrations completed', {
-                hasCompressedColumn: this.hasCompressedColumn,
-            });
-        }
-        catch (error) {
-            log$e.debug('Migration failed, disabling compression features', error);
-            this.hasCompressedColumn = false;
-            // Don't throw - allow the app to continue even if migration fails
-            // The compressed feature will just be disabled
-        }
-    }
-    async checkColumnExists(columnName) {
-        try {
-            const pragmaSQL = `PRAGMA table_info(${ReactNativeCacheAdapter.TABLE_NAME})`;
-            const results = await this.executeSql(pragmaSQL);
-            const columns = this.normalizeResults(results);
-            log$e.debug('Table columns found', { columns: columns.map((c) => c.name) });
-            return columns.some((column) => column.name === columnName);
-        }
-        catch (error) {
-            log$e.debug('Error checking column existence', error);
-            return false;
-        }
-    }
-    async get(key) {
-        await this.ensureInitialized();
-        const sql = `SELECT * FROM ${ReactNativeCacheAdapter.TABLE_NAME} WHERE cache_key = ?`;
-        log$e.debug('Executing get query', { sql, key });
-        const results = await this.executeSql(sql, [key]);
-        log$e.debug('Get query results', { key, hasResults: !!results });
-        // Normalize results from different SQLite implementations
-        const rows = this.normalizeResults(results);
-        if (!rows || rows.length === 0) {
-            return null;
-        }
-        const row = rows[0];
-        if (!row) {
-            return null;
-        }
-        const isCompressed = this.hasCompressedColumn ? !!row.compressed : false;
-        const rawData = isCompressed ? decompressData(row.data, true).data : row.data;
-        return {
-            data: JSON.parse(rawData),
-            timestamp: row.timestamp,
-            compressed: isCompressed,
-        };
-    }
-    async set(key, data) {
-        const item = {
-            data,
-            timestamp: Date.now(),
-        };
-        log$e.debug('Setting cache item', { key });
-        return this.setItem(key, item);
-    }
-    async setItem(key, item) {
-        await this.ensureInitialized();
-        // Handle compression if enabled and compressed column is available
-        const serializedData = JSON.stringify(item.data);
-        let finalData = serializedData;
-        let isCompressed = false;
-        if (this.options.compression && this.options.compressionThreshold && this.hasCompressedColumn) {
-            const compressionResult = compressData(serializedData, this.options.compressionThreshold);
-            finalData = compressionResult.data;
-            isCompressed = compressionResult.compressed;
-            log$e.debug('Compression result', {
-                key,
-                originalSize: compressionResult.originalSize,
-                compressedSize: compressionResult.compressedSize,
-                compressed: isCompressed,
-                savings: compressionResult.originalSize - compressionResult.compressedSize,
-            });
-        }
-        log$e.debug('Setting item with metadata', {
-            key,
-            timestamp: item.timestamp,
-            compressed: isCompressed,
-            hasCompressedColumn: this.hasCompressedColumn,
-        });
-        // Build SQL and parameters based on available columns
-        let sql;
-        let params;
-        if (this.hasCompressedColumn) {
-            sql = `
-        INSERT OR REPLACE INTO ${ReactNativeCacheAdapter.TABLE_NAME}
-        (cache_key, data, timestamp, compressed)
-        VALUES (?, ?, ?, ?)
-      `;
-            params = [key, finalData, item.timestamp, isCompressed ? 1 : 0];
-        }
-        else {
-            // Fallback for databases without compressed column
-            sql = `
-        INSERT OR REPLACE INTO ${ReactNativeCacheAdapter.TABLE_NAME}
-        (cache_key, data, timestamp)
-        VALUES (?, ?, ?)
-      `;
-            params = [key, finalData, item.timestamp];
-        }
-        log$e.debug('Executing setItem SQL', { key, paramsCount: params.length });
-        await this.executeSql(sql, params);
-    }
-    async setBatch(items) {
-        if (items.length === 0)
-            return;
-        await this.ensureInitialized();
-        log$e.debug('Batch setting items', { count: items.length });
-        if (this.isExpo) {
-            await this.db.withTransactionAsync(async () => {
-                for (const [key, item] of items) {
-                    await this.setBatchItem(key, item);
-                }
-            });
-        }
-        else {
-            return new Promise((resolve, reject) => {
-                this.db.transaction((tx) => {
-                    const promises = items.map(([key, item]) => this.setBatchItemRN(tx, key, item));
-                    Promise.all(promises)
-                        .then(() => resolve())
-                        .catch(reject);
-                }, reject, () => resolve());
-            });
-        }
-        log$e.debug('Batch operation completed', { count: items.length });
-    }
-    async setBatchItem(key, item) {
-        // Handle compression if enabled and compressed column is available
-        const serializedData = JSON.stringify(item.data);
-        let finalData = serializedData;
-        let isCompressed = false;
-        if (this.options.compression && this.options.compressionThreshold && this.hasCompressedColumn) {
-            const compressionResult = compressData(serializedData, this.options.compressionThreshold);
-            finalData = compressionResult.data;
-            isCompressed = compressionResult.compressed;
-        }
-        // Build SQL and parameters based on available columns
-        let sql;
-        let params;
-        if (this.hasCompressedColumn) {
-            sql = `
-        INSERT OR REPLACE INTO ${ReactNativeCacheAdapter.TABLE_NAME}
-        (cache_key, data, timestamp, compressed)
-        VALUES (?, ?, ?, ?)
-      `;
-            params = [key, finalData, item.timestamp, isCompressed ? 1 : 0];
-        }
-        else {
-            sql = `
-        INSERT OR REPLACE INTO ${ReactNativeCacheAdapter.TABLE_NAME}
-        (cache_key, data, timestamp)
-        VALUES (?, ?, ?)
-      `;
-            params = [key, finalData, item.timestamp];
-        }
-        await this.db.runAsync(sql, params);
-    }
-    async setBatchItemRN(tx, key, item) {
-        // Handle compression if enabled and compressed column is available
-        const serializedData = JSON.stringify(item.data);
-        let finalData = serializedData;
-        let isCompressed = false;
-        if (this.options.compression && this.options.compressionThreshold && this.hasCompressedColumn) {
-            const compressionResult = compressData(serializedData, this.options.compressionThreshold);
-            finalData = compressionResult.data;
-            isCompressed = compressionResult.compressed;
-        }
-        // Build SQL and parameters based on available columns
-        let sql;
-        let params;
-        if (this.hasCompressedColumn) {
-            sql = `
-        INSERT OR REPLACE INTO ${ReactNativeCacheAdapter.TABLE_NAME}
-        (cache_key, data, timestamp, compressed)
-        VALUES (?, ?, ?, ?)
-      `;
-            params = [key, finalData, item.timestamp, isCompressed ? 1 : 0];
-        }
-        else {
-            sql = `
-        INSERT OR REPLACE INTO ${ReactNativeCacheAdapter.TABLE_NAME}
-        (cache_key, data, timestamp)
-        VALUES (?, ?, ?)
-      `;
-            params = [key, finalData, item.timestamp];
-        }
-        return new Promise((resolve, reject) => {
-            tx.executeSql(sql, params, () => resolve(), (_, error) => {
-                reject(error);
-                return false;
-            });
-        });
-    }
-    async invalidate(pattern) {
-        await this.ensureInitialized();
-        const keys = await this.getKeys(pattern);
-        if (keys.length === 0)
-            return;
-        const placeholders = keys.map(() => '?').join(',');
-        const sql = `DELETE FROM ${ReactNativeCacheAdapter.TABLE_NAME} WHERE cache_key IN (${placeholders})`;
-        await this.executeSql(sql, keys);
-    }
-    async clear() {
-        await this.ensureInitialized();
-        const sql = `DELETE FROM ${ReactNativeCacheAdapter.TABLE_NAME}`;
-        await this.executeSql(sql);
-    }
-    async getSize() {
-        await this.ensureInitialized();
-        const sql = `
-      SELECT
-        COUNT(*) as entries,
-        SUM(LENGTH(data)) as bytes
-      FROM ${ReactNativeCacheAdapter.TABLE_NAME}
-    `;
-        const results = await this.executeSql(sql);
-        const rows = this.normalizeResults(results);
-        const row = rows[0] || { entries: 0, bytes: 0 };
-        return {
-            entries: row.entries || 0,
-            bytes: (row.bytes || 0) * 2,
-            lastCleanup: Date.now(),
-        };
-    }
-    async cleanup() {
-        // No cleanup needed - cache never expires
-        return 0;
-    }
-    async getKeys(pattern) {
-        await this.ensureInitialized();
-        let sql = `SELECT cache_key FROM ${ReactNativeCacheAdapter.TABLE_NAME}`;
-        const params = [];
-        if (pattern) {
-            // Simple pattern matching with LIKE
-            const likePattern = pattern.replace(/\*/g, '%').replace(/\?/g, '_');
-            sql += ' WHERE cache_key LIKE ?';
-            params.push(likePattern);
-        }
-        const results = await this.executeSql(sql, params);
-        const keys = [];
-        const rows = this.normalizeResults(results);
-        for (const row of rows) {
-            keys.push(row.cache_key);
-        }
-        return keys;
-    }
-    async executeSql(sql, params = []) {
-        if (this.isExpo) {
-            const expoDB = this.db;
-            if (sql.toLowerCase().includes('select') || sql.toLowerCase().includes('pragma')) {
-                const result = await expoDB.getAllAsync(sql, params);
-                return Array.isArray(result) ? { results: result } : result;
-            }
-            else {
-                return await expoDB.runAsync(sql, params);
-            }
-        }
-        else {
-            // react-native-sqlite-storage
-            return new Promise((resolve, reject) => {
-                this.db.transaction((tx) => {
-                    tx.executeSql(sql, params, (_, results) => resolve(results), (_, error) => {
-                        reject(error);
-                        return false;
-                    });
-                });
-            });
-        }
-    }
-    async ensureInitialized() {
-        if (!this.initPromise) {
-            this.initPromise = this.initialize();
-        }
-        await this.initPromise;
-    }
-}
-ReactNativeCacheAdapter.DB_NAME = 'acube_cache.db';
-ReactNativeCacheAdapter.TABLE_NAME = 'cache_entries';
-/**
- * Memory-based fallback cache adapter for environments without SQLite
- * Cache never expires - data persists until explicitly invalidated
- */
-class MemoryCacheAdapter {
-    constructor(options = {}) {
-        this.cache = new Map();
-        this.totalBytes = 0;
-        this.options = {
-            maxEntries: 1000,
-            ...options,
-        };
-    }
-    calculateItemSize(key, item) {
-        // Calculate rough size estimation for memory usage
-        const keySize = key.length * 2; // UTF-16 estimation
-        const itemSize = JSON.stringify(item).length * 2; // UTF-16 estimation
-        return keySize + itemSize;
-    }
-    async get(key) {
-        log$e.debug('Getting cache item', { key });
-        const item = this.cache.get(key);
-        if (!item) {
-            log$e.debug('Cache miss', { key });
-            return null;
-        }
-        // Handle decompression if needed
-        const isCompressed = !!item.compressed;
-        let finalData = item.data;
-        if (isCompressed) {
-            const decompressed = decompressData(item.data, true);
-            finalData = JSON.parse(decompressed.data);
-        }
-        log$e.debug('Cache hit', { key, compressed: isCompressed });
-        return {
-            ...item,
-            data: finalData,
-            compressed: isCompressed,
-        };
-    }
-    async set(key, data) {
-        log$e.debug('Setting cache item', { key });
-        // Handle compression if enabled
-        let finalData = data;
-        let isCompressed = false;
-        if (this.options.compression && this.options.compressionThreshold) {
-            const serializedData = JSON.stringify(data);
-            const compressionResult = compressData(serializedData, this.options.compressionThreshold);
-            if (compressionResult.compressed) {
-                finalData = compressionResult.data;
-                isCompressed = true;
-                log$e.debug('Compression result', {
-                    key,
-                    originalSize: compressionResult.originalSize,
-                    compressedSize: compressionResult.compressedSize,
-                    savings: compressionResult.originalSize - compressionResult.compressedSize,
-                });
-            }
-        }
-        const item = {
-            data: finalData,
-            timestamp: Date.now(),
-            compressed: isCompressed,
-        };
-        return this.setItem(key, item);
-    }
-    async setItem(key, item) {
-        // Calculate size of new item
-        const newItemSize = this.calculateItemSize(key, item);
-        // If item already exists, subtract old size
-        if (this.cache.has(key)) {
-            const oldItem = this.cache.get(key);
-            const oldItemSize = this.calculateItemSize(key, oldItem);
-            this.totalBytes -= oldItemSize;
-        }
-        // Enforce max entries limit
-        if (this.cache.size >= (this.options.maxEntries || 1000) && !this.cache.has(key)) {
-            const oldestKey = this.cache.keys().next().value;
-            if (oldestKey) {
-                const oldestItem = this.cache.get(oldestKey);
-                const oldestItemSize = this.calculateItemSize(oldestKey, oldestItem);
-                this.totalBytes -= oldestItemSize;
-                this.cache.delete(oldestKey);
-                log$e.debug('Removed oldest item for capacity', { oldestKey, freedBytes: oldestItemSize });
-            }
-        }
-        // Set new item and update total size
-        this.cache.set(key, item);
-        this.totalBytes += newItemSize;
-        log$e.debug('Updated cache size', {
-            entries: this.cache.size,
-            totalBytes: this.totalBytes,
-            newItemSize,
-        });
-    }
-    async setBatch(items) {
-        if (items.length === 0)
-            return;
-        log$e.debug('Batch setting items', { count: items.length });
-        let totalNewBytes = 0;
-        let totalOldBytes = 0;
-        const itemsToRemove = [];
-        // First pass: calculate size changes and identify capacity issues
-        for (const [key, item] of items) {
-            const newItemSize = this.calculateItemSize(key, item);
-            totalNewBytes += newItemSize;
-            // If item already exists, track old size for removal
-            if (this.cache.has(key)) {
-                const oldItem = this.cache.get(key);
-                const oldItemSize = this.calculateItemSize(key, oldItem);
-                totalOldBytes += oldItemSize;
-            }
-        }
-        // Handle capacity limits - remove oldest items if needed
-        const projectedEntries = this.cache.size + items.filter(([key]) => !this.cache.has(key)).length;
-        const maxEntries = this.options.maxEntries || 1000;
-        if (projectedEntries > maxEntries) {
-            const entriesToRemove = projectedEntries - maxEntries;
-            const oldestKeys = Array.from(this.cache.keys()).slice(0, entriesToRemove);
-            for (const oldKey of oldestKeys) {
-                const oldItem = this.cache.get(oldKey);
-                const oldItemSize = this.calculateItemSize(oldKey, oldItem);
-                this.totalBytes -= oldItemSize;
-                this.cache.delete(oldKey);
-                itemsToRemove.push(oldKey);
-            }
-            if (itemsToRemove.length > 0) {
-                log$e.debug('Removed items for batch capacity', {
-                    removedCount: itemsToRemove.length,
-                    removedKeys: itemsToRemove,
-                });
-            }
-        }
-        // Update total bytes accounting
-        this.totalBytes = this.totalBytes - totalOldBytes + totalNewBytes;
-        // Second pass: set all items
-        for (const [key, item] of items) {
-            this.cache.set(key, item);
-        }
-        log$e.debug('Batch operation completed', {
-            count: items.length,
-            totalBytes: this.totalBytes,
-            entries: this.cache.size,
-            bytesAdded: totalNewBytes - totalOldBytes,
-        });
-    }
-    async invalidate(pattern) {
-        const regex = this.patternToRegex(pattern);
-        let removed = 0;
-        let bytesFreed = 0;
-        for (const key of this.cache.keys()) {
-            if (regex.test(key)) {
-                const item = this.cache.get(key);
-                const itemSize = this.calculateItemSize(key, item);
-                this.cache.delete(key);
-                this.totalBytes -= itemSize;
-                bytesFreed += itemSize;
-                removed++;
-            }
-        }
-        if (removed > 0) {
-            log$e.debug('Invalidation completed', {
-                pattern,
-                entriesRemoved: removed,
-                bytesFreed,
-                remainingEntries: this.cache.size,
-                remainingBytes: this.totalBytes,
-            });
-        }
-    }
-    async clear() {
-        this.cache.clear();
-        this.totalBytes = 0;
-        log$e.debug('Cache cleared', { entries: 0, bytes: 0 });
-    }
-    async getSize() {
-        return {
-            entries: this.cache.size,
-            bytes: this.totalBytes,
-            lastCleanup: Date.now(),
-        };
-    }
-    async cleanup() {
-        // No cleanup needed - cache never expires
-        return 0;
-    }
-    async getKeys(pattern) {
-        const keys = Array.from(this.cache.keys());
-        if (!pattern)
-            return keys;
-        const regex = this.patternToRegex(pattern);
-        return keys.filter((key) => regex.test(key));
-    }
-    patternToRegex(pattern) {
-        const escaped = pattern.replace(/[.+^${}()|[\]\\]/g, '\\$&');
-        const regexPattern = escaped.replace(/\\\*/g, '.*').replace(/\\\?/g, '.');
-        return new RegExp(`^${regexPattern}$`);
-    }
-}
-
-const instanceOfAny = (object, constructors) => constructors.some((c) => object instanceof c);
-
-let idbProxyableTypes;
-let cursorAdvanceMethods;
-// This is a function to prevent it throwing up in node environments.
-function getIdbProxyableTypes() {
-    return (idbProxyableTypes ||
-        (idbProxyableTypes = [
-            IDBDatabase,
-            IDBObjectStore,
-            IDBIndex,
-            IDBCursor,
-            IDBTransaction,
-        ]));
-}
-// This is a function to prevent it throwing up in node environments.
-function getCursorAdvanceMethods() {
-    return (cursorAdvanceMethods ||
-        (cursorAdvanceMethods = [
-            IDBCursor.prototype.advance,
-            IDBCursor.prototype.continue,
-            IDBCursor.prototype.continuePrimaryKey,
-        ]));
-}
-const transactionDoneMap = new WeakMap();
-const transformCache = new WeakMap();
-const reverseTransformCache = new WeakMap();
-function promisifyRequest(request) {
-    const promise = new Promise((resolve, reject) => {
-        const unlisten = () => {
-            request.removeEventListener('success', success);
-            request.removeEventListener('error', error);
-        };
-        const success = () => {
-            resolve(wrap(request.result));
-            unlisten();
-        };
-        const error = () => {
-            reject(request.error);
-            unlisten();
-        };
-        request.addEventListener('success', success);
-        request.addEventListener('error', error);
-    });
-    // This mapping exists in reverseTransformCache but doesn't exist in transformCache. This
-    // is because we create many promises from a single IDBRequest.
-    reverseTransformCache.set(promise, request);
-    return promise;
-}
-function cacheDonePromiseForTransaction(tx) {
-    // Early bail if we've already created a done promise for this transaction.
-    if (transactionDoneMap.has(tx))
-        return;
-    const done = new Promise((resolve, reject) => {
-        const unlisten = () => {
-            tx.removeEventListener('complete', complete);
-            tx.removeEventListener('error', error);
-            tx.removeEventListener('abort', error);
-        };
-        const complete = () => {
-            resolve();
-            unlisten();
-        };
-        const error = () => {
-            reject(tx.error || new DOMException('AbortError', 'AbortError'));
-            unlisten();
-        };
-        tx.addEventListener('complete', complete);
-        tx.addEventListener('error', error);
-        tx.addEventListener('abort', error);
-    });
-    // Cache it for later retrieval.
-    transactionDoneMap.set(tx, done);
-}
-let idbProxyTraps = {
-    get(target, prop, receiver) {
-        if (target instanceof IDBTransaction) {
-            // Special handling for transaction.done.
-            if (prop === 'done')
-                return transactionDoneMap.get(target);
-            // Make tx.store return the only store in the transaction, or undefined if there are many.
-            if (prop === 'store') {
-                return receiver.objectStoreNames[1]
-                    ? undefined
-                    : receiver.objectStore(receiver.objectStoreNames[0]);
-            }
-        }
-        // Else transform whatever we get back.
-        return wrap(target[prop]);
-    },
-    set(target, prop, value) {
-        target[prop] = value;
-        return true;
-    },
-    has(target, prop) {
-        if (target instanceof IDBTransaction &&
-            (prop === 'done' || prop === 'store')) {
-            return true;
-        }
-        return prop in target;
-    },
-};
-function replaceTraps(callback) {
-    idbProxyTraps = callback(idbProxyTraps);
-}
-function wrapFunction(func) {
-    // Due to expected object equality (which is enforced by the caching in `wrap`), we
-    // only create one new func per func.
-    // Cursor methods are special, as the behaviour is a little more different to standard IDB. In
-    // IDB, you advance the cursor and wait for a new 'success' on the IDBRequest that gave you the
-    // cursor. It's kinda like a promise that can resolve with many values. That doesn't make sense
-    // with real promises, so each advance methods returns a new promise for the cursor object, or
-    // undefined if the end of the cursor has been reached.
-    if (getCursorAdvanceMethods().includes(func)) {
-        return function (...args) {
-            // Calling the original function with the proxy as 'this' causes ILLEGAL INVOCATION, so we use
-            // the original object.
-            func.apply(unwrap(this), args);
-            return wrap(this.request);
-        };
-    }
-    return function (...args) {
-        // Calling the original function with the proxy as 'this' causes ILLEGAL INVOCATION, so we use
-        // the original object.
-        return wrap(func.apply(unwrap(this), args));
-    };
-}
-function transformCachableValue(value) {
-    if (typeof value === 'function')
-        return wrapFunction(value);
-    // This doesn't return, it just creates a 'done' promise for the transaction,
-    // which is later returned for transaction.done (see idbObjectHandler).
-    if (value instanceof IDBTransaction)
-        cacheDonePromiseForTransaction(value);
-    if (instanceOfAny(value, getIdbProxyableTypes()))
-        return new Proxy(value, idbProxyTraps);
-    // Return the same value back if we're not going to transform it.
-    return value;
-}
-function wrap(value) {
-    // We sometimes generate multiple promises from a single IDBRequest (eg when cursoring), because
-    // IDB is weird and a single IDBRequest can yield many responses, so these can't be cached.
-    if (value instanceof IDBRequest)
-        return promisifyRequest(value);
-    // If we've already transformed this value before, reuse the transformed value.
-    // This is faster, but it also provides object equality.
-    if (transformCache.has(value))
-        return transformCache.get(value);
-    const newValue = transformCachableValue(value);
-    // Not all types are transformed.
-    // These may be primitive types, so they can't be WeakMap keys.
-    if (newValue !== value) {
-        transformCache.set(value, newValue);
-        reverseTransformCache.set(newValue, value);
-    }
-    return newValue;
-}
-const unwrap = (value) => reverseTransformCache.get(value);
-
-/**
- * Open a database.
- *
- * @param name Name of the database.
- * @param version Schema version.
- * @param callbacks Additional callbacks.
- */
-function openDB(name, version, { blocked, upgrade, blocking, terminated } = {}) {
-    const request = indexedDB.open(name, version);
-    const openPromise = wrap(request);
-    if (upgrade) {
-        request.addEventListener('upgradeneeded', (event) => {
-            upgrade(wrap(request.result), event.oldVersion, event.newVersion, wrap(request.transaction), event);
-        });
-    }
-    if (blocked) {
-        request.addEventListener('blocked', (event) => blocked(
-        // Casting due to https://github.com/microsoft/TypeScript-DOM-lib-generator/pull/1405
-        event.oldVersion, event.newVersion, event));
-    }
-    openPromise
-        .then((db) => {
-        if (terminated)
-            db.addEventListener('close', () => terminated());
-        if (blocking) {
-            db.addEventListener('versionchange', (event) => blocking(event.oldVersion, event.newVersion, event));
-        }
-    })
-        .catch(() => { });
-    return openPromise;
-}
-/**
- * Delete a database.
- *
- * @param name Name of the database.
- */
-function deleteDB(name, { blocked } = {}) {
-    const request = indexedDB.deleteDatabase(name);
-    if (blocked) {
-        request.addEventListener('blocked', (event) => blocked(
-        // Casting due to https://github.com/microsoft/TypeScript-DOM-lib-generator/pull/1405
-        event.oldVersion, event));
-    }
-    return wrap(request).then(() => undefined);
-}
-
-const readMethods = ['get', 'getKey', 'getAll', 'getAllKeys', 'count'];
-const writeMethods = ['put', 'add', 'delete', 'clear'];
-const cachedMethods = new Map();
-function getMethod(target, prop) {
-    if (!(target instanceof IDBDatabase &&
-        !(prop in target) &&
-        typeof prop === 'string')) {
-        return;
-    }
-    if (cachedMethods.get(prop))
-        return cachedMethods.get(prop);
-    const targetFuncName = prop.replace(/FromIndex$/, '');
-    const useIndex = prop !== targetFuncName;
-    const isWrite = writeMethods.includes(targetFuncName);
-    if (
-    // Bail if the target doesn't exist on the target. Eg, getAll isn't in Edge.
-    !(targetFuncName in (useIndex ? IDBIndex : IDBObjectStore).prototype) ||
-        !(isWrite || readMethods.includes(targetFuncName))) {
-        return;
-    }
-    const method = async function (storeName, ...args) {
-        // isWrite ? 'readwrite' : undefined gzipps better, but fails in Edge :(
-        const tx = this.transaction(storeName, isWrite ? 'readwrite' : 'readonly');
-        let target = tx.store;
-        if (useIndex)
-            target = target.index(args.shift());
-        // Must reject if op rejects.
-        // If it's a write operation, must reject if tx.done rejects.
-        // Must reject with op rejection first.
-        // Must resolve with op value.
-        // Must handle both promises (no unhandled rejections)
-        return (await Promise.all([
-            target[targetFuncName](...args),
-            isWrite && tx.done,
-        ]))[0];
-    };
-    cachedMethods.set(prop, method);
-    return method;
-}
-replaceTraps((oldTraps) => ({
-    ...oldTraps,
-    get: (target, prop, receiver) => getMethod(target, prop) || oldTraps.get(target, prop, receiver),
-    has: (target, prop) => !!getMethod(target, prop) || oldTraps.has(target, prop),
-}));
-
-const advanceMethodProps = ['continue', 'continuePrimaryKey', 'advance'];
-const methodMap = {};
-const advanceResults = new WeakMap();
-const ittrProxiedCursorToOriginalProxy = new WeakMap();
-const cursorIteratorTraps = {
-    get(target, prop) {
-        if (!advanceMethodProps.includes(prop))
-            return target[prop];
-        let cachedFunc = methodMap[prop];
-        if (!cachedFunc) {
-            cachedFunc = methodMap[prop] = function (...args) {
-                advanceResults.set(this, ittrProxiedCursorToOriginalProxy.get(this)[prop](...args));
-            };
-        }
-        return cachedFunc;
-    },
-};
-async function* iterate(...args) {
-    // tslint:disable-next-line:no-this-assignment
-    let cursor = this;
-    if (!(cursor instanceof IDBCursor)) {
-        cursor = await cursor.openCursor(...args);
-    }
-    if (!cursor)
-        return;
-    cursor = cursor;
-    const proxiedCursor = new Proxy(cursor, cursorIteratorTraps);
-    ittrProxiedCursorToOriginalProxy.set(proxiedCursor, cursor);
-    // Map this double-proxy back to the original, so other cursor methods work.
-    reverseTransformCache.set(proxiedCursor, unwrap(cursor));
-    while (cursor) {
-        yield proxiedCursor;
-        // If one of the advancing methods was not called, call continue().
-        cursor = await (advanceResults.get(proxiedCursor) || cursor.continue());
-        advanceResults.delete(proxiedCursor);
-    }
-}
-function isIteratorProp(target, prop) {
-    return ((prop === Symbol.asyncIterator &&
-        instanceOfAny(target, [IDBIndex, IDBObjectStore, IDBCursor])) ||
-        (prop === 'iterate' && instanceOfAny(target, [IDBIndex, IDBObjectStore])));
-}
-replaceTraps((oldTraps) => ({
-    ...oldTraps,
-    get(target, prop, receiver) {
-        if (isIteratorProp(target, prop))
-            return iterate;
-        return oldTraps.get(target, prop, receiver);
-    },
-    has(target, prop) {
-        return isIteratorProp(target, prop) || oldTraps.has(target, prop);
-    },
-}));
-
-const log$d = createPrefixedLogger('CACHE-WEB');
-/**
- * Web cache adapter using IndexedDB with automatic error recovery
- * Cache never expires - data persists until explicitly invalidated
- */
-class WebCacheAdapter {
-    constructor(options = {}) {
-        this.db = null;
-        this.initPromise = null;
-        this.retryCount = 0;
-        this.maxRetries = 3;
-        this.options = {
-            maxSize: 50 * 1024 * 1024, // 50MB
-            maxEntries: 10000,
-            compression: false,
-            compressionThreshold: 1024,
-            ...options,
-        };
-        this.initPromise = this.initialize();
-    }
-    async initialize() {
-        if (this.db)
-            return;
-        log$d.debug('Initializing IndexedDB cache', {
-            dbName: WebCacheAdapter.DB_NAME,
-            version: WebCacheAdapter.DB_VERSION,
-        });
-        try {
-            this.db = await this.openDatabase();
-            log$d.debug('IndexedDB cache initialized successfully');
-            this.retryCount = 0; // Reset retry count on success
-        }
-        catch (error) {
-            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
-            log$d.debug('Failed to initialize IndexedDB', { error: errorMessage });
-            // Check if this is a version conflict error
-            if (this.isVersionConflictError(errorMessage)) {
-                await this.handleVersionConflict();
-            }
-            else {
-                throw new Error(`Failed to initialize IndexedDB: ${errorMessage}`);
-            }
-        }
-    }
-    async openDatabase() {
-        return await openDB(WebCacheAdapter.DB_NAME, WebCacheAdapter.DB_VERSION, {
-            upgrade: (db, oldVersion, newVersion, transaction) => {
-                log$d.debug('Database upgrade needed', { oldVersion, newVersion });
-                this.handleUpgrade(db, oldVersion, newVersion, transaction);
-            },
-            blocked: () => {
-                log$d.debug('Database blocked - another tab may be open');
-            },
-            blocking: () => {
-                log$d.debug('Database blocking - will close connection');
-                if (this.db) {
-                    this.db.close();
-                    this.db = null;
-                }
-            },
-            terminated: () => {
-                log$d.debug('Database connection terminated unexpectedly');
-                this.db = null;
-            },
-        });
-    }
-    handleUpgrade(db, oldVersion, newVersion, transaction) {
-        log$d.debug('Handling database upgrade', { oldVersion, newVersion });
-        // Create cache store if it doesn't exist (initial setup)
-        if (!db.objectStoreNames.contains(WebCacheAdapter.STORE_NAME)) {
-            const store = db.createObjectStore(WebCacheAdapter.STORE_NAME, { keyPath: 'key' });
-            store.createIndex('timestamp', 'timestamp', { unique: false });
-            log$d.debug('Created cache store and timestamp index');
-        }
-        // Handle migration from version 1 to 2
-        if (oldVersion < 2) {
-            const store = transaction.objectStore(WebCacheAdapter.STORE_NAME);
-            // Remove unused indexes from simplified cache structure
-            const indexesToRemove = ['tags', 'source', 'syncStatus'];
-            indexesToRemove.forEach((indexName) => {
-                try {
-                    if (store.indexNames.contains(indexName)) {
-                        store.deleteIndex(indexName);
-                        log$d.debug(`Removed unused index: ${indexName}`);
-                    }
-                }
-                catch (error) {
-                    // Ignore errors if indexes don't exist
-                    log$d.debug(`Warning: Could not remove index ${indexName}`, error);
-                }
-            });
-        }
-        log$d.debug('Database upgrade completed');
-    }
-    isVersionConflictError(errorMessage) {
-        return (errorMessage.includes('less than the existing version') ||
-            errorMessage.includes('version conflict') ||
-            errorMessage.includes('VersionError'));
-    }
-    async handleVersionConflict() {
-        log$d.debug('Handling version conflict, attempting recovery...');
-        if (this.retryCount >= this.maxRetries) {
-            throw new Error('Failed to resolve IndexedDB version conflict after multiple attempts');
-        }
-        this.retryCount++;
-        try {
-            // Close any existing connection
-            if (this.db) {
-                this.db.close();
-                this.db = null;
-            }
-            // Delete the problematic database
-            log$d.debug('Deleting problematic database to resolve version conflict');
-            await deleteDB(WebCacheAdapter.DB_NAME);
-            // Wait a bit for the deletion to complete
-            await new Promise((resolve) => setTimeout(resolve, 200));
-            // Try to open the database again
-            log$d.debug(`Retrying database initialization (attempt ${this.retryCount}/${this.maxRetries})`);
-            this.db = await this.openDatabase();
-            log$d.debug('Successfully recovered from version conflict');
-            this.retryCount = 0; // Reset retry count on success
-        }
-        catch (retryError) {
-            const retryErrorMessage = retryError instanceof Error ? retryError.message : 'Unknown error';
-            log$d.debug('Recovery attempt failed', { attempt: this.retryCount, error: retryErrorMessage });
-            if (this.retryCount < this.maxRetries) {
-                // Try again
-                await this.handleVersionConflict();
-            }
-            else {
-                throw new Error(`Failed to recover from IndexedDB version conflict: ${retryErrorMessage}`);
-            }
-        }
-    }
-    async get(key) {
-        await this.ensureInitialized();
-        log$d.debug('Getting cache item', { key });
-        try {
-            const transaction = this.db.transaction([WebCacheAdapter.STORE_NAME], 'readonly');
-            const store = transaction.objectStore(WebCacheAdapter.STORE_NAME);
-            const result = await store.get(key);
-            if (!result) {
-                return null;
-            }
-            const item = result;
-            // Handle decompression if needed
-            const isCompressed = !!item.compressed;
-            let finalData;
-            if (isCompressed) {
-                const decompressed = decompressData(item.data, true);
-                finalData = JSON.parse(decompressed.data);
-            }
-            else {
-                finalData = item.data;
-            }
-            return {
-                data: finalData,
-                timestamp: item.timestamp,
-                compressed: isCompressed,
-            };
-        }
-        catch (error) {
-            log$d.debug('Error getting cache item', { key, error });
-            return null; // Return null on error instead of throwing
-        }
-    }
-    async set(key, data) {
-        const item = {
-            data,
-            timestamp: Date.now(),
-        };
-        return this.setItem(key, item);
-    }
-    async setItem(key, item) {
-        await this.ensureInitialized();
-        // Handle compression if enabled
-        let finalData = item.data;
-        let isCompressed = false;
-        if (this.options.compression && this.options.compressionThreshold) {
-            const serializedData = JSON.stringify(item.data);
-            const compressionResult = compressData(serializedData, this.options.compressionThreshold);
-            if (compressionResult.compressed) {
-                finalData = compressionResult.data;
-                isCompressed = true;
-                log$d.debug('Compression result', {
-                    key,
-                    originalSize: compressionResult.originalSize,
-                    compressedSize: compressionResult.compressedSize,
-                    compressed: isCompressed,
-                    savings: compressionResult.originalSize - compressionResult.compressedSize,
-                });
-            }
-        }
-        log$d.debug('Setting cache item', { key, timestamp: item.timestamp, compressed: isCompressed });
-        const storedItem = {
-            key,
-            data: finalData,
-            timestamp: item.timestamp,
-            compressed: isCompressed,
-        };
-        try {
-            const transaction = this.db.transaction([WebCacheAdapter.STORE_NAME], 'readwrite');
-            const store = transaction.objectStore(WebCacheAdapter.STORE_NAME);
-            await store.put(storedItem);
-        }
-        catch (error) {
-            log$d.debug('Error setting cache item', { key, error });
-            // Silently fail for cache writes
+                message.includes('tls') ||
+                message.includes('handshake'));
         }
+        return false;
     }
-    async setBatch(items) {
-        if (items.length === 0)
-            return;
-        await this.ensureInitialized();
-        log$d.debug('Batch setting items', { count: items.length });
-        try {
-            const transaction = this.db.transaction([WebCacheAdapter.STORE_NAME], 'readwrite');
-            const store = transaction.objectStore(WebCacheAdapter.STORE_NAME);
-            // Process all items in the transaction
-            const promises = items.map(([key, item]) => {
-                const storedItem = this.prepareBatchItem(key, item);
-                return store.put(storedItem);
-            });
-            await Promise.all(promises);
-            log$d.debug('Batch operation completed', { count: items.length });
-        }
-        catch (error) {
-            log$d.debug('Error in batch operation', { count: items.length, error });
-            // Silently fail for batch writes
-        }
-    }
-    prepareBatchItem(key, item) {
-        // Handle compression if enabled (same logic as setItem)
-        let finalData = item.data;
-        let isCompressed = false;
-        if (this.options.compression && this.options.compressionThreshold) {
-            const serializedData = JSON.stringify(item.data);
-            const compressionResult = compressData(serializedData, this.options.compressionThreshold);
-            if (compressionResult.compressed) {
-                finalData = compressionResult.data;
-                isCompressed = true;
-            }
+    async configureCertificate(certificate) {
+        if (!this.mtlsAdapter) {
+            throw new Error('mTLS adapter not available');
         }
-        return {
-            key,
-            data: finalData,
-            timestamp: item.timestamp,
-            compressed: isCompressed,
+        const certificateData = {
+            certificate: certificate.certificate,
+            privateKey: certificate.privateKey,
+            format: certificate.format.toUpperCase(),
         };
+        await this.mtlsAdapter.configureCertificate(certificateData);
     }
-    async invalidate(pattern) {
-        await this.ensureInitialized();
-        const keys = await this.getKeys(pattern);
-        const deletePromises = keys.map((key) => this.delete(key));
-        await Promise.all(deletePromises);
-    }
-    async clear() {
-        await this.ensureInitialized();
-        try {
-            const transaction = this.db.transaction([WebCacheAdapter.STORE_NAME], 'readwrite');
-            const store = transaction.objectStore(WebCacheAdapter.STORE_NAME);
-            await store.clear();
-            log$d.debug('Cache cleared successfully');
-        }
-        catch (error) {
-            log$d.debug('Error clearing cache', error);
-            // Silently fail for cache clear
+    async storeCertificate(certificate, privateKey, options = {}) {
+        if (!this.certificatePort) {
+            throw new Error('Certificate port not available');
         }
-    }
-    async getSize() {
-        await this.ensureInitialized();
-        try {
-            const transaction = this.db.transaction([WebCacheAdapter.STORE_NAME], 'readonly');
-            const store = transaction.objectStore(WebCacheAdapter.STORE_NAME);
-            let entries = 0;
-            let bytes = 0;
-            // Use cursor for efficient iteration
-            let cursor = await store.openCursor();
-            while (cursor) {
-                entries++;
-                // Rough estimation of size
-                bytes += JSON.stringify(cursor.value).length * 2; // UTF-16 encoding
-                cursor = await cursor.continue();
+        if (this.mtlsAdapter) {
+            try {
+                await this.mtlsAdapter.removeCertificate();
+            }
+            catch {
+                // No existing certificate to remove
             }
-            return {
-                entries,
-                bytes,
-                lastCleanup: Date.now(),
-            };
         }
-        catch (error) {
-            log$d.debug('Error getting cache size', error);
-            return {
-                entries: 0,
-                bytes: 0,
-                lastCleanup: Date.now(),
+        const format = (options.format || 'pem');
+        await this.certificatePort.storeCertificate(certificate, privateKey, format);
+        if (this.mtlsAdapter) {
+            const certificateData = {
+                certificate,
+                privateKey,
+                format: format.toUpperCase(),
             };
+            await this.mtlsAdapter.configureCertificate(certificateData);
         }
     }
-    async cleanup() {
-        // No cleanup needed - cache never expires
-        return 0;
-    }
-    async getKeys(pattern) {
-        await this.ensureInitialized();
-        try {
-            const transaction = this.db.transaction([WebCacheAdapter.STORE_NAME], 'readonly');
-            const store = transaction.objectStore(WebCacheAdapter.STORE_NAME);
-            const allKeys = (await store.getAllKeys());
-            if (!pattern) {
-                return allKeys;
+    async clearCertificate() {
+        if (this.mtlsAdapter) {
+            try {
+                await this.mtlsAdapter.removeCertificate();
+            }
+            catch {
+                // No certificate to remove
             }
-            const regex = this.patternToRegex(pattern);
-            return allKeys.filter((key) => regex.test(key));
         }
-        catch (error) {
-            log$d.debug('Error getting cache keys', error);
-            return [];
+        if (this.certificatePort) {
+            await this.certificatePort.clearCertificate();
         }
     }
-    async delete(key) {
-        await this.ensureInitialized();
-        try {
-            const transaction = this.db.transaction([WebCacheAdapter.STORE_NAME], 'readwrite');
-            const store = transaction.objectStore(WebCacheAdapter.STORE_NAME);
-            await store.delete(key);
-            return true;
-        }
-        catch (error) {
-            log$d.debug('Error deleting cache item', { key, error });
+    async testConnection() {
+        if (!this.mtlsAdapter) {
             return false;
         }
+        return this.mtlsAdapter.testConnection();
     }
-    async ensureInitialized() {
-        if (!this.initPromise) {
-            this.initPromise = this.initialize();
-        }
-        try {
-            await this.initPromise;
-        }
-        catch (error) {
-            log$d.debug('Failed to ensure initialization', error);
-            // Reset and try once more
-            this.initPromise = null;
-            this.db = null;
-            this.initPromise = this.initialize();
-            await this.initPromise;
+    getBaseUrl() {
+        if (!this.mtlsAdapter) {
+            return null;
         }
+        return this.mtlsAdapter.getBaseUrl();
     }
-    patternToRegex(pattern) {
-        // Convert simple glob patterns to regex
-        const escaped = pattern.replace(/[.+^${}()|[\]\\]/g, '\\$&');
-        const regexPattern = escaped.replace(/\\\*/g, '.*').replace(/\\\?/g, '.');
-        return new RegExp(`^${regexPattern}$`);
-    }
-}
-WebCacheAdapter.DB_NAME = 'acube_cache';
-WebCacheAdapter.DB_VERSION = 2;
-WebCacheAdapter.STORE_NAME = 'cache_entries';
-
-const log$c = createPrefixedLogger('CACHE-LOADER');
-function loadCacheAdapter(platform) {
-    try {
-        switch (platform) {
-            case 'web':
-                return new WebCacheAdapter({
-                    maxSize: 50 * 1024 * 1024,
-                    maxEntries: 10000,
-                    compression: false,
-                });
-            case 'react-native':
-                try {
-                    return new ReactNativeCacheAdapter({
-                        maxSize: 100 * 1024 * 1024,
-                        maxEntries: 15000,
-                    });
-                }
-                catch {
-                    return new MemoryCacheAdapter({
-                        maxSize: 10 * 1024 * 1024,
-                        maxEntries: 5000,
-                    });
+    async getStatus() {
+        const status = {
+            adapterAvailable: !!this.mtlsAdapter,
+            certificatePortAvailable: !!this.certificatePort,
+            isReady: false,
+            hasCertificate: false,
+            certificateInfo: null,
+            platformInfo: this.mtlsAdapter?.getPlatformInfo() || null,
+            pendingRequestsCount: this.pendingRequests.size,
+        };
+        if (this.certificatePort) {
+            try {
+                status.hasCertificate = await this.certificatePort.hasCertificate();
+                if (status.hasCertificate) {
+                    status.certificateInfo = await this.certificatePort.getCertificateInfo();
                 }
-            case 'node':
-            default:
-                return new MemoryCacheAdapter({
-                    maxSize: 10 * 1024 * 1024,
-                    maxEntries: 5000,
-                });
+            }
+            catch {
+                // Ignore errors
+            }
         }
+        status.isReady = await this.isMtlsReady();
+        return status;
     }
-    catch (error) {
-        log$c.warn(`Cache adapter not available for platform ${platform}:`, error);
-        return undefined;
+    clearPendingRequests() {
+        this.pendingRequests.clear();
     }
 }
 
-/**
- * Mixin that adds multiGet, multiSet, multiRemove to any storage adapter
- * Eliminates duplicate code across Node, Web, and React Native adapters
- */
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
 /**
  * Abstract base class for standard storage adapters
  * Implements multi-operations, subclasses implement core operations
@@ -5208,7 +2893,7 @@ class BaseSecureStorageAdapter {
     }
 }
 
-const log$b = createPrefixedLogger('NETWORK-BASE');
+const log$8 = createPrefixedLogger('NETWORK-BASE');
 class NetworkBase {
     constructor(initialOnline = true, debounceMs = 300) {
         this.destroy$ = new Subject();
@@ -5228,14 +2913,14 @@ class NetworkBase {
         const current = this.statusSubject.getValue();
         if (current.online !== online) {
             this.statusSubject.next({ online, timestamp: Date.now() });
-            log$b.debug(`Network status changed: ${online ? 'online' : 'offline'}`);
+            log$8.debug(`Network status changed: ${online ? 'online' : 'offline'}`);
         }
     }
     destroy() {
         this.destroy$.next();
         this.destroy$.complete();
         this.statusSubject.complete();
-        log$b.debug('Network monitor destroyed');
+        log$8.debug('Network monitor destroyed');
     }
 }
 
@@ -5295,7 +2980,7 @@ class NodeSecureStorageAdapter extends BaseSecureStorageAdapter {
     }
 }
 
-const log$a = createPrefixedLogger('RN-STORAGE');
+const log$7 = createPrefixedLogger('RN-STORAGE');
 /**
  * React Native storage adapter using AsyncStorage
  * Note: Uses native batch operations for better performance (not base class)
@@ -5327,7 +3012,7 @@ class ReactNativeStorageAdapter {
             return await this.AsyncStorage.getItem(key);
         }
         catch (error) {
-            log$a.error('Failed to get item from AsyncStorage:', error);
+            log$7.error('Failed to get item from AsyncStorage:', error);
             return null;
         }
     }
@@ -5368,7 +3053,7 @@ class ReactNativeStorageAdapter {
             return await this.AsyncStorage.getAllKeys();
         }
         catch (error) {
-            log$a.error('Failed to get all keys:', error);
+            log$7.error('Failed to get all keys:', error);
             return [];
         }
     }
@@ -5385,7 +3070,7 @@ class ReactNativeStorageAdapter {
             return result;
         }
         catch (error) {
-            log$a.error('Failed to get multiple items:', error);
+            log$7.error('Failed to get multiple items:', error);
             const result = {};
             keys.forEach((key) => {
                 result[key] = null;
@@ -5435,7 +3120,7 @@ class ReactNativeSecureStorageAdapter extends BaseSecureStorageAdapter {
             return;
         }
         catch {
-            log$a.debug('expo-secure-store not available, trying react-native-keychain');
+            log$7.debug('expo-secure-store not available, trying react-native-keychain');
         }
         try {
             const Keychain = require('react-native-keychain');
@@ -5444,7 +3129,7 @@ class ReactNativeSecureStorageAdapter extends BaseSecureStorageAdapter {
             return;
         }
         catch {
-            log$a.error('react-native-keychain not available');
+            log$7.error('react-native-keychain not available');
         }
         throw new Error('No secure storage available. Please install expo-secure-store or react-native-keychain');
     }
@@ -5462,7 +3147,7 @@ class ReactNativeSecureStorageAdapter extends BaseSecureStorageAdapter {
             }
         }
         catch (error) {
-            log$a.error('Failed to get secure item:', error);
+            log$7.error('Failed to get secure item:', error);
         }
         return null;
     }
@@ -5499,10 +3184,10 @@ class ReactNativeSecureStorageAdapter extends BaseSecureStorageAdapter {
         }
     }
     async clear() {
-        log$a.warn('Clear all secure items not fully implemented for React Native');
+        log$7.warn('Clear all secure items not fully implemented for React Native');
     }
     async getAllKeys() {
-        log$a.warn('Get all secure keys not implemented for React Native');
+        log$7.warn('Get all secure keys not implemented for React Native');
         return [];
     }
     async isAvailable() {
@@ -5720,7 +3405,7 @@ class NodeNetworkMonitor extends NetworkBase {
     }
 }
 
-const log$9 = createPrefixedLogger('RN-NETWORK');
+const log$6 = createPrefixedLogger('RN-NETWORK');
 /**
  * React Native network monitor using RxJS
  * Supports both @react-native-community/netinfo and expo-network
@@ -5733,7 +3418,7 @@ class ReactNativeNetworkMonitor extends NetworkBase {
         this.moduleReady$ = new Subject();
         this.isExpo = detectPlatform().isExpo;
         this.init().catch((error) => {
-            log$9.error('Network monitor initialization failed:', error);
+            log$6.error('Network monitor initialization failed:', error);
         });
     }
     async init() {
@@ -5752,10 +3437,10 @@ class ReactNativeNetworkMonitor extends NetworkBase {
         try {
             const module = require('@react-native-community/netinfo');
             this.netInfoModule = module.default || module;
-            log$9.debug('Loaded @react-native-community/netinfo module');
+            log$6.debug('Loaded @react-native-community/netinfo module');
         }
         catch (error) {
-            log$9.error('Failed to load React Native NetInfo module:', error);
+            log$6.error('Failed to load React Native NetInfo module:', error);
             this.netInfoModule = null;
         }
     }
@@ -5763,10 +3448,10 @@ class ReactNativeNetworkMonitor extends NetworkBase {
         try {
             const module = require('expo-network');
             this.netInfoModule = module.default || module;
-            log$9.debug('Loaded expo-network module');
+            log$6.debug('Loaded expo-network module');
         }
         catch (error) {
-            log$9.error('Failed to load Expo Network module:', error);
+            log$6.error('Failed to load Expo Network module:', error);
             this.netInfoModule = null;
         }
     }
@@ -5783,16 +3468,16 @@ class ReactNativeNetworkMonitor extends NetworkBase {
             }
             const online = !!(state.isConnected && state.isInternetReachable !== false);
             this.updateStatus(online);
-            log$9.debug('Initial network state:', online ? 'online' : 'offline');
+            log$6.debug('Initial network state:', online ? 'online' : 'offline');
         }
         catch (error) {
-            log$9.warn('Could not fetch initial network state:', error);
+            log$6.warn('Could not fetch initial network state:', error);
         }
     }
     subscribeToStateChanges() {
         if (!this.netInfoModule)
             return;
-        log$9.debug('Subscribing to network state changes');
+        log$6.debug('Subscribing to network state changes');
         const handleState = (state) => {
             const online = !!(state.isConnected && (state.isInternetReachable ?? true));
             this.updateStatus(online);
@@ -5834,7 +3519,7 @@ class ReactNativeNetworkMonitor extends NetworkBase {
             };
         }
         catch (error) {
-            log$9.error('Failed to fetch detailed network info:', error);
+            log$6.error('Failed to fetch detailed network info:', error);
             return null;
         }
     }
@@ -5934,7 +3619,7 @@ function loadNetworkMonitor(platform) {
     }
 }
 
-var MTLSErrorType$1;
+var MTLSErrorType;
 (function (MTLSErrorType) {
     MTLSErrorType["NOT_SUPPORTED"] = "MTLS_NOT_SUPPORTED";
     MTLSErrorType["CERTIFICATE_NOT_FOUND"] = "MTLS_CERTIFICATE_NOT_FOUND";
@@ -5943,7 +3628,7 @@ var MTLSErrorType$1;
     MTLSErrorType["CONNECTION_FAILED"] = "MTLS_CONNECTION_FAILED";
     MTLSErrorType["AUTHENTICATION_FAILED"] = "MTLS_AUTHENTICATION_FAILED";
     MTLSErrorType["CONFIGURATION_ERROR"] = "MTLS_CONFIGURATION_ERROR";
-})(MTLSErrorType$1 || (MTLSErrorType$1 = {}));
+})(MTLSErrorType || (MTLSErrorType = {}));
 class MTLSError extends Error {
     constructor(type, message, originalError, statusCode) {
         super(message);
@@ -5970,7 +3655,7 @@ class CertificateValidator {
     }
 }
 
-const log$8 = createPrefixedLogger('RN-MTLS');
+const log$5 = createPrefixedLogger('RN-MTLS');
 /**
  * React Native mTLS Adapter using @a-cube-io/expo-mutual-tls
  */
@@ -5992,7 +3677,7 @@ class ReactNativeMTLSAdapter {
             this.expoMTLS = ExpoMutualTls;
             // Set up debug logging with the correct event signature
             const debugListener = ExpoMutualTls.onDebugLog((event) => {
-                log$8.debug(`${event.type}: ${event.message}`, {
+                log$5.debug(`${event.type}: ${event.message}`, {
                     method: event.method,
                     url: event.url,
                     statusCode: event.statusCode,
@@ -6002,28 +3687,28 @@ class ReactNativeMTLSAdapter {
             this.eventListeners.push(debugListener);
             // Set up error logging with the correct event signature
             const errorListener = ExpoMutualTls.onError((event) => {
-                log$8.error(event.message, {
+                log$5.error(event.message, {
                     code: event.code,
                 });
             });
             this.eventListeners.push(errorListener);
             // Set up certificate expiry monitoring with the correct event signature
             const expiryListener = ExpoMutualTls.onCertificateExpiry((event) => {
-                log$8.warn(`Certificate ${event.subject} expires at ${new Date(event.expiry)}`, {
+                log$5.warn(`Certificate ${event.subject} expires at ${new Date(event.expiry)}`, {
                     alias: event.alias,
                     warning: event.warning,
                 });
             });
             this.eventListeners.push(expiryListener);
-            log$8.debug('Expo mTLS module loaded successfully');
+            log$5.debug('Expo mTLS module loaded successfully');
         }
         catch (error) {
-            log$8.warn('@a-cube-io/expo-mutual-tls not available:', error);
+            log$5.warn('@a-cube-io/expo-mutual-tls not available:', error);
         }
     }
     async isMTLSSupported() {
         const supported = this.expoMTLS !== null;
-        log$8.debug('mTLS support check:', {
+        log$5.debug('mTLS support check:', {
             supported,
             platform: this.getPlatformInfo().platform,
             moduleAvailable: !!this.expoMTLS,
@@ -6032,10 +3717,10 @@ class ReactNativeMTLSAdapter {
     }
     async initialize(config) {
         if (!this.expoMTLS) {
-            throw new MTLSError(MTLSErrorType$1.NOT_SUPPORTED, 'Expo mTLS module not available');
+            throw new MTLSError(MTLSErrorType.NOT_SUPPORTED, 'Expo mTLS module not available');
         }
         this.config = config;
-        log$8.debug('Initialized with config:', {
+        log$5.debug('Initialized with config:', {
             baseUrl: config.baseUrl,
             port: config.port,
             timeout: config.timeout,
@@ -6044,12 +3729,12 @@ class ReactNativeMTLSAdapter {
     }
     async configureCertificate(certificateData) {
         if (!this.expoMTLS) {
-            throw new MTLSError(MTLSErrorType$1.NOT_SUPPORTED, 'Expo mTLS module not available');
+            throw new MTLSError(MTLSErrorType.NOT_SUPPORTED, 'Expo mTLS module not available');
         }
         if (!this.config) {
-            throw new MTLSError(MTLSErrorType$1.CONFIGURATION_ERROR, 'Adapter not initialized. Call initialize() first.');
+            throw new MTLSError(MTLSErrorType.CONFIGURATION_ERROR, 'Adapter not initialized. Call initialize() first.');
         }
-        log$8.debug('Configuring certificate:', {
+        log$5.debug('Configuring certificate:', {
             format: certificateData.format,
             hasPassword: !!certificateData.password,
             certificateLength: certificateData.certificate.length,
@@ -6059,47 +3744,47 @@ class ReactNativeMTLSAdapter {
             if (certificateData.format === 'PEM') {
                 // Validate PEM format
                 if (!CertificateValidator.validatePEMFormat(certificateData.certificate, certificateData.privateKey)) {
-                    throw new MTLSError(MTLSErrorType$1.CERTIFICATE_INVALID, 'Invalid PEM certificate format');
+                    throw new MTLSError(MTLSErrorType.CERTIFICATE_INVALID, 'Invalid PEM certificate format');
                 }
                 // Step 1: Configure PEM services (optional parameters for keychain services)
                 const configResult = await this.expoMTLS.configurePEM('client-cert-service', // certService
                 'client-key-service', // keyService
                 true // enableLogging - let the native module handle its own debug logging
                 );
-                log$8.debug('PEM services configured:', configResult);
+                log$5.debug('PEM services configured:', configResult);
                 if (!configResult.success) {
-                    throw new MTLSError(MTLSErrorType$1.CONFIGURATION_ERROR, `PEM configuration failed: ${configResult.state}`);
+                    throw new MTLSError(MTLSErrorType.CONFIGURATION_ERROR, `PEM configuration failed: ${configResult.state}`);
                 }
                 // Step 2: Store the actual PEM certificate and private key
                 const storeResult = await this.expoMTLS.storePEM(certificateData.certificate, certificateData.privateKey, certificateData.password // passphrase (optional)
                 );
-                log$8.debug('PEM certificate store result:', storeResult);
+                log$5.debug('PEM certificate store result:', storeResult);
                 if (!storeResult) {
-                    throw new MTLSError(MTLSErrorType$1.CERTIFICATE_INVALID, 'Failed to store PEM certificate');
+                    throw new MTLSError(MTLSErrorType.CERTIFICATE_INVALID, 'Failed to store PEM certificate');
                 }
             }
             else if (certificateData.format === 'P12') {
                 if (!certificateData.password) {
-                    throw new MTLSError(MTLSErrorType$1.CONFIGURATION_ERROR, 'P12 certificate requires password');
+                    throw new MTLSError(MTLSErrorType.CONFIGURATION_ERROR, 'P12 certificate requires password');
                 }
                 // Step 1: Configure P12 keychain service
                 const configResult = await this.expoMTLS.configureP12('client-p12-service', // keychainService
                 true // enableLogging - let the native module handle its own debug logging
                 );
-                log$8.debug('P12 service configured:', configResult);
+                log$5.debug('P12 service configured:', configResult);
                 if (!configResult.success) {
-                    throw new MTLSError(MTLSErrorType$1.CONFIGURATION_ERROR, `P12 configuration failed: ${configResult.state}`);
+                    throw new MTLSError(MTLSErrorType.CONFIGURATION_ERROR, `P12 configuration failed: ${configResult.state}`);
                 }
                 // Step 2: Store the P12 certificate data
                 const storeResult = await this.expoMTLS.storeP12(certificateData.certificate, // P12 data in certificate field
                 certificateData.password);
-                log$8.debug('P12 certificate store result:', storeResult);
+                log$5.debug('P12 certificate store result:', storeResult);
                 if (!storeResult) {
-                    throw new MTLSError(MTLSErrorType$1.CERTIFICATE_INVALID, 'Failed to store P12 certificate');
+                    throw new MTLSError(MTLSErrorType.CERTIFICATE_INVALID, 'Failed to store P12 certificate');
                 }
             }
             else {
-                throw new MTLSError(MTLSErrorType$1.CERTIFICATE_INVALID, `Unsupported certificate format: ${certificateData.format}`);
+                throw new MTLSError(MTLSErrorType.CERTIFICATE_INVALID, `Unsupported certificate format: ${certificateData.format}`);
             }
             this.isConfigured = true;
         }
@@ -6107,8 +3792,8 @@ class ReactNativeMTLSAdapter {
             if (error instanceof MTLSError) {
                 throw error;
             }
-            log$8.error('Certificate configuration failed:', error);
-            throw new MTLSError(MTLSErrorType$1.CONFIGURATION_ERROR, 'Failed to configure certificate', error);
+            log$5.error('Certificate configuration failed:', error);
+            throw new MTLSError(MTLSErrorType.CONFIGURATION_ERROR, 'Failed to configure certificate', error);
         }
     }
     async hasCertificate() {
@@ -6118,38 +3803,38 @@ class ReactNativeMTLSAdapter {
         try {
             // Use static method call
             const hasCert = await this.expoMTLS.hasCertificate();
-            log$8.debug('Certificate availability check:', hasCert);
+            log$5.debug('Certificate availability check:', hasCert);
             return hasCert;
         }
         catch (error) {
-            log$8.error('Certificate check failed:', error);
+            log$5.error('Certificate check failed:', error);
             return false;
         }
     }
     async getCertificateInfo() {
         if (!this.expoMTLS) {
-            log$8.debug('Certificate info requested but module not available');
+            log$5.debug('Certificate info requested but module not available');
             return null;
         }
         try {
             const hasCert = await this.hasCertificate();
             if (!hasCert) {
-                log$8.debug('No certificate stored');
+                log$5.debug('No certificate stored');
                 return null;
             }
             // Use getCertificatesInfo to retrieve information about stored certificates
             const result = await this.expoMTLS.getCertificatesInfo();
             if (!result || !result.certificates || result.certificates.length === 0) {
-                log$8.debug('No certificate information available');
+                log$5.debug('No certificate information available');
                 return null;
             }
             // Get the first certificate (primary client certificate)
             const cert = result.certificates[0];
             if (!cert) {
-                log$8.debug('Certificate data is empty');
+                log$5.debug('Certificate data is empty');
                 return null;
             }
-            log$8.debug('Retrieved certificate info:', {
+            log$5.debug('Retrieved certificate info:', {
                 subject: cert.subject.commonName,
                 issuer: cert.issuer.commonName,
                 validFrom: new Date(cert.validFrom),
@@ -6168,7 +3853,7 @@ class ReactNativeMTLSAdapter {
             };
         }
         catch (error) {
-            log$8.error('Failed to get certificate info:', error);
+            log$5.error('Failed to get certificate info:', error);
             return null;
         }
     }
@@ -6179,14 +3864,14 @@ class ReactNativeMTLSAdapter {
      */
     async parseCertificateData(certificateData) {
         if (!this.expoMTLS) {
-            log$8.debug('Parse certificate: Module not available');
+            log$5.debug('Parse certificate: Module not available');
             return null;
         }
         try {
             let result;
             if (certificateData.format === 'P12') {
                 if (!certificateData.password) {
-                    throw new MTLSError(MTLSErrorType$1.CONFIGURATION_ERROR, 'P12 certificate requires password for parsing');
+                    throw new MTLSError(MTLSErrorType.CONFIGURATION_ERROR, 'P12 certificate requires password for parsing');
                 }
                 result = await this.expoMTLS.parseCertificateP12(certificateData.certificate, certificateData.password);
             }
@@ -6194,31 +3879,31 @@ class ReactNativeMTLSAdapter {
                 result = await this.expoMTLS.parseCertificatePEM(certificateData.certificate);
             }
             else {
-                throw new MTLSError(MTLSErrorType$1.CERTIFICATE_INVALID, `Unsupported certificate format: ${certificateData.format}`);
+                throw new MTLSError(MTLSErrorType.CERTIFICATE_INVALID, `Unsupported certificate format: ${certificateData.format}`);
             }
-            log$8.debug('Certificate parsed successfully:', {
+            log$5.debug('Certificate parsed successfully:', {
                 certificateCount: result.certificates.length,
                 subjects: result.certificates.map((cert) => cert.subject.commonName),
             });
             return result;
         }
         catch (error) {
-            log$8.error('Failed to parse certificate:', error);
+            log$5.error('Failed to parse certificate:', error);
             if (error instanceof MTLSError) {
                 throw error;
             }
-            throw new MTLSError(MTLSErrorType$1.CERTIFICATE_INVALID, 'Failed to parse certificate data', error);
+            throw new MTLSError(MTLSErrorType.CERTIFICATE_INVALID, 'Failed to parse certificate data', error);
         }
     }
     async request(requestConfig) {
         if (!this.expoMTLS) {
-            throw new MTLSError(MTLSErrorType$1.NOT_SUPPORTED, 'Expo mTLS module not available');
+            throw new MTLSError(MTLSErrorType.NOT_SUPPORTED, 'Expo mTLS module not available');
         }
         const hasCert = await this.hasCertificate();
         if (!hasCert) {
-            throw new MTLSError(MTLSErrorType$1.CERTIFICATE_NOT_FOUND, 'No certificate configured');
+            throw new MTLSError(MTLSErrorType.CERTIFICATE_NOT_FOUND, 'No certificate configured');
         }
-        log$8.debug('Making mTLS request:', {
+        log$5.debug('Making mTLS request:', {
             method: requestConfig.method || 'GET',
             url: requestConfig.url,
             headers: requestConfig.headers,
@@ -6226,7 +3911,7 @@ class ReactNativeMTLSAdapter {
             responseType: requestConfig.responseType,
         });
         if (requestConfig.data) {
-            log$8.debug('mTLS request body:', requestConfig.data);
+            log$5.debug('mTLS request body:', requestConfig.data);
         }
         try {
             const response = await this.expoMTLS.request(requestConfig.url, {
@@ -6235,9 +3920,9 @@ class ReactNativeMTLSAdapter {
                 body: requestConfig.data ? JSON.stringify(requestConfig.data) : undefined,
                 responseType: requestConfig.responseType,
             });
-            log$8.debug('mTLS request successful:', response);
+            log$5.debug('mTLS request successful:', response);
             if (!response.success) {
-                throw new MTLSError(MTLSErrorType$1.CONNECTION_FAILED, `mTLS request failed: ${response.statusMessage} (${response.statusCode})`, undefined, response.statusCode);
+                throw new MTLSError(MTLSErrorType.CONNECTION_FAILED, `mTLS request failed: ${response.statusMessage} (${response.statusCode})`, undefined, response.statusCode);
             }
             let data = response.body;
             // only parse if responseType is 'json' or if Content-Type header indicates JSON
@@ -6247,7 +3932,7 @@ class ReactNativeMTLSAdapter {
                     data = JSON.parse(response.body);
                 }
                 catch (parseError) {
-                    log$8.warn('Failed to parse JSON response:', parseError);
+                    log$5.warn('Failed to parse JSON response:', parseError);
                     // If parsing fails, keep raw body
                 }
             }
@@ -6264,8 +3949,8 @@ class ReactNativeMTLSAdapter {
             };
         }
         catch (error) {
-            log$8.error('mTLS request failed:', error);
-            throw new MTLSError(MTLSErrorType$1.CONNECTION_FAILED, 'mTLS request failed', error);
+            log$5.error('mTLS request failed:', error);
+            throw new MTLSError(MTLSErrorType.CONNECTION_FAILED, 'mTLS request failed', error);
         }
     }
     /**
@@ -6277,18 +3962,18 @@ class ReactNativeMTLSAdapter {
      */
     async testConnection() {
         if (!this.expoMTLS || !this.config) {
-            log$8.debug('Diagnostic test: No mTLS module or config available');
+            log$5.debug('Diagnostic test: No mTLS module or config available');
             return false;
         }
         try {
             const hasCert = await this.hasCertificate();
             if (!hasCert) {
-                log$8.debug('Diagnostic test: No certificate configured');
+                log$5.debug('Diagnostic test: No certificate configured');
                 return false;
             }
-            log$8.debug('Running diagnostic test (may fail even if mTLS works):', this.config.baseUrl);
+            log$5.debug('Running diagnostic test (may fail even if mTLS works):', this.config.baseUrl);
             const result = await this.expoMTLS.testConnection(this.config.baseUrl);
-            log$8.debug('Diagnostic test result (NOT validation):', {
+            log$5.debug('Diagnostic test result (NOT validation):', {
                 success: result.success,
                 statusCode: result.statusCode,
                 statusMessage: result.statusMessage,
@@ -6299,13 +3984,13 @@ class ReactNativeMTLSAdapter {
             return result.success;
         }
         catch (error) {
-            log$8.warn('Diagnostic test failed (this is expected):', error);
+            log$5.warn('Diagnostic test failed (this is expected):', error);
             return false;
         }
     }
     async removeCertificate() {
         if (!this.expoMTLS) {
-            log$8.debug('Remove certificate: Module not available');
+            log$5.debug('Remove certificate: Module not available');
             return;
         }
         try {
@@ -6314,11 +3999,11 @@ class ReactNativeMTLSAdapter {
             this.isConfigured = false;
             // Cleanup event listeners
             this.cleanupEventListeners();
-            log$8.debug('Certificate removed successfully');
+            log$5.debug('Certificate removed successfully');
         }
         catch (error) {
-            log$8.error('Failed to remove certificate:', error);
-            throw new MTLSError(MTLSErrorType$1.CONFIGURATION_ERROR, 'Failed to remove certificate', error);
+            log$5.error('Failed to remove certificate:', error);
+            throw new MTLSError(MTLSErrorType.CONFIGURATION_ERROR, 'Failed to remove certificate', error);
         }
     }
     /**
@@ -6326,7 +4011,7 @@ class ReactNativeMTLSAdapter {
      */
     cleanupEventListeners() {
         if (this.eventListeners.length > 0) {
-            log$8.debug(`Cleaning up ${this.eventListeners.length} event listeners`);
+            log$5.debug(`Cleaning up ${this.eventListeners.length} event listeners`);
         }
         // Remove individual listeners if they have remove methods
         this.eventListeners.forEach((listener) => {
@@ -6363,7 +4048,7 @@ class ReactNativeMTLSAdapter {
     }
 }
 
-const log$7 = createPrefixedLogger('WEB-MTLS');
+const log$4 = createPrefixedLogger('WEB-MTLS');
 /**
  * Web mTLS Adapter - Graceful fallback for web browsers
  *
@@ -6377,13 +4062,13 @@ const log$7 = createPrefixedLogger('WEB-MTLS');
  */
 class WebMTLSAdapter {
     constructor() {
-        log$7.warn('Web browsers do not support programmatic mTLS configuration');
-        log$7.info('Use JWT authentication or configure client certificates in browser settings');
+        log$4.warn('Web browsers do not support programmatic mTLS configuration');
+        log$4.info('Use JWT authentication or configure client certificates in browser settings');
     }
     async isMTLSSupported() {
         // mTLS is not supported programmatically in web browsers
         const supported = false;
-        log$7.debug('mTLS support check:', {
+        log$4.debug('mTLS support check:', {
             supported,
             platform: this.getPlatformInfo().platform,
             reason: 'Browser security model prevents programmatic certificate configuration',
@@ -6392,14 +4077,14 @@ class WebMTLSAdapter {
         return supported;
     }
     async initialize(config) {
-        log$7.warn('Initialized but mTLS not available in web browsers:', {
+        log$4.warn('Initialized but mTLS not available in web browsers:', {
             baseUrl: config.baseUrl,
             port: config.port,
             recommendation: 'Use standard HTTPS with JWT authentication',
         });
     }
     async configureCertificate(certificateData) {
-        log$7.error('Certificate configuration attempted:', {
+        log$4.error('Certificate configuration attempted:', {
             format: certificateData.format,
             reason: 'Not supported in web browsers',
             alternatives: [
@@ -6408,21 +4093,21 @@ class WebMTLSAdapter {
                 'Configure server-side proxy for certificate handling',
             ],
         });
-        throw new MTLSError(MTLSErrorType$1.NOT_SUPPORTED, 'mTLS client certificate configuration is not supported in web browsers. ' +
+        throw new MTLSError(MTLSErrorType.NOT_SUPPORTED, 'mTLS client certificate configuration is not supported in web browsers. ' +
             'Web browsers manage client certificates through the browser certificate store. ' +
             'Please use JWT authentication or import certificates manually into your browser.');
     }
     async hasCertificate() {
         // We cannot detect if the browser has certificates configured
-        log$7.debug('Certificate availability check: Cannot detect browser certificates programmatically');
+        log$4.debug('Certificate availability check: Cannot detect browser certificates programmatically');
         return false;
     }
     async getCertificateInfo() {
-        log$7.debug('Certificate info requested: Not accessible in web browsers');
+        log$4.debug('Certificate info requested: Not accessible in web browsers');
         return null;
     }
     async request(requestConfig) {
-        log$7.error('mTLS request attempted:', {
+        log$4.error('mTLS request attempted:', {
             method: requestConfig.method,
             url: requestConfig.url,
             reason: 'Not supported in web browsers',
@@ -6432,16 +4117,16 @@ class WebMTLSAdapter {
                 'Rely on browser-managed certificates (if configured by user)',
             ],
         });
-        throw new MTLSError(MTLSErrorType$1.NOT_SUPPORTED, 'mTLS requests are not supported in web browsers via JavaScript. ' +
+        throw new MTLSError(MTLSErrorType.NOT_SUPPORTED, 'mTLS requests are not supported in web browsers via JavaScript. ' +
             'Use standard HTTP client with JWT authentication, or ensure client certificates ' +
             'are properly configured in the browser certificate store.');
     }
     async testConnection() {
-        log$7.debug('Connection test: mTLS not available in web browsers');
+        log$4.debug('Connection test: mTLS not available in web browsers');
         return false;
     }
     async removeCertificate() {
-        log$7.debug('Remove certificate: No certificates to remove (not supported in web browsers)');
+        log$4.debug('Remove certificate: No certificates to remove (not supported in web browsers)');
         // No-op - cannot remove certificates programmatically in browsers
     }
     /**
@@ -6449,7 +4134,7 @@ class WebMTLSAdapter {
      * Always returns null for web browsers as mTLS is not supported
      */
     getBaseUrl() {
-        log$7.debug('Base URL requested: Not supported in web browsers');
+        log$4.debug('Base URL requested: Not supported in web browsers');
         return null;
     }
     getPlatformInfo() {
@@ -6482,7 +4167,7 @@ class WebMTLSAdapter {
     }
 }
 
-const log$6 = createPrefixedLogger('MTLS-LOADER');
+const log$3 = createPrefixedLogger('MTLS-LOADER');
 function loadMTLSAdapter(platform, config) {
     try {
         let adapter;
@@ -6516,7 +4201,7 @@ function loadMTLSAdapter(platform, config) {
         return adapter;
     }
     catch (error) {
-        log$6.warn(`mTLS adapter not available for platform ${platform}:`, error);
+        log$3.warn(`mTLS adapter not available for platform ${platform}:`, error);
         return null;
     }
 }
@@ -6526,7 +4211,7 @@ async function initializeAdapterAsync(adapter, config) {
         if (isSupported) {
             await adapter.initialize(config);
             const platformInfo = adapter.getPlatformInfo();
-            log$6.debug('mTLS adapter initialized:', {
+            log$3.debug('mTLS adapter initialized:', {
                 platform: platformInfo.platform,
                 mtlsSupported: platformInfo.mtlsSupported,
                 certificateStorage: platformInfo.certificateStorage,
@@ -6535,31 +4220,28 @@ async function initializeAdapterAsync(adapter, config) {
         }
     }
     catch (error) {
-        log$6.warn('Failed to initialize mTLS adapter:', error);
+        log$3.warn('Failed to initialize mTLS adapter:', error);
     }
 }
 
-const log$5 = createPrefixedLogger('ADAPTER-LOADER');
+const log$2 = createPrefixedLogger('ADAPTER-LOADER');
 function loadPlatformAdapters(options = {}) {
     const { mtlsConfig } = options;
     const { platform } = detectPlatform();
-    log$5.debug('Loading adapters for platform:', platform);
+    log$2.debug('Loading adapters for platform:', platform);
     const storageAdapters = loadStorageAdapters(platform);
     const networkMonitor = loadNetworkMonitor(platform);
-    const cache = loadCacheAdapter(platform);
     const mtls = loadMTLSAdapter(platform, mtlsConfig);
-    log$5.debug('Adapters loaded:', {
+    log$2.debug('Adapters loaded:', {
         platform,
         hasStorage: !!storageAdapters.storage,
         hasSecureStorage: !!storageAdapters.secureStorage,
         hasNetworkMonitor: !!networkMonitor,
-        hasCache: !!cache,
         hasMTLS: !!mtls,
     });
     return {
         ...storageAdapters,
         networkMonitor,
-        cache,
         mtls: mtls || undefined,
     };
 }
@@ -6576,12 +4258,9 @@ function createACubeMTLSConfig(baseUrl, timeout, autoInitialize = true, forcePor
 
 const DI_TOKENS = {
     HTTP_PORT: Symbol('HTTP_PORT'),
-    BASE_HTTP_PORT: Symbol('BASE_HTTP_PORT'),
     STORAGE_PORT: Symbol('STORAGE_PORT'),
     SECURE_STORAGE_PORT: Symbol('SECURE_STORAGE_PORT'),
     NETWORK_PORT: Symbol('NETWORK_PORT'),
-    CACHE_PORT: Symbol('CACHE_PORT'),
-    CACHE_KEY_GENERATOR: Symbol('CACHE_KEY_GENERATOR'),
     MTLS_PORT: Symbol('MTLS_PORT'),
     TOKEN_STORAGE_PORT: Symbol('TOKEN_STORAGE_PORT'),
     RECEIPT_REPOSITORY: Symbol('RECEIPT_REPOSITORY'),
@@ -6599,7 +4278,6 @@ const DI_TOKENS = {
     AUTH_SERVICE: Symbol('AUTH_SERVICE'),
     AUTHENTICATION_SERVICE: Symbol('AUTHENTICATION_SERVICE'),
     CERTIFICATE_SERVICE: Symbol('CERTIFICATE_SERVICE'),
-    OFFLINE_SERVICE: Symbol('OFFLINE_SERVICE'),
     NOTIFICATION_SERVICE: Symbol('NOTIFICATION_SERVICE'),
     TELEMETRY_SERVICE: Symbol('TELEMETRY_SERVICE'),
 };
@@ -7494,545 +5172,83 @@ class TelemetryMapper {
                 : null,
             lastMessageFromAde: output.last_message_from_ade
                 ? this.messageFromApi(output.last_message_from_ade)
-                : null,
-            lottery: this.lotteryFromApi(output.lottery),
-        };
-    }
-    static merchantFromApi(output) {
-        return {
-            vatNumber: output.vat_number,
-            fiscalCode: output.fiscal_code,
-            businessName: output.business_name,
-        };
-    }
-    static supplierFromApi(output) {
-        return {
-            vatNumber: output.vat_number,
-            fiscalCode: output.fiscal_code,
-            businessName: output.business_name,
-        };
-    }
-    static softwareVersionFromApi(output) {
-        return {
-            version: output.version,
-            swid: output.swid,
-            installedAt: output.installed_at,
-            status: output.status,
-        };
-    }
-    static softwareFromApi(output) {
-        return {
-            code: output.code,
-            name: output.name,
-            approvalReference: output.approval_reference,
-            versionInfo: output.version_info ? this.softwareVersionFromApi(output.version_info) : null,
-        };
-    }
-    static pendingReceiptsFromApi(output) {
-        return {
-            count: output.count,
-            totalAmount: output.total_amount,
-        };
-    }
-    static transmissionFromApi(output) {
-        return {
-            attemptedAt: output.attempted_at,
-            outcome: output.outcome,
-        };
-    }
-    static messageFromApi(output) {
-        return {
-            receivedAt: output.received_at,
-            content: output.content,
-        };
-    }
-    static secretRequestFromApi(output) {
-        return {
-            requestedAt: output.requested_at,
-            outcome: output.outcome,
-        };
-    }
-    static lotteryFromApi(output) {
-        return {
-            lastTransmission: output.last_transmission
-                ? this.transmissionFromApi(output.last_transmission)
-                : null,
-            secretRequest: output.secret_request
-                ? this.secretRequestFromApi(output.secret_request)
-                : null,
-        };
-    }
-}
-
-class TelemetryRepositoryImpl {
-    constructor(http) {
-        this.http = http;
-    }
-    async getTelemetry(pemId) {
-        const response = await this.http.get(`/mf1/pems/${pemId}/telemetry`);
-        return TelemetryMapper.fromApiOutput(response.data);
-    }
-}
-
-const log$4 = createPrefixedLogger('CACHE-KEY');
-const URL_PATTERNS = [
-    // Receipt (mf1) - specific patterns first
-    {
-        pattern: /^\/mf1\/receipts\/([^/]+)\/returnable-items$/,
-        resource: 'receipt',
-        action: 'returnable',
-    },
-    {
-        pattern: /^\/mf1\/receipts\/([^/]+)\/details$/,
-        resource: 'receipt',
-        action: 'details',
-    },
-    { pattern: /^\/mf1\/receipts\/([^/]+)$/, resource: 'receipt' },
-    {
-        pattern: /^\/mf1\/pems\/([^/]+)\/receipts$/,
-        resource: 'receipt',
-        parent: 'point-of-sale',
-        isList: true,
-    },
-    { pattern: /^\/mf1\/receipts$/, resource: 'receipt', isList: true },
-    // Merchant (mf2)
-    { pattern: /^\/mf2\/merchants\/([^/]+)$/, resource: 'merchant' },
-    { pattern: /^\/mf2\/merchants$/, resource: 'merchant', isList: true },
-    // Cashier (mf1)
-    { pattern: /^\/mf1\/cashiers\/me$/, resource: 'cashier', action: 'me' },
-    { pattern: /^\/mf1\/cashiers\/([^/]+)$/, resource: 'cashier' },
-    { pattern: /^\/mf1\/cashiers$/, resource: 'cashier', isList: true },
-    // Cash Register (mf1)
-    { pattern: /^\/mf1\/cash-registers\/([^/]+)$/, resource: 'cash-register' },
-    { pattern: /^\/mf1\/cash-registers$/, resource: 'cash-register', isList: true },
-    // Point of Sale (mf1)
-    { pattern: /^\/mf1\/pems\/([^/]+)$/, resource: 'point-of-sale' },
-    { pattern: /^\/mf1\/pems$/, resource: 'point-of-sale', isList: true },
-    // Nested resources under merchant (mf2)
-    {
-        pattern: /^\/mf2\/merchants\/([^/]+)\/suppliers\/([^/]+)$/,
-        resource: 'supplier',
-        parent: 'merchant',
-    },
-    {
-        pattern: /^\/mf2\/merchants\/([^/]+)\/suppliers$/,
-        resource: 'supplier',
-        parent: 'merchant',
-        isList: true,
-    },
-    {
-        pattern: /^\/mf2\/merchants\/([^/]+)\/daily-reports/,
-        resource: 'daily-report',
-        parent: 'merchant',
-        isList: true,
-    },
-    {
-        pattern: /^\/mf2\/merchants\/([^/]+)\/journals/,
-        resource: 'journal',
-        parent: 'merchant',
-        isList: true,
-    },
-    // PEM (mf2)
-    {
-        pattern: /^\/mf2\/pems\/([^/]+)\/certificates$/,
-        resource: 'pem',
-        action: 'certificates',
-    },
-    { pattern: /^\/mf2\/pems\/([^/]+)$/, resource: 'pem' },
-    // Others
-    { pattern: /^\/mf1\/notifications/, resource: 'notification', isList: true },
-    {
-        pattern: /^\/mf1\/pems\/([^/]+)\/telemetry$/,
-        resource: 'telemetry',
-    },
-];
-const DEFAULT_TTL_CONFIG = {
-    // Data that rarely changes - 30 min TTL for items only
-    merchant: { ttlMs: 30 * 60 * 1000, cacheList: false, cacheItem: true },
-    'point-of-sale': { ttlMs: 30 * 60 * 1000, cacheList: false, cacheItem: true },
-    'cash-register': { ttlMs: 30 * 60 * 1000, cacheList: false, cacheItem: true },
-    pem: { ttlMs: 30 * 60 * 1000, cacheList: false, cacheItem: false },
-    // Data that changes moderately - 10 min TTL for items only
-    cashier: { ttlMs: 10 * 60 * 1000, cacheList: false, cacheItem: true },
-    supplier: { ttlMs: 10 * 60 * 1000, cacheList: false, cacheItem: true },
-    // Data that can change - 5 min TTL for items only
-    receipt: { ttlMs: 5 * 60 * 1000, cacheList: false, cacheItem: true },
-    'daily-report': { ttlMs: 5 * 60 * 1000, cacheList: false, cacheItem: true },
-    journal: { ttlMs: 5 * 60 * 1000, cacheList: false, cacheItem: true },
-    // Real-time data - 1 min TTL
-    notification: { ttlMs: 1 * 60 * 1000, cacheList: false, cacheItem: false },
-    telemetry: { ttlMs: 1 * 60 * 1000, cacheList: false, cacheItem: false },
-};
-const DEFAULT_TTL = 5 * 60 * 1000; // 5 minutes
-class CacheKeyGenerator {
-    constructor(customConfig) {
-        this.config = { ...DEFAULT_TTL_CONFIG, ...customConfig };
-        log$4.info('CacheKeyGenerator initialized with config:', {
-            resources: Object.keys(this.config),
-        });
-    }
-    generate(url, params) {
-        const parsed = this.parseUrl(url);
-        if (!parsed) {
-            // Fallback: use URL as key
-            const paramStr = params ? this.serializeParams(params) : '';
-            const key = paramStr ? `${url}?${paramStr}` : url;
-            log$4.debug('URL not matched, using fallback key:', { url, key });
-            return key;
-        }
-        const { resource, ids, action, isList, parent } = parsed;
-        if (isList) {
-            const paramStr = params ? this.serializeParams(params) : '';
-            const parentPart = parent && ids.length > 0 ? `${parent}=${ids[0]}&` : '';
-            const key = `${resource}:list:${parentPart}${paramStr}`;
-            log$4.debug('Generated list cache key:', { url, key, resource });
-            return key;
-        }
-        // Single item
-        if (ids.length === 0 && action) {
-            // Special case for endpoints like /cashiers/me
-            const key = `${resource}:${action}`;
-            log$4.debug('Generated special action cache key:', { url, key, resource, action });
-            return key;
-        }
-        let key = `${resource}:${ids.join(':')}`;
-        if (action) {
-            key += `:${action}`;
-        }
-        log$4.debug('Generated item cache key:', { url, key, resource, ids, action });
-        return key;
-    }
-    parseResource(url) {
-        const parsed = this.parseUrl(url);
-        return parsed?.resource;
-    }
-    getTTL(url) {
-        const resource = this.parseResource(url);
-        if (!resource) {
-            log$4.debug('No resource found for URL, using default TTL:', { url, ttl: DEFAULT_TTL });
-            return DEFAULT_TTL;
-        }
-        const ttl = this.config[resource].ttlMs;
-        log$4.debug('TTL for resource:', { url, resource, ttlMs: ttl, ttlMin: ttl / 60000 });
-        return ttl;
-    }
-    shouldCache(url) {
-        const parsed = this.parseUrl(url);
-        if (!parsed) {
-            log$4.debug('URL not recognized, should not cache:', { url });
-            return false;
-        }
-        const { resource, isList } = parsed;
-        const config = this.config[resource];
-        if (isList) {
-            log$4.debug('List endpoint cache decision:', {
-                url,
-                resource,
-                isList: true,
-                shouldCache: config.cacheList,
-            });
-            return config.cacheList;
-        }
-        log$4.debug('Item endpoint cache decision:', {
-            url,
-            resource,
-            isList: false,
-            shouldCache: config.cacheItem,
-        });
-        return config.cacheItem;
-    }
-    getInvalidationPatterns(url, method) {
-        const parsed = this.parseUrl(url);
-        if (!parsed) {
-            log$4.debug('No patterns to invalidate for URL:', { url, method });
-            return [];
-        }
-        const { resource, ids, parent } = parsed;
-        const patterns = [];
-        // Always invalidate list on mutations
-        if (method === 'POST' || method === 'PUT' || method === 'PATCH' || method === 'DELETE') {
-            if (parent && ids.length > 0) {
-                patterns.push(`${resource}:list:${parent}=${ids[0]}*`);
-            }
-            patterns.push(`${resource}:list:*`);
-        }
-        // Invalidate specific item on PUT/PATCH/DELETE
-        if (method === 'PUT' || method === 'PATCH' || method === 'DELETE') {
-            if (ids.length > 0) {
-                patterns.push(`${resource}:${ids.join(':')}*`);
-            }
-        }
-        // Special cases
-        if (resource === 'cashier' && (method === 'PUT' || method === 'DELETE')) {
-            patterns.push('cashier:me');
-        }
-        log$4.debug('Invalidation patterns:', { url, method, patterns });
-        return patterns;
-    }
-    parseUrl(url) {
-        // Remove query string for pattern matching
-        const urlPath = url.split('?')[0];
-        for (const pattern of URL_PATTERNS) {
-            const match = urlPath?.match(pattern.pattern);
-            if (match) {
-                // Extract IDs from capture groups
-                const ids = match.slice(1).filter(Boolean);
-                return {
-                    resource: pattern.resource,
-                    ids,
-                    action: pattern.action,
-                    isList: pattern.isList,
-                    parent: pattern.parent,
-                };
-            }
-        }
-        return null;
-    }
-    serializeParams(params) {
-        const sortedKeys = Object.keys(params).sort();
-        const parts = [];
-        for (const key of sortedKeys) {
-            const value = params[key];
-            if (value !== undefined && value !== null) {
-                parts.push(`${key}=${String(value)}`);
-            }
-        }
-        return parts.join('&');
-    }
-}
-
-const log$3 = createPrefixedLogger('CACHE');
-class CachingHttpDecorator {
-    constructor(http, cache, keyGenerator, networkMonitor, config = {}) {
-        this.http = http;
-        this.cache = cache;
-        this.keyGenerator = keyGenerator;
-        this.networkMonitor = networkMonitor;
-        this.config = config;
-        this.currentOnlineState = true;
-        this.authToken = null;
-        log$3.info('CachingHttpDecorator initialized', {
-            enabled: config.enabled !== false,
-            hasNetworkMonitor: !!networkMonitor,
-        });
-        this.setupNetworkMonitoring();
+                : null,
+            lottery: this.lotteryFromApi(output.lottery),
+        };
     }
-    setupNetworkMonitoring() {
-        if (this.networkMonitor) {
-            this.networkSubscription = this.networkMonitor.online$.subscribe((online) => {
-                if (this.currentOnlineState !== online) {
-                    log$3.info('Network state changed:', { online });
-                }
-                this.currentOnlineState = online;
-            });
-        }
+    static merchantFromApi(output) {
+        return {
+            vatNumber: output.vat_number,
+            fiscalCode: output.fiscal_code,
+            businessName: output.business_name,
+        };
     }
-    isOnline() {
-        if (this.networkMonitor) {
-            return this.currentOnlineState;
-        }
-        if (typeof navigator !== 'undefined' && 'onLine' in navigator) {
-            return navigator.onLine;
-        }
-        return true;
+    static supplierFromApi(output) {
+        return {
+            vatNumber: output.vat_number,
+            fiscalCode: output.fiscal_code,
+            businessName: output.business_name,
+        };
     }
-    async get(url, config) {
-        const startTime = Date.now();
-        // Check if caching is disabled globally
-        if (this.config.enabled === false) {
-            log$3.debug('GET (cache disabled globally):', { url });
-            return this.http.get(url, config);
-        }
-        // Check if this URL should be cached
-        const shouldCache = this.keyGenerator.shouldCache(url);
-        if (!shouldCache) {
-            log$3.debug('GET (not cacheable - likely a list endpoint):', { url });
-            return this.http.get(url, config);
-        }
-        const cacheKey = this.keyGenerator.generate(url, config?.params);
-        const ttl = this.keyGenerator.getTTL(url);
-        const resource = this.keyGenerator.parseResource(url);
-        log$3.info('GET request starting:', {
-            url,
-            resource,
-            cacheKey,
-            ttlMs: ttl,
-            ttlMin: Math.round(ttl / 60000),
-            params: config?.params,
-        });
-        // Check cache
-        let cached = null;
-        try {
-            cached = await this.cache.get(cacheKey);
-            if (cached) {
-                log$3.debug('Cache entry found:', {
-                    cacheKey,
-                    timestamp: new Date(cached.timestamp).toISOString(),
-                    ageMs: Date.now() - cached.timestamp,
-                });
-            }
-            else {
-                log$3.debug('Cache entry not found:', { cacheKey });
-            }
-        }
-        catch (error) {
-            log$3.warn('Cache lookup failed:', {
-                cacheKey,
-                error: error instanceof Error ? error.message : error,
-            });
-        }
-        if (cached) {
-            const age = Date.now() - cached.timestamp;
-            const isExpired = age >= ttl;
-            log$3.debug('Cache analysis:', {
-                cacheKey,
-                ageMs: age,
-                ageSec: Math.round(age / 1000),
-                ttlMs: ttl,
-                isExpired,
-                isOnline: this.isOnline(),
-            });
-            // If within TTL, return cached data
-            if (!isExpired) {
-                const duration = Date.now() - startTime;
-                log$3.info('CACHE HIT:', {
-                    url,
-                    cacheKey,
-                    ageMs: age,
-                    durationMs: duration,
-                });
-                return {
-                    data: cached.data,
-                    status: 200,
-                    headers: { 'x-cache': 'HIT' },
-                };
-            }
-            // If offline and cache is stale, return stale data
-            if (!this.isOnline()) {
-                const duration = Date.now() - startTime;
-                log$3.info('CACHE STALE (offline):', {
-                    url,
-                    cacheKey,
-                    ageMs: age,
-                    durationMs: duration,
-                });
-                return {
-                    data: cached.data,
-                    status: 200,
-                    headers: { 'x-cache': 'STALE' },
-                };
-            }
-            log$3.debug('Cache expired, fetching fresh data:', { cacheKey, ageMs: age, ttlMs: ttl });
-        }
-        // Fetch fresh data
-        try {
-            log$3.debug('Fetching from network:', { url });
-            const response = await this.http.get(url, config);
-            // Cache the response
-            try {
-                await this.cache.set(cacheKey, response.data);
-                log$3.debug('Response cached successfully:', { cacheKey });
-            }
-            catch (error) {
-                log$3.error('Failed to cache response:', {
-                    cacheKey,
-                    error: error instanceof Error ? error.message : error,
-                });
-            }
-            const duration = Date.now() - startTime;
-            log$3.info('CACHE MISS (fetched fresh):', {
-                url,
-                cacheKey,
-                status: response.status,
-                durationMs: duration,
-            });
-            return {
-                ...response,
-                headers: { ...response.headers, 'x-cache': 'MISS' },
-            };
-        }
-        catch (error) {
-            // On error, return stale cache if available
-            if (cached) {
-                const duration = Date.now() - startTime;
-                log$3.warn('CACHE STALE (network error):', {
-                    url,
-                    cacheKey,
-                    error: error instanceof Error ? error.message : 'Unknown error',
-                    durationMs: duration,
-                });
-                return {
-                    data: cached.data,
-                    status: 200,
-                    headers: { 'x-cache': 'STALE' },
-                };
-            }
-            log$3.error('Network error with no cache fallback:', {
-                url,
-                error: error instanceof Error ? error.message : error,
-            });
-            throw error;
-        }
+    static softwareVersionFromApi(output) {
+        return {
+            version: output.version,
+            swid: output.swid,
+            installedAt: output.installed_at,
+            status: output.status,
+        };
     }
-    async post(url, data, config) {
-        log$3.info('POST request:', { url });
-        const response = await this.http.post(url, data, config);
-        await this.invalidateRelated(url, 'POST');
-        return response;
+    static softwareFromApi(output) {
+        return {
+            code: output.code,
+            name: output.name,
+            approvalReference: output.approval_reference,
+            versionInfo: output.version_info ? this.softwareVersionFromApi(output.version_info) : null,
+        };
     }
-    async put(url, data, config) {
-        log$3.info('PUT request:', { url });
-        const response = await this.http.put(url, data, config);
-        await this.invalidateRelated(url, 'PUT');
-        return response;
+    static pendingReceiptsFromApi(output) {
+        return {
+            count: output.count,
+            totalAmount: output.total_amount,
+        };
     }
-    async patch(url, data, config) {
-        log$3.info('PATCH request:', { url });
-        const response = await this.http.patch(url, data, config);
-        await this.invalidateRelated(url, 'PATCH');
-        return response;
+    static transmissionFromApi(output) {
+        return {
+            attemptedAt: output.attempted_at,
+            outcome: output.outcome,
+        };
     }
-    async delete(url, config) {
-        log$3.info('DELETE request:', { url });
-        const response = await this.http.delete(url, config);
-        await this.invalidateRelated(url, 'DELETE');
-        return response;
+    static messageFromApi(output) {
+        return {
+            receivedAt: output.received_at,
+            content: output.content,
+        };
     }
-    setAuthToken(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);
+    static secretRequestFromApi(output) {
+        return {
+            requestedAt: output.requested_at,
+            outcome: output.outcome,
+        };
     }
-    getAuthToken() {
-        return this.authToken;
+    static lotteryFromApi(output) {
+        return {
+            lastTransmission: output.last_transmission
+                ? this.transmissionFromApi(output.last_transmission)
+                : null,
+            secretRequest: output.secret_request
+                ? this.secretRequestFromApi(output.secret_request)
+                : null,
+        };
     }
-    async invalidateRelated(url, method) {
-        const patterns = this.keyGenerator.getInvalidationPatterns(url, method);
-        if (patterns.length === 0) {
-            log$3.debug('No cache patterns to invalidate:', { url, method });
-            return;
-        }
-        log$3.info('Invalidating cache patterns:', { url, method, patterns });
-        for (const pattern of patterns) {
-            try {
-                await this.cache.invalidate(pattern);
-                log$3.debug('Cache pattern invalidated:', { pattern });
-            }
-            catch (error) {
-                log$3.error('Failed to invalidate pattern:', {
-                    pattern,
-                    error: error instanceof Error ? error.message : error,
-                });
-            }
-        }
+}
+
+class TelemetryRepositoryImpl {
+    constructor(http) {
+        this.http = http;
     }
-    destroy() {
-        log$3.debug('CachingHttpDecorator destroyed');
-        this.networkSubscription?.unsubscribe();
+    async getTelemetry(pemId) {
+        const response = await this.http.get(`/mf1/pems/${pemId}/telemetry`);
+        return TelemetryMapper.fromApiOutput(response.data);
     }
 }
 
@@ -8305,7 +5521,6 @@ class SDKFactory {
             baseUrl: config.baseUrl,
             timeout: config.timeout,
         });
-        container.register(DI_TOKENS.BASE_HTTP_PORT, httpAdapter);
         container.register(DI_TOKENS.HTTP_PORT, httpAdapter);
         container.registerFactory(DI_TOKENS.RECEIPT_REPOSITORY, () => {
             const http = container.get(DI_TOKENS.HTTP_PORT);
@@ -8353,23 +5568,6 @@ class SDKFactory {
         });
         return container;
     }
-    static registerCacheServices(container, cache, network) {
-        container.register(DI_TOKENS.CACHE_PORT, cache);
-        if (network) {
-            container.register(DI_TOKENS.NETWORK_PORT, network);
-        }
-        const keyGenerator = new CacheKeyGenerator();
-        container.register(DI_TOKENS.CACHE_KEY_GENERATOR, keyGenerator);
-        const baseHttp = container.get(DI_TOKENS.BASE_HTTP_PORT);
-        const cachingHttp = new CachingHttpDecorator(baseHttp, cache, keyGenerator, network);
-        container.register(DI_TOKENS.HTTP_PORT, cachingHttp);
-    }
-    static getCacheKeyGenerator(container) {
-        if (container.has(DI_TOKENS.CACHE_KEY_GENERATOR)) {
-            return container.get(DI_TOKENS.CACHE_KEY_GENERATOR);
-        }
-        return undefined;
-    }
     static registerAuthServices(container, secureStorage, config) {
         const tokenStorage = new TokenStorageAdapter(secureStorage);
         container.register(DI_TOKENS.TOKEN_STORAGE_PORT, tokenStorage);
@@ -8407,7 +5605,7 @@ class SDKFactory {
     }
 }
 
-const log$2 = createPrefixedLogger('SDK');
+const log$1 = createPrefixedLogger('SDK');
 class ACubeSDK {
     constructor(config, customAdapters, events = {}) {
         this.events = events;
@@ -8421,23 +5619,22 @@ class ACubeSDK {
     }
     async initialize() {
         if (this.isInitialized) {
-            log$2.debug('SDK already initialized, skipping');
+            log$1.debug('SDK already initialized, skipping');
             return;
         }
-        log$2.info('Initializing SDK', {
+        log$1.info('Initializing SDK', {
             apiUrl: this.config.getApiUrl(),
             authUrl: this.config.getAuthUrl(),
             debugEnabled: this.config.isDebugEnabled(),
         });
         try {
             if (!this.adapters) {
-                log$2.debug('Loading platform adapters');
+                log$1.debug('Loading platform adapters');
                 const mtlsConfig = createACubeMTLSConfig(this.config.getApiUrl(), this.config.getTimeout(), true);
                 this.adapters = loadPlatformAdapters({
                     mtlsConfig,
                 });
-                log$2.info('Platform adapters loaded', {
-                    hasCache: !!this.adapters.cache,
+                log$1.info('Platform adapters loaded', {
                     hasNetworkMonitor: !!this.adapters.networkMonitor,
                     hasMtls: !!this.adapters.mtls,
                     hasSecureStorage: !!this.adapters.secureStorage,
@@ -8449,30 +5646,15 @@ class ACubeSDK {
                 timeout: this.config.getTimeout(),
                 debugEnabled: this.config.isDebugEnabled(),
             };
-            log$2.debug('Creating DI container');
+            log$1.debug('Creating DI container');
             this.container = SDKFactory.createContainer(factoryConfig);
-            log$2.debug('Registering auth services');
+            log$1.debug('Registering auth services');
             SDKFactory.registerAuthServices(this.container, this.adapters.secureStorage, factoryConfig);
-            if (this.adapters.cache) {
-                log$2.info('Registering cache services', {
-                    hasNetworkMonitor: !!this.adapters.networkMonitor,
-                });
-                SDKFactory.registerCacheServices(this.container, this.adapters.cache, this.adapters.networkMonitor);
-            }
-            else {
-                log$2.debug('No cache adapter available, caching disabled');
-            }
-            log$2.debug('Initializing certificate service');
+            log$1.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$2.debug('HTTP ports initialized', {
-                httpPortType: httpPort.constructor.name,
-                baseHttpPortType: baseHttpPort.constructor.name,
-                areSameInstance: httpPort === baseHttpPort,
-            });
-            log$2.debug('Initializing authentication service');
+            log$1.debug('Initializing authentication service');
             this.authService = new AuthenticationService(httpPort, tokenStorage, {
                 authUrl: this.config.getAuthUrl(),
                 timeout: this.config.getTimeout(),
@@ -8482,51 +5664,33 @@ class ACubeSDK {
                     this.events.onAuthError?.(new ACubeSDKError('AUTH_ERROR', error.message, error));
                 },
             });
-            log$2.debug('Initializing offline manager');
-            const queueEvents = {
-                onOperationAdded: (operation) => {
-                    this.events.onOfflineOperationAdded?.(operation.id);
-                },
-                onOperationCompleted: (result) => {
-                    this.events.onOfflineOperationCompleted?.(result.operation.id, result.success);
-                },
-                onOperationFailed: (result) => {
-                    this.events.onOfflineOperationCompleted?.(result.operation.id, false);
-                },
-            };
-            this.offlineManager = new OfflineManager(this.adapters.storage, httpPort, this.adapters.networkMonitor, {
-                syncInterval: 30000,
-            }, queueEvents);
             this.networkSubscription = this.adapters.networkMonitor.online$.subscribe((online) => {
                 this.currentOnlineState = online;
                 this.events.onNetworkStatusChanged?.(online);
-                if (online && this.offlineManager) {
-                    this.offlineManager.sync().catch(() => { });
-                }
             });
             const isAuth = await this.authService.isAuthenticated();
-            log$2.debug('Checking authentication status during init', { isAuthenticated: isAuth });
+            log$1.debug('Checking authentication status during init', { isAuthenticated: isAuth });
             if (isAuth) {
                 const token = await this.authService.getAccessToken();
-                log$2.debug('Token retrieved during init', {
+                log$1.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');
+                    log$1.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');
+                log$1.warn('User not authenticated during SDK init - token will be set after login');
             }
-            if (this.adapters?.mtls && 'setMTLSAdapter' in baseHttpPort) {
-                log$2.debug('Connecting mTLS adapter to HTTP port');
-                const httpWithMtls = baseHttpPort;
+            if (this.adapters?.mtls && 'setMTLSAdapter' in httpPort) {
+                log$1.debug('Connecting mTLS adapter to HTTP port');
+                const httpWithMtls = httpPort;
                 httpWithMtls.setMTLSAdapter(this.adapters.mtls);
             }
-            if ('setAuthStrategy' in baseHttpPort) {
-                log$2.debug('Configuring auth strategy');
+            if ('setAuthStrategy' in httpPort) {
+                log$1.debug('Configuring auth strategy');
                 const jwtHandler = new JwtAuthHandler(tokenStorage);
                 const certificatePort = this.certificateService
                     ? {
@@ -8557,7 +5721,7 @@ class ACubeSDK {
                     },
                 };
                 const authStrategy = new AuthStrategy(jwtHandler, mtlsHandler, userProvider, this.adapters?.mtls || null);
-                const httpWithStrategy = baseHttpPort;
+                const httpWithStrategy = httpPort;
                 httpWithStrategy.setAuthStrategy(authStrategy);
             }
             if (this.adapters?.mtls && this.certificateService) {
@@ -8575,19 +5739,18 @@ class ACubeSDK {
                     }
                 }
                 catch (certError) {
-                    log$2.warn('Certificate auto-configuration failed, will retry on demand', {
+                    log$1.warn('Certificate auto-configuration failed, will retry on demand', {
                         error: certError instanceof Error ? certError.message : certError,
                     });
                 }
             }
             this.isInitialized = true;
-            log$2.info('SDK initialized successfully', {
-                hasCache: !!this.adapters.cache,
+            log$1.info('SDK initialized successfully', {
                 hasMtls: !!this.adapters.mtls,
             });
         }
         catch (error) {
-            log$2.error('SDK initialization failed', {
+            log$1.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);
@@ -8643,19 +5806,19 @@ class ACubeSDK {
     }
     async login(credentials) {
         this.ensureInitialized();
-        log$2.info('Login attempt', { email: credentials.email });
+        log$1.info('Login attempt', { email: credentials.email });
         const user = await this.authService.login(credentials);
-        log$2.info('Login successful', { roles: user.roles });
+        log$1.info('Login successful', { roles: user.roles });
         const token = await this.authService.getAccessToken();
         if (token) {
             this.httpPort.setAuthToken(token);
-            log$2.debug('Auth token set on HTTP port');
+            log$1.debug('Auth token set on HTTP port');
         }
         return user;
     }
     async logout() {
         this.ensureInitialized();
-        log$2.info('Logout');
+        log$1.info('Logout');
         await this.authService.logout();
         this.httpPort.setAuthToken(null);
     }
@@ -8673,10 +5836,6 @@ class ACubeSDK {
         this.ensureInitialized();
         return await this.authService.isAuthenticated();
     }
-    getOfflineManager() {
-        this.ensureInitialized();
-        return this.offlineManager;
-    }
     isOnline() {
         this.ensureInitialized();
         return this.currentOnlineState;
@@ -8804,7 +5963,6 @@ class ACubeSDK {
     }
     destroy() {
         this.networkSubscription?.unsubscribe();
-        this.offlineManager?.destroy();
         this.container?.clear();
         this.isInitialized = false;
     }
@@ -9090,7 +6248,6 @@ class TelemetryService {
         this.events = events;
         this.stateSubject = new BehaviorSubject({
             data: null,
-            isCached: false,
             isLoading: false,
             lastFetchedAt: null,
         });
@@ -9160,7 +6317,6 @@ class TelemetryService {
             const data = await this.repository.getTelemetry(this.currentPemId);
             const newState = {
                 data,
-                isCached: false,
                 isLoading: false,
                 lastFetchedAt: Date.now(),
             };
@@ -9185,7 +6341,6 @@ class TelemetryService {
     clearTelemetry() {
         this.stateSubject.next({
             data: null,
-            isCached: false,
             isLoading: false,
             lastFetchedAt: null,
         });
@@ -9198,7 +6353,7 @@ class TelemetryService {
     }
 }
 
-const log$1 = createPrefixedLogger('SDK-MANAGER');
+const log = createPrefixedLogger('SDK-MANAGER');
 /**
  * SDKManager - Singleton wrapper for ACubeSDK with simplified API
  *
@@ -9265,7 +6420,7 @@ class SDKManager {
                 if (canPoll && !this.isPollingActive) {
                     const hasCert = await this.checkCertificate();
                     if (!hasCert) {
-                        log$1.warn('Certificate missing — polling blocked until certificate is installed');
+                        log.warn('Certificate missing — polling blocked until certificate is installed');
                         return;
                     }
                     this.notificationService?.startPolling();
@@ -9367,7 +6522,7 @@ class SDKManager {
                 this.isPollingActive = true;
             }
             else {
-                log$1.warn('Certificate missing at init — polling blocked until certificate is installed');
+                log.warn('Certificate missing at init — polling blocked until certificate is installed');
             }
         }
         // AppStateService remains active for all users (handles OFFLINE network state)
@@ -9410,7 +6565,7 @@ class SDKManager {
         return this.certificateMissingSubject.asObservable();
     }
     /**
-     * Observable stream of telemetry state (data, isLoading, isCached, error)
+     * Observable stream of telemetry state (data, isLoading, error)
      */
     get telemetryState$() {
         this.ensureInitialized();
@@ -9494,7 +6649,7 @@ class SDKManager {
                     const user = await sdk.getCurrentUser();
                     const canPoll = user && hasAnyRole(user.roles, ['ROLE_MERCHANT', 'ROLE_CASHIER']);
                     if (canPoll) {
-                        log$1.info('Certificate installed — starting polling');
+                        log.info('Certificate installed — starting polling');
                         this.notificationService?.startPolling();
                         await this.startTelemetryPollingAuto();
                         this.isPollingActive = true;
@@ -9507,7 +6662,7 @@ class SDKManager {
                 this.certificateMissingSubject.next(true);
                 // Stop polling since certificate is required
                 if (this.isPollingActive) {
-                    log$1.info('Certificate removed — stopping polling');
+                    log.info('Certificate removed — stopping polling');
                     this.notificationService?.stopPolling();
                     this.telemetryService?.stopPolling();
                     this.telemetryService?.clearTelemetry();
@@ -9587,268 +6742,5 @@ 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;
-    }
-    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();
-    }
-}
-
-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);
-}
-
-var ErrorCategory;
-(function (ErrorCategory) {
-    ErrorCategory["SERVER_ERROR"] = "SERVER_ERROR";
-    ErrorCategory["CLIENT_ERROR"] = "CLIENT_ERROR";
-    ErrorCategory["AUTH_ERROR"] = "AUTH_ERROR";
-    ErrorCategory["CERTIFICATE_ERROR"] = "CERTIFICATE_ERROR";
-    ErrorCategory["NETWORK_ERROR"] = "NETWORK_ERROR";
-    ErrorCategory["UNKNOWN_ERROR"] = "UNKNOWN_ERROR";
-})(ErrorCategory || (ErrorCategory = {}));
-function extractStatusCode(error) {
-    if (error instanceof MTLSError && error.statusCode) {
-        return error.statusCode;
-    }
-    const errorObj = error;
-    if (errorObj?.response?.status) {
-        return errorObj.response.status;
-    }
-    if (typeof errorObj?.statusCode === 'number') {
-        return errorObj.statusCode;
-    }
-    return undefined;
-}
-function classifyError(error) {
-    const statusCode = extractStatusCode(error);
-    const errorMessage = error instanceof Error ? error.message : String(error);
-    if (statusCode && statusCode >= 500 && statusCode < 600) {
-        return {
-            category: ErrorCategory.SERVER_ERROR,
-            statusCode,
-            message: errorMessage,
-            shouldRetry: false,
-            userMessage: `Server error (${statusCode}): The server encountered an error.`,
-        };
-    }
-    if (statusCode === 401 || statusCode === 403) {
-        return {
-            category: ErrorCategory.AUTH_ERROR,
-            statusCode,
-            message: errorMessage,
-            shouldRetry: false,
-            userMessage: `Authentication error (${statusCode}): Invalid credentials or insufficient permissions.`,
-        };
-    }
-    if (statusCode && statusCode >= 400 && statusCode < 500) {
-        return {
-            category: ErrorCategory.CLIENT_ERROR,
-            statusCode,
-            message: errorMessage,
-            shouldRetry: false,
-            userMessage: `Request error (${statusCode}): ${errorMessage}`,
-        };
-    }
-    if (error instanceof MTLSError) {
-        return {
-            category: ErrorCategory.CERTIFICATE_ERROR,
-            statusCode,
-            message: errorMessage,
-            shouldRetry: true,
-            userMessage: 'Certificate error: Unable to establish secure connection.',
-        };
-    }
-    if (!statusCode &&
-        (errorMessage.toLowerCase().includes('network') ||
-            errorMessage.toLowerCase().includes('timeout') ||
-            errorMessage.toLowerCase().includes('connection'))) {
-        return {
-            category: ErrorCategory.NETWORK_ERROR,
-            message: errorMessage,
-            shouldRetry: true,
-            userMessage: 'Network error: Unable to connect to server.',
-        };
-    }
-    return {
-        category: ErrorCategory.UNKNOWN_ERROR,
-        statusCode,
-        message: errorMessage,
-        shouldRetry: false,
-        userMessage: `Unexpected error: ${errorMessage}`,
-    };
-}
-function shouldReconfigureCertificate(error) {
-    const classification = classifyError(error);
-    return classification.category === ErrorCategory.CERTIFICATE_ERROR;
-}
-function shouldRetryRequest(error, isRetryAttempt) {
-    if (isRetryAttempt) {
-        return false;
-    }
-    const classification = classifyError(error);
-    return classification.shouldRetry;
-}
-function getUserFriendlyMessage(error) {
-    const classification = classifyError(error);
-    return classification.userMessage;
-}
-
-var MTLSErrorType;
-(function (MTLSErrorType) {
-    MTLSErrorType["NOT_SUPPORTED"] = "MTLS_NOT_SUPPORTED";
-    MTLSErrorType["CERTIFICATE_NOT_FOUND"] = "MTLS_CERTIFICATE_NOT_FOUND";
-    MTLSErrorType["CERTIFICATE_EXPIRED"] = "MTLS_CERTIFICATE_EXPIRED";
-    MTLSErrorType["CERTIFICATE_INVALID"] = "MTLS_CERTIFICATE_INVALID";
-    MTLSErrorType["CONNECTION_FAILED"] = "MTLS_CONNECTION_FAILED";
-    MTLSErrorType["AUTHENTICATION_FAILED"] = "MTLS_AUTHENTICATION_FAILED";
-    MTLSErrorType["CONFIGURATION_ERROR"] = "MTLS_CONFIGURATION_ERROR";
-})(MTLSErrorType || (MTLSErrorType = {}));
-class PlatformDetector {
-    static detectPlatform() {
-        if ((typeof global !== 'undefined' && global.__expo) ||
-            (typeof navigator !== 'undefined' &&
-                navigator.product === 'ReactNative')) {
-            return 'react-native';
-        }
-        if (typeof process !== 'undefined' && process.versions?.node) {
-            return 'node';
-        }
-        return 'web';
-    }
-    static isReactNative() {
-        return this.detectPlatform() === 'react-native';
-    }
-    static isNode() {
-        return this.detectPlatform() === 'node';
-    }
-    static isWeb() {
-        return this.detectPlatform() === 'web';
-    }
-    static getPlatformDetails() {
-        const platform = this.detectPlatform();
-        return {
-            platform,
-            userAgent: typeof navigator !== 'undefined' ? navigator.userAgent : 'unknown',
-            nodeVersion: typeof process !== 'undefined' ? process.version : undefined,
-            isExpo: typeof global !== 'undefined' && !!global.__expo,
-            hasWindow: typeof window !== 'undefined',
-            hasDocument: typeof document !== 'undefined',
-            hasProcess: typeof process !== 'undefined',
-        };
-    }
-}
-
-export { ACubeSDK, ACubeSDKError, ActivationRequestSchema, AddressMapper, AddressSchema, AppStateService, AuthStrategy, AuthenticationService, AxiosHttpAdapter, CacheHandler, CashRegisterCreateSchema, CashRegisterMapper, CashRegisterRepositoryImpl, CashierCreateInputSchema, CashierMapper, CashierRepositoryImpl, CertificateService, CertificateValidator, ConfigManager, DAILY_REPORT_STATUS_OPTIONS, DEFAULT_QUEUE_CONFIG, DIContainer, DI_TOKENS, DailyReportMapper, DailyReportRepositoryImpl, DailyReportStatusSchema, DailyReportsParamsSchema, EXEMPT_VAT_CODES, ErrorCategory, GOOD_OR_SERVICE_OPTIONS, GoodOrServiceSchema, JournalCloseInputSchema, JournalMapper, JournalRepositoryImpl, JwtAuthHandler, LotterySchema, LotterySecretRequestSchema, MTLSError, MTLSErrorType$1 as MTLSErrorType, MerchantCreateInputSchema, MerchantMapper, MerchantRepositoryImpl, MerchantUpdateInputSchema, MessageSchema, MtlsAuthHandler, NOTIFICATION_CODES, NOTIFICATION_LEVELS, NOTIFICATION_SCOPES, NOTIFICATION_SOURCES, NOTIFICATION_TYPES, NotificationDataBlockAtSchema, NotificationDataPemStatusSchema, NotificationListResponseSchema, NotificationMapper, NotificationMf2UnreachableSchema, NotificationPemBackOnlineSchema, NotificationPemsBlockedSchema, NotificationRepositoryImpl, NotificationSchema, NotificationScopeSchema, NotificationService, OfflineManager, OperationQueue, PEMStatusOfflineRequestSchema, PEMStatusSchema, PEM_STATUS_OPTIONS, PEM_TYPE_OPTIONS, PemCreateInputSchema, PemDataSchema, PemMapper, PemRepositoryImpl, PemStatusSchema, PendingReceiptsSchema, PlatformDetector, PointOfSaleMapper, PointOfSaleRepositoryImpl, RECEIPT_PROOF_TYPE_OPTIONS, RECEIPT_READY, RECEIPT_SENT, RECEIPT_SORT_ASCENDING, RECEIPT_SORT_DESCENDING, ReceiptInputSchema, ReceiptItemSchema, ReceiptMapper, ReceiptProofTypeSchema, ReceiptRepositoryImpl, ReceiptReturnInputSchema, ReceiptReturnItemSchema, ReceiptReturnOrVoidViaPEMInputSchema, ReceiptReturnOrVoidWithProofInputSchema, SDKFactory, SDKManager, STANDARD_VAT_RATES, SupplierCreateInputSchema, SupplierMapper, SupplierRepositoryImpl, SupplierUpdateInputSchema, SyncManager, TelemetryMapper, TelemetryMerchantSchema, TelemetryRepositoryImpl, TelemetrySchema, TelemetryService, TelemetrySoftwareSchema, TelemetrySoftwareVersionSchema, TelemetrySupplierSchema, TransmissionSchema, VAT_RATE_CODES, VAT_RATE_CODE_OPTIONS, ValidationMessages, VatRateCodeSchema, VoidReceiptInputSchema, classifyError, clearObject, clearObjectShallow, createACubeMTLSConfig, createACubeSDK, createPrefixedLogger, createACubeSDK as default, detectPlatform, extractRoles, formatDecimal, getUserFriendlyMessage, hasAnyRole, hasNonEmptyValues, hasRole, isEmpty, isTokenExpired, loadPlatformAdapters, logger, parseJwt, shouldReconfigureCertificate, shouldRetryRequest, transformError, validateInput };
+export { ACubeSDK, ACubeSDKError, AddressMapper, AppStateService, AuthenticationService, CashRegisterMapper, CashierMapper, CertificateService, CertificateValidator, ConfigManager, DAILY_REPORT_STATUS_OPTIONS, DailyReportMapper, EXEMPT_VAT_CODES, GOOD_OR_SERVICE_OPTIONS, GoodOrServiceSchema, JournalMapper, MTLSError, MTLSErrorType, MerchantMapper, NOTIFICATION_CODES, NOTIFICATION_LEVELS, NOTIFICATION_SCOPES, NOTIFICATION_SOURCES, NOTIFICATION_TYPES, NotificationMapper, NotificationService, PEM_STATUS_OPTIONS, PEM_TYPE_OPTIONS, PemMapper, PointOfSaleMapper, RECEIPT_PROOF_TYPE_OPTIONS, RECEIPT_READY, RECEIPT_SENT, RECEIPT_SORT_ASCENDING, RECEIPT_SORT_DESCENDING, ReceiptMapper, ReceiptProofTypeSchema, SDKManager, STANDARD_VAT_RATES, SupplierMapper, TelemetryMapper, TelemetryService, VAT_RATE_CODES, VAT_RATE_CODE_OPTIONS, VatRateCodeSchema, createACubeMTLSConfig, createACubeSDK, createPrefixedLogger, createACubeSDK as default, extractRoles, hasAnyRole, hasRole, isTokenExpired, loadPlatformAdapters, logger, parseJwt };
 //# sourceMappingURL=index.native.js.map