@a-cube-io/ereceipts-js-sdk 2.1.0 → 2.2.0

package/dist/index.esm.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
@@ -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) {
@@ -2924,6 +2510,14 @@ class AuthStrategy {
         if (userRole === 'SUPPLIER') {
             return { mode: 'jwt', usePort444: false };
         }
+        if (url.includes('/download-data')) {
+            if (platform === 'mobile') {
+                return { mode: 'mtls', usePort444: true };
+            }
+            else {
+                return { mode: 'jwt', usePort444: true };
+            }
+        }
         if (userRole === 'CASHIER') {
             if (!isReceiptEndpoint) {
                 return { mode: 'jwt', usePort444: false };
@@ -3260,11 +2854,6 @@ class MtlsAuthHandler {
     }
 }
 
-/**
- * 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
@@ -4038,7 +3627,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";
@@ -4047,7 +3636,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);
@@ -4136,7 +3725,7 @@ 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$5.debug('Initialized with config:', {
@@ -4148,10 +3737,10 @@ 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$5.debug('Configuring certificate:', {
             format: certificateData.format,
@@ -4163,7 +3752,7 @@ 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
@@ -4172,19 +3761,19 @@ class ReactNativeMTLSAdapter {
                 );
                 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$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
@@ -4192,18 +3781,18 @@ class ReactNativeMTLSAdapter {
                 );
                 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$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;
         }
@@ -4212,7 +3801,7 @@ class ReactNativeMTLSAdapter {
                 throw error;
             }
             log$5.error('Certificate configuration failed:', error);
-            throw new MTLSError(MTLSErrorType$1.CONFIGURATION_ERROR, 'Failed to configure certificate', error);
+            throw new MTLSError(MTLSErrorType.CONFIGURATION_ERROR, 'Failed to configure certificate', error);
         }
     }
     async hasCertificate() {
@@ -4290,7 +3879,7 @@ class ReactNativeMTLSAdapter {
             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);
             }
@@ -4298,7 +3887,7 @@ 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$5.debug('Certificate parsed successfully:', {
                 certificateCount: result.certificates.length,
@@ -4311,16 +3900,16 @@ class ReactNativeMTLSAdapter {
             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$5.debug('Making mTLS request:', {
             method: requestConfig.method || 'GET',
@@ -4341,7 +3930,7 @@ class ReactNativeMTLSAdapter {
             });
             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
@@ -4369,7 +3958,7 @@ class ReactNativeMTLSAdapter {
         }
         catch (error) {
             log$5.error('mTLS request failed:', error);
-            throw new MTLSError(MTLSErrorType$1.CONNECTION_FAILED, 'mTLS request failed', error);
+            throw new MTLSError(MTLSErrorType.CONNECTION_FAILED, 'mTLS request failed', error);
         }
     }
     /**
@@ -4422,7 +4011,7 @@ class ReactNativeMTLSAdapter {
         }
         catch (error) {
             log$5.error('Failed to remove certificate:', error);
-            throw new MTLSError(MTLSErrorType$1.CONFIGURATION_ERROR, 'Failed to remove certificate', error);
+            throw new MTLSError(MTLSErrorType.CONFIGURATION_ERROR, 'Failed to remove certificate', error);
         }
     }
     /**
@@ -4512,7 +4101,7 @@ 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.');
     }
@@ -4536,7 +4125,7 @@ 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.');
     }
@@ -5358,6 +4947,12 @@ class PemRepositoryImpl {
         const response = await this.http.get(`/mf2/pems/${serialNumber}/certificates`);
         return PemMapper.fromCertificatesApiOutput(response.data);
     }
+    async downloadData(serialNumber) {
+        const response = await this.http.get(`/mf1/pems/${serialNumber}/download-data`, {
+            responseType: 'arraybuffer',
+        });
+        return response.data;
+    }
 }
 
 class DailyReportMapper {
@@ -7161,183 +6756,5 @@ const RECEIPT_SENT = 'sent';
 const RECEIPT_SORT_DESCENDING = 'descending';
 const RECEIPT_SORT_ASCENDING = 'ascending';
 
-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, CashRegisterCreateSchema, CashRegisterMapper, CashRegisterRepositoryImpl, CashierCreateInputSchema, CashierMapper, CashierRepositoryImpl, CertificateService, CertificateValidator, ConfigManager, DAILY_REPORT_STATUS_OPTIONS, 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, 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, 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.esm.js.map