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

package/dist/index.cjs.js

@@ -1892,27 +1892,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
@@ -2469,7 +2448,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',
@@ -2496,103 +2475,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__namespace.enum(VAT_RATE_CODE_OPTIONS);
 const GoodOrServiceSchema = z__namespace.enum(GOOD_OR_SERVICE_OPTIONS);
 const ReceiptProofTypeSchema = z__namespace.enum(RECEIPT_PROOF_TYPE_OPTIONS);
-// Receipt Item Schema
-const ReceiptItemSchema = z__namespace.object({
-    type: GoodOrServiceSchema.optional(),
-    quantity: z__namespace.string().min(1, { error: 'fieldIsRequired' }),
-    description: z__namespace.string().min(1, { error: 'fieldIsRequired' }),
-    unit_price: z__namespace.string().min(1, { error: 'fieldIsRequired' }),
-    vat_rate_code: VatRateCodeSchema.optional(),
-    simplified_vat_allocation: z__namespace.boolean().optional(),
-    discount: z__namespace.string().nullable().optional(),
-    is_down_payment_or_voucher_redemption: z__namespace.boolean().optional(),
-    complimentary: z__namespace.boolean().optional(),
-});
-// Main Receipt Input Schema
-const ReceiptInputSchema = z__namespace
-    .object({
-    items: z__namespace.array(ReceiptItemSchema).min(1, { error: 'arrayMin1' }),
-    customer_tax_code: z__namespace.string().optional(),
-    customer_lottery_code: z__namespace.string().optional(),
-    discount: z__namespace.string().nullable().optional(),
-    invoice_issuing: z__namespace.boolean().optional(),
-    uncollected_dcr_to_ssn: z__namespace.boolean().optional(),
-    services_uncollected_amount: z__namespace.string().nullable().optional(),
-    goods_uncollected_amount: z__namespace.string().nullable().optional(),
-    cash_payment_amount: z__namespace.string().nullable().optional(),
-    electronic_payment_amount: z__namespace.string().nullable().optional(),
-    ticket_restaurant_payment_amount: z__namespace.string().nullable().optional(),
-    ticket_restaurant_quantity: z__namespace.number().optional(),
-})
-    .refine((data) => {
-    // At least one payment method should be provided
-    const hasCashPayment = data.cash_payment_amount && parseFloat(data.cash_payment_amount) > 0;
-    const hasElectronicPayment = data.electronic_payment_amount && parseFloat(data.electronic_payment_amount) > 0;
-    const hasTicketPayment = data.ticket_restaurant_payment_amount &&
-        parseFloat(data.ticket_restaurant_payment_amount) > 0;
-    return hasCashPayment || hasElectronicPayment || hasTicketPayment;
-}, {
-    error: 'At least one payment method is required',
-    path: ['payment_methods'],
-})
-    .refine((data) => {
-    // only one between customer_tax_code and customer_lottery_code can be provided
-    return !data.customer_tax_code || !data.customer_lottery_code;
-}, {
-    error: 'Only one between customer_tax_code and customer_lottery_code can be provided',
-    path: ['customer_tax_code', 'customer_lottery_code'],
-});
-// Receipt Return or Void via PEM Schema
-const ReceiptReturnOrVoidViaPEMInputSchema = z__namespace.object({
-    device_id: z__namespace.string().optional(),
-    items: z__namespace.array(ReceiptItemSchema).min(1, { error: 'arrayMin1' }),
-    document_number: z__namespace.string().min(1, { error: 'fieldIsRequired' }),
-    document_datetime: z__namespace.string().optional(),
-    lottery_code: z__namespace.string().optional(),
-});
-// Receipt Return or Void with Proof Schema
-const ReceiptReturnOrVoidWithProofInputSchema = z__namespace.object({
-    items: z__namespace.array(ReceiptItemSchema).min(1, { error: 'arrayMin1' }),
-    proof: ReceiptProofTypeSchema,
-    document_datetime: z__namespace.string().min(1, { error: 'fieldIsRequired' }),
-});
-// Void Receipt Schema
-const VoidReceiptInputSchema = z__namespace.object({
-    document_number: z__namespace.string().min(1, { error: 'fieldIsRequired' }),
-});
-const ReceiptReturnItemSchema = z__namespace
-    .array(z__namespace.object({
-    id: z__namespace.number(),
-    quantity: z__namespace.string().min(1, { error: 'fieldIsRequired' }),
-}))
-    .min(1, { error: 'arrayMin1' });
-// Receipt Return Schema
-const ReceiptReturnInputSchema = z__namespace.object({
-    items: z__namespace.array(ReceiptReturnItemSchema).min(1, { error: 'arrayMin1' }),
-    document_number: z__namespace.string().min(1, { error: 'fieldIsRequired' }),
-});
-
-// Cashier Create Input Schema (MF1)
-const CashierCreateInputSchema = z__namespace.object({
-    email: z__namespace
-        .string()
-        .min(1, { error: 'fieldIsRequired' })
-        .max(255, { error: 'emailMaxLength' })
-        .email({ error: 'invalidEmail' }),
-    password: z__namespace
-        .string()
-        .min(8, { error: 'passwordMinLength' })
-        .max(40, { error: 'passwordMaxLength' }),
-    name: z__namespace.string().min(1, { error: 'fieldIsRequired' }).max(255, { error: 'nameMaxLength' }),
-    display_name: z__namespace
-        .string()
-        .min(1, { error: 'fieldIsRequired' })
-        .max(255, { error: 'displayNameMaxLength' }),
-});
 
 // Enum options arrays
 const PEM_STATUS_OPTIONS = [
@@ -2603,312 +2489,12 @@ const PEM_STATUS_OPTIONS = [
     'OFFLINE',
     'DISCARDED',
 ];
-// Address Schema (reusable)
-const AddressSchema = z__namespace.object({
-    street_address: z__namespace.string().min(1, { error: 'fieldIsRequired' }),
-    street_number: z__namespace.string().min(1, { error: 'fieldIsRequired' }),
-    zip_code: z__namespace
-        .string()
-        .min(1, { error: 'fieldIsRequired' })
-        .regex(/^\d{5}$/, { error: 'invalidZipCode' }),
-    city: z__namespace.string().min(1, { error: 'fieldIsRequired' }),
-    province: z__namespace
-        .string()
-        .min(2, { error: 'provinceMinLength' })
-        .max(2, { error: 'provinceMaxLength' })
-        .toUpperCase(),
-});
-// PEM Status Schema
-const PEMStatusSchema = z__namespace.enum(PEM_STATUS_OPTIONS);
-// Activation Request Schema
-const ActivationRequestSchema = z__namespace.object({
-    registration_key: z__namespace.string().min(1, { error: 'fieldIsRequired' }),
-});
-// PEM Status Offline Request Schema
-const PEMStatusOfflineRequestSchema = z__namespace.object({
-    timestamp: z__namespace
-        .string()
-        .min(1, { error: 'fieldIsRequired' })
-        .refine((val) => !isNaN(Date.parse(val)), {
-        error: 'invalidDateFormat',
-    }),
-    reason: z__namespace.string().min(1, { error: 'fieldIsRequired' }),
-});
-
-// Cash Register Create Schema
-const CashRegisterCreateSchema = z__namespace.object({
-    pem_serial_number: z__namespace.string().min(1, { error: 'fieldIsRequired' }),
-    name: z__namespace.string().min(1, { error: 'fieldIsRequired' }).max(100, { error: 'nameMaxLength' }),
-});
-
-// VAT number validation regex (Partita IVA - 11 digits)
-const VAT_NUMBER_REGEX = /^\d{11}$/;
-// Fiscal code validation regex (Codice Fiscale - 11 digits only for merchants)
-const FISCAL_CODE_REGEX = /^\d{11}$/;
-// Password validation regex (from OpenAPI spec)
-const PASSWORD_REGEX = /^((?=.*[A-Z])(?=.*[a-z])(?=.*[0-9])(?=.*[!@#$%^&*])(?=.{10,}).*)$/;
-// Merchant Create Input Schema
-const MerchantCreateInputSchema = z__namespace
-    .object({
-    vat_number: z__namespace
-        .string()
-        .min(1, { error: 'fieldIsRequired' })
-        .regex(VAT_NUMBER_REGEX, { error: 'invalidVatNumber' }),
-    fiscal_code: z__namespace.string().regex(FISCAL_CODE_REGEX, { error: 'invalidFiscalCode' }).optional(),
-    business_name: z__namespace.string().max(200, { error: 'businessNameMaxLength' }).optional().nullable(),
-    first_name: z__namespace.string().max(100, { error: 'firstNameMaxLength' }).optional().nullable(),
-    last_name: z__namespace.string().max(100, { error: 'lastNameMaxLength' }).optional().nullable(),
-    email: z__namespace.string().min(1, { error: 'fieldIsRequired' }).email({ error: 'invalidEmail' }),
-    password: z__namespace
-        .string()
-        .min(1, { error: 'fieldIsRequired' })
-        .regex(PASSWORD_REGEX, { error: 'passwordComplexity' }),
-    address: AddressSchema.optional(),
-})
-    .refine((data) => {
-    const hasBusinessName = data.business_name && data.business_name.trim() !== '';
-    const hasPersonalNames = (data.first_name && data.first_name.trim() !== '') ||
-        (data.last_name && data.last_name.trim() !== '');
-    // If business name is set, first/last name must not be provided
-    if (hasBusinessName && hasPersonalNames) {
-        return false;
-    }
-    // At least one naming method must be provided
-    if (!hasBusinessName && !hasPersonalNames) {
-        return false;
-    }
-    return true;
-}, {
-    error: 'businessNameOrPersonalNamesRequired',
-    path: ['business_name'],
-});
-// Merchant Update Input Schema
-const MerchantUpdateInputSchema = z__namespace.object({
-    business_name: z__namespace.string().max(200, { error: 'businessNameMaxLength' }).optional().nullable(),
-    first_name: z__namespace.string().max(100, { error: 'firstNameMaxLength' }).optional().nullable(),
-    last_name: z__namespace.string().max(100, { error: 'lastNameMaxLength' }).optional().nullable(),
-    address: AddressSchema.optional().nullable(),
-});
 
 // Enum options arrays
 const PEM_TYPE_OPTIONS = ['AP', 'SP', 'TM', 'PV'];
-// PEM Data Schema
-const PemDataSchema = z__namespace.object({
-    version: z__namespace.string().min(1, { error: 'fieldIsRequired' }),
-    type: z__namespace.enum(PEM_TYPE_OPTIONS, {
-        error: 'invalidPemType',
-    }),
-});
-// PEM Create Input Schema
-const PemCreateInputSchema = z__namespace.object({
-    merchant_uuid: z__namespace.string().min(1, { error: 'fieldIsRequired' }).uuid({ error: 'invalidUuid' }),
-    address: AddressSchema.optional(),
-    /* external_pem_data: PemDataSchema.optional(), */
-});
 
-// Italian Fiscal ID validation regex (Codice Fiscale for individuals or Partita IVA for companies)
-const FISCAL_ID_REGEX = /^([A-Z]{6}[0-9LMNPQRSTUV]{2}[ABCDEHLMPRST][0-9LMNPQRSTUV]{2}[A-Z][0-9LMNPQRSTUV]{3}[A-Z]|[0-9]{11})$/;
-// Supplier Create Input Schema
-const SupplierCreateInputSchema = z__namespace.object({
-    fiscal_id: z__namespace
-        .string()
-        .min(1, { error: 'fieldIsRequired' })
-        .regex(FISCAL_ID_REGEX, { error: 'invalidFiscalId' })
-        .toUpperCase(),
-    name: z__namespace.string().min(1, { error: 'fieldIsRequired' }).max(200, { error: 'nameMaxLength' }),
-    address: AddressSchema.optional(),
-});
-// Supplier Update Input Schema
-const SupplierUpdateInputSchema = z__namespace.object({
-    name: z__namespace.string().min(1, { error: 'fieldIsRequired' }).max(200, { error: 'nameMaxLength' }),
-    address: AddressSchema.optional(),
-});
-
-// Journal Close Input Schema
-const JournalCloseInputSchema = z__namespace.object({
-    closing_timestamp: z__namespace
-        .string()
-        .min(1, { error: 'fieldIsRequired' })
-        .refine((val) => !isNaN(Date.parse(val)), {
-        error: 'invalidDateFormat',
-    }),
-    reason: z__namespace.string().max(255, { error: 'reasonMaxLength' }).optional(),
-});
-
-// Daily Report Status Options
+// Enum options arrays
 const DAILY_REPORT_STATUS_OPTIONS = ['pending', 'sent', 'error'];
-// Daily Report Status Schema
-const DailyReportStatusSchema = z__namespace.enum(DAILY_REPORT_STATUS_OPTIONS, {
-    error: 'invalidDailyReportStatus',
-});
-// Daily Reports List Parameters Schema
-const DailyReportsParamsSchema = z__namespace.object({
-    pem_serial_number: z__namespace.string().min(1, { error: 'fieldIsRequired' }).optional(),
-    date_from: z__namespace
-        .string()
-        .refine((val) => !isNaN(Date.parse(val)), {
-        error: 'invalidDateFormat',
-    })
-        .optional(),
-    date_to: z__namespace
-        .string()
-        .refine((val) => !isNaN(Date.parse(val)), {
-        error: 'invalidDateFormat',
-    })
-        .optional(),
-    status: DailyReportStatusSchema.optional(),
-    page: z__namespace.number().min(1, { error: 'pageMinValue' }).optional(),
-});
-
-const NotificationScopeSchema = z__namespace.object({
-    type: z__namespace.literal('global'),
-});
-const PemStatusSchema = z__namespace.enum(['ONLINE', 'OFFLINE']);
-const NotificationDataBlockAtSchema = z__namespace.object({
-    block_at: z__namespace.string(),
-});
-const NotificationDataPemStatusSchema = z__namespace.object({
-    from: PemStatusSchema,
-    to: PemStatusSchema,
-});
-const NotificationBaseSchema = z__namespace.object({
-    uuid: z__namespace.string().uuid({ error: 'invalidUuid' }),
-    scope: NotificationScopeSchema,
-    source: z__namespace.enum(['system', 'Italian Tax Authority']),
-    level: z__namespace.enum(['info', 'warning', 'error', 'critical']),
-    created_at: z__namespace.string(),
-});
-const NotificationMf2UnreachableSchema = NotificationBaseSchema.extend({
-    type: z__namespace.literal('INTERNAL_COMMUNICATION_FAILURE'),
-    code: z__namespace.literal('SYS-W-01'),
-    data: NotificationDataBlockAtSchema,
-});
-const NotificationPemsBlockedSchema = NotificationBaseSchema.extend({
-    type: z__namespace.literal('PEM_STATUS_CHANGED'),
-    code: z__namespace.literal('SYS-C-01'),
-    data: NotificationDataPemStatusSchema,
-});
-const NotificationPemBackOnlineSchema = NotificationBaseSchema.extend({
-    type: z__namespace.literal('PEM_STATUS_CHANGED'),
-    code: z__namespace.literal('SYS-I-01'),
-    data: NotificationDataPemStatusSchema,
-});
-const NotificationSchema = z__namespace.discriminatedUnion('code', [
-    NotificationMf2UnreachableSchema,
-    NotificationPemsBlockedSchema,
-    NotificationPemBackOnlineSchema,
-]);
-const NotificationListResponseSchema = z__namespace.object({
-    members: z__namespace.array(NotificationSchema),
-});
-
-const TelemetryMerchantSchema = z__namespace.object({
-    vat_number: z__namespace.string(),
-    fiscal_code: z__namespace.string().nullable(),
-    business_name: z__namespace.string(),
-});
-const TelemetrySupplierSchema = z__namespace.object({
-    vat_number: z__namespace.string(),
-    fiscal_code: z__namespace.string().nullable(),
-    business_name: z__namespace.string(),
-});
-const TelemetrySoftwareVersionSchema = z__namespace.object({
-    version: z__namespace.string(),
-    swid: z__namespace.string(),
-    installed_at: z__namespace.string(),
-    status: z__namespace.enum(['active', 'inactive', 'archived']),
-});
-const TelemetrySoftwareSchema = z__namespace.object({
-    code: z__namespace.string(),
-    name: z__namespace.string(),
-    approval_reference: z__namespace.string(),
-    version_info: TelemetrySoftwareVersionSchema,
-});
-const PendingReceiptsSchema = z__namespace.object({
-    count: z__namespace.number().int().nonnegative(),
-    total_amount: z__namespace.string(),
-});
-const TransmissionSchema = z__namespace.object({
-    attempted_at: z__namespace.string(),
-    outcome: z__namespace.enum(['success', 'failed', 'pending']),
-});
-const MessageSchema = z__namespace.object({
-    received_at: z__namespace.string(),
-    content: z__namespace.string(),
-});
-const LotterySecretRequestSchema = z__namespace.object({
-    requested_at: z__namespace.string(),
-    outcome: z__namespace.enum(['success', 'failed', 'pending']),
-});
-const LotterySchema = z__namespace.object({
-    last_transmission: TransmissionSchema,
-    secret_request: LotterySecretRequestSchema,
-});
-const TelemetrySchema = z__namespace.object({
-    pem_id: z__namespace.string(),
-    pem_status: z__namespace.enum(['ONLINE', 'OFFLINE', 'ERROR']),
-    pem_status_changed_at: z__namespace.string(),
-    merchant: TelemetryMerchantSchema,
-    supplier: TelemetrySupplierSchema,
-    software: TelemetrySoftwareSchema,
-    last_communication_at: z__namespace.string(),
-    pending_receipts: PendingReceiptsSchema,
-    last_receipt_transmission: TransmissionSchema,
-    last_message_from_mf2: MessageSchema,
-    ade_corrispettivi_transmission: TransmissionSchema,
-    last_message_from_ade: MessageSchema,
-    lottery: LotterySchema,
-});
-
-// 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) {
@@ -3283,11 +2869,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
@@ -7184,310 +6765,59 @@ 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);
-}
-
-exports.ErrorCategory = void 0;
-(function (ErrorCategory) {
-    ErrorCategory["SERVER_ERROR"] = "SERVER_ERROR";
-    ErrorCategory["CLIENT_ERROR"] = "CLIENT_ERROR";
-    ErrorCategory["AUTH_ERROR"] = "AUTH_ERROR";
-    ErrorCategory["CERTIFICATE_ERROR"] = "CERTIFICATE_ERROR";
-    ErrorCategory["NETWORK_ERROR"] = "NETWORK_ERROR";
-    ErrorCategory["UNKNOWN_ERROR"] = "UNKNOWN_ERROR";
-})(exports.ErrorCategory || (exports.ErrorCategory = {}));
-function extractStatusCode(error) {
-    if (error instanceof MTLSError && error.statusCode) {
-        return error.statusCode;
-    }
-    const errorObj = error;
-    if (errorObj?.response?.status) {
-        return errorObj.response.status;
-    }
-    if (typeof errorObj?.statusCode === 'number') {
-        return errorObj.statusCode;
-    }
-    return undefined;
-}
-function classifyError(error) {
-    const statusCode = extractStatusCode(error);
-    const errorMessage = error instanceof Error ? error.message : String(error);
-    if (statusCode && statusCode >= 500 && statusCode < 600) {
-        return {
-            category: exports.ErrorCategory.SERVER_ERROR,
-            statusCode,
-            message: errorMessage,
-            shouldRetry: false,
-            userMessage: `Server error (${statusCode}): The server encountered an error.`,
-        };
-    }
-    if (statusCode === 401 || statusCode === 403) {
-        return {
-            category: exports.ErrorCategory.AUTH_ERROR,
-            statusCode,
-            message: errorMessage,
-            shouldRetry: false,
-            userMessage: `Authentication error (${statusCode}): Invalid credentials or insufficient permissions.`,
-        };
-    }
-    if (statusCode && statusCode >= 400 && statusCode < 500) {
-        return {
-            category: exports.ErrorCategory.CLIENT_ERROR,
-            statusCode,
-            message: errorMessage,
-            shouldRetry: false,
-            userMessage: `Request error (${statusCode}): ${errorMessage}`,
-        };
-    }
-    if (error instanceof MTLSError) {
-        return {
-            category: exports.ErrorCategory.CERTIFICATE_ERROR,
-            statusCode,
-            message: errorMessage,
-            shouldRetry: true,
-            userMessage: 'Certificate error: Unable to establish secure connection.',
-        };
-    }
-    if (!statusCode &&
-        (errorMessage.toLowerCase().includes('network') ||
-            errorMessage.toLowerCase().includes('timeout') ||
-            errorMessage.toLowerCase().includes('connection'))) {
-        return {
-            category: exports.ErrorCategory.NETWORK_ERROR,
-            message: errorMessage,
-            shouldRetry: true,
-            userMessage: 'Network error: Unable to connect to server.',
-        };
-    }
-    return {
-        category: exports.ErrorCategory.UNKNOWN_ERROR,
-        statusCode,
-        message: errorMessage,
-        shouldRetry: false,
-        userMessage: `Unexpected error: ${errorMessage}`,
-    };
-}
-function shouldReconfigureCertificate(error) {
-    const classification = classifyError(error);
-    return classification.category === exports.ErrorCategory.CERTIFICATE_ERROR;
-}
-function shouldRetryRequest(error, isRetryAttempt) {
-    if (isRetryAttempt) {
-        return false;
-    }
-    const classification = classifyError(error);
-    return classification.shouldRetry;
-}
-function getUserFriendlyMessage(error) {
-    const classification = classifyError(error);
-    return classification.userMessage;
-}
-
-var MTLSErrorType;
-(function (MTLSErrorType) {
-    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',
-        };
-    }
-}
-
 exports.ACubeSDK = ACubeSDK;
 exports.ACubeSDKError = ACubeSDKError;
-exports.ActivationRequestSchema = ActivationRequestSchema;
 exports.AddressMapper = AddressMapper;
-exports.AddressSchema = AddressSchema;
 exports.AppStateService = AppStateService;
-exports.AuthStrategy = AuthStrategy;
 exports.AuthenticationService = AuthenticationService;
-exports.AxiosHttpAdapter = AxiosHttpAdapter;
-exports.CashRegisterCreateSchema = CashRegisterCreateSchema;
 exports.CashRegisterMapper = CashRegisterMapper;
-exports.CashRegisterRepositoryImpl = CashRegisterRepositoryImpl;
-exports.CashierCreateInputSchema = CashierCreateInputSchema;
 exports.CashierMapper = CashierMapper;
-exports.CashierRepositoryImpl = CashierRepositoryImpl;
 exports.CertificateService = CertificateService;
 exports.CertificateValidator = CertificateValidator;
 exports.ConfigManager = ConfigManager;
 exports.DAILY_REPORT_STATUS_OPTIONS = DAILY_REPORT_STATUS_OPTIONS;
-exports.DIContainer = DIContainer;
-exports.DI_TOKENS = DI_TOKENS;
 exports.DailyReportMapper = DailyReportMapper;
-exports.DailyReportRepositoryImpl = DailyReportRepositoryImpl;
-exports.DailyReportStatusSchema = DailyReportStatusSchema;
-exports.DailyReportsParamsSchema = DailyReportsParamsSchema;
 exports.EXEMPT_VAT_CODES = EXEMPT_VAT_CODES;
 exports.GOOD_OR_SERVICE_OPTIONS = GOOD_OR_SERVICE_OPTIONS;
 exports.GoodOrServiceSchema = GoodOrServiceSchema;
-exports.JournalCloseInputSchema = JournalCloseInputSchema;
 exports.JournalMapper = JournalMapper;
-exports.JournalRepositoryImpl = JournalRepositoryImpl;
-exports.JwtAuthHandler = JwtAuthHandler;
-exports.LotterySchema = LotterySchema;
-exports.LotterySecretRequestSchema = LotterySecretRequestSchema;
 exports.MTLSError = MTLSError;
-exports.MerchantCreateInputSchema = MerchantCreateInputSchema;
 exports.MerchantMapper = MerchantMapper;
-exports.MerchantRepositoryImpl = MerchantRepositoryImpl;
-exports.MerchantUpdateInputSchema = MerchantUpdateInputSchema;
-exports.MessageSchema = MessageSchema;
-exports.MtlsAuthHandler = MtlsAuthHandler;
 exports.NOTIFICATION_CODES = NOTIFICATION_CODES;
 exports.NOTIFICATION_LEVELS = NOTIFICATION_LEVELS;
 exports.NOTIFICATION_SCOPES = NOTIFICATION_SCOPES;
 exports.NOTIFICATION_SOURCES = NOTIFICATION_SOURCES;
 exports.NOTIFICATION_TYPES = NOTIFICATION_TYPES;
-exports.NotificationDataBlockAtSchema = NotificationDataBlockAtSchema;
-exports.NotificationDataPemStatusSchema = NotificationDataPemStatusSchema;
-exports.NotificationListResponseSchema = NotificationListResponseSchema;
 exports.NotificationMapper = NotificationMapper;
-exports.NotificationMf2UnreachableSchema = NotificationMf2UnreachableSchema;
-exports.NotificationPemBackOnlineSchema = NotificationPemBackOnlineSchema;
-exports.NotificationPemsBlockedSchema = NotificationPemsBlockedSchema;
-exports.NotificationRepositoryImpl = NotificationRepositoryImpl;
-exports.NotificationSchema = NotificationSchema;
-exports.NotificationScopeSchema = NotificationScopeSchema;
 exports.NotificationService = NotificationService;
-exports.PEMStatusOfflineRequestSchema = PEMStatusOfflineRequestSchema;
-exports.PEMStatusSchema = PEMStatusSchema;
 exports.PEM_STATUS_OPTIONS = PEM_STATUS_OPTIONS;
 exports.PEM_TYPE_OPTIONS = PEM_TYPE_OPTIONS;
-exports.PemCreateInputSchema = PemCreateInputSchema;
-exports.PemDataSchema = PemDataSchema;
 exports.PemMapper = PemMapper;
-exports.PemRepositoryImpl = PemRepositoryImpl;
-exports.PemStatusSchema = PemStatusSchema;
-exports.PendingReceiptsSchema = PendingReceiptsSchema;
-exports.PlatformDetector = PlatformDetector;
 exports.PointOfSaleMapper = PointOfSaleMapper;
-exports.PointOfSaleRepositoryImpl = PointOfSaleRepositoryImpl;
 exports.RECEIPT_PROOF_TYPE_OPTIONS = RECEIPT_PROOF_TYPE_OPTIONS;
 exports.RECEIPT_READY = RECEIPT_READY;
 exports.RECEIPT_SENT = RECEIPT_SENT;
 exports.RECEIPT_SORT_ASCENDING = RECEIPT_SORT_ASCENDING;
 exports.RECEIPT_SORT_DESCENDING = RECEIPT_SORT_DESCENDING;
-exports.ReceiptInputSchema = ReceiptInputSchema;
-exports.ReceiptItemSchema = ReceiptItemSchema;
 exports.ReceiptMapper = ReceiptMapper;
 exports.ReceiptProofTypeSchema = ReceiptProofTypeSchema;
-exports.ReceiptRepositoryImpl = ReceiptRepositoryImpl;
-exports.ReceiptReturnInputSchema = ReceiptReturnInputSchema;
-exports.ReceiptReturnItemSchema = ReceiptReturnItemSchema;
-exports.ReceiptReturnOrVoidViaPEMInputSchema = ReceiptReturnOrVoidViaPEMInputSchema;
-exports.ReceiptReturnOrVoidWithProofInputSchema = ReceiptReturnOrVoidWithProofInputSchema;
-exports.SDKFactory = SDKFactory;
 exports.SDKManager = SDKManager;
 exports.STANDARD_VAT_RATES = STANDARD_VAT_RATES;
-exports.SupplierCreateInputSchema = SupplierCreateInputSchema;
 exports.SupplierMapper = SupplierMapper;
-exports.SupplierRepositoryImpl = SupplierRepositoryImpl;
-exports.SupplierUpdateInputSchema = SupplierUpdateInputSchema;
 exports.TelemetryMapper = TelemetryMapper;
-exports.TelemetryMerchantSchema = TelemetryMerchantSchema;
-exports.TelemetryRepositoryImpl = TelemetryRepositoryImpl;
-exports.TelemetrySchema = TelemetrySchema;
 exports.TelemetryService = TelemetryService;
-exports.TelemetrySoftwareSchema = TelemetrySoftwareSchema;
-exports.TelemetrySoftwareVersionSchema = TelemetrySoftwareVersionSchema;
-exports.TelemetrySupplierSchema = TelemetrySupplierSchema;
-exports.TransmissionSchema = TransmissionSchema;
 exports.VAT_RATE_CODES = VAT_RATE_CODES;
 exports.VAT_RATE_CODE_OPTIONS = VAT_RATE_CODE_OPTIONS;
-exports.ValidationMessages = ValidationMessages;
 exports.VatRateCodeSchema = VatRateCodeSchema;
-exports.VoidReceiptInputSchema = VoidReceiptInputSchema;
-exports.classifyError = classifyError;
-exports.clearObject = clearObject;
-exports.clearObjectShallow = clearObjectShallow;
 exports.createACubeMTLSConfig = createACubeMTLSConfig;
 exports.createACubeSDK = createACubeSDK;
 exports.createPrefixedLogger = createPrefixedLogger;
 exports.default = createACubeSDK;
-exports.detectPlatform = detectPlatform;
 exports.extractRoles = extractRoles;
-exports.formatDecimal = formatDecimal;
-exports.getUserFriendlyMessage = getUserFriendlyMessage;
 exports.hasAnyRole = hasAnyRole;
-exports.hasNonEmptyValues = hasNonEmptyValues;
 exports.hasRole = hasRole;
-exports.isEmpty = isEmpty;
 exports.isTokenExpired = isTokenExpired;
 exports.loadPlatformAdapters = loadPlatformAdapters;
 exports.logger = logger;
 exports.parseJwt = parseJwt;
-exports.shouldReconfigureCertificate = shouldReconfigureCertificate;
-exports.shouldRetryRequest = shouldRetryRequest;
-exports.transformError = transformError;
-exports.validateInput = validateInput;
 //# sourceMappingURL=index.cjs.js.map