@a-cube-io/ereceipts-js-sdk 1.0.0

package/dist/index.js

@@ -0,0 +1,1065 @@
+import { isAuthenticated, getCurrentUser, loginProvider, AuthenticationError, loginMerchant, loginCashier, logout, validateAddress, validateEmail, validateFiscalId } from './chunk-C3YEL4ED.js';
+export { AuthenticationError, combineValidationResults, getCurrentUser, hasRole, isAuthenticated, loginCashier, loginMerchant, loginProvider, logout, refreshToken, validateAddress, validateEmail, validateFiscalId, validateMoneyAmount, validatePassword, validateProvinceCode, validateReceiptItem, validateRequired, validateZipCode } from './chunk-C3YEL4ED.js';
+import { getAPIClient, MF1_PATHS, MF2_PATHS, isConnected, addNetworkListener } from './chunk-VDHN3FKS.js';
+export { APIClient, API_ENDPOINTS, AxiosRetryInterceptor, MF1_PATHS, MF2_PATHS, addNetworkListener, calculateJitteredDelay, calculateRetryDelay, checkInternetConnectivity, configureSDK, getAPIClient, getBaseURL, getNetworkState, initializeAPIClient, isConnected, isRetryableError, removeNetworkListener, retryAsync, waitForConnection, withRetry } from './chunk-VDHN3FKS.js';
+import { SecureTokenStorage, networkLogger } from './chunk-YX3PJ4FC.js';
+export { SecureTokenStorage, apiLogger, authLogger, logDebug, logError, logInfo, logWarn, networkLogger, storageLogger, uiLogger } from './chunk-YX3PJ4FC.js';
+import { RequestQueue } from './chunk-UBEIMFLN.js';
+export { RequestQueue } from './chunk-UBEIMFLN.js';
+import { __name, getMTLSCertificateKey, getMTLSPrivateKeyKey } from './chunk-K65HAAAO.js';
+export { SECURE_KEYS, STORAGE_KEYS, getMTLSCertificateKey, getMTLSPrivateKeyKey } from './chunk-K65HAAAO.js';
+import React2, { forwardRef, useState, useCallback, useEffect } from 'react';
+import { StyleSheet, View, Text, TextInput, TouchableOpacity, ActivityIndicator } from 'react-native';
+
+/* A-Cube SDK - Professional TypeScript SDK for Italian e-receipt system */
+
+// src/api/mf1.ts
+var createCashier = /* @__PURE__ */ __name(async (data) => {
+  const client = getAPIClient();
+  const response = await client.post(MF1_PATHS.CASHIERS, data);
+  return response.data;
+}, "createCashier");
+var getCashiers = /* @__PURE__ */ __name(async (page = 1, size = 30) => {
+  const client = getAPIClient();
+  const response = await client.get(`${MF1_PATHS.CASHIERS}?page=${page}&size=${size}`);
+  return response.data;
+}, "getCashiers");
+var getCashierById = /* @__PURE__ */ __name(async (id) => {
+  const client = getAPIClient();
+  const response = await client.get(MF1_PATHS.CASHIER_BY_ID(id));
+  return response.data;
+}, "getCashierById");
+var getCurrentCashier = /* @__PURE__ */ __name(async () => {
+  const client = getAPIClient();
+  const response = await client.get(MF1_PATHS.CASHIER_ME);
+  return response.data;
+}, "getCurrentCashier");
+var deleteCashier = /* @__PURE__ */ __name(async (id) => {
+  const client = getAPIClient();
+  await client.delete(MF1_PATHS.CASHIER_BY_ID(id));
+}, "deleteCashier");
+var getPointOfSales = /* @__PURE__ */ __name(async (status, page = 1, size = 30) => {
+  const client = getAPIClient();
+  let url = `${MF1_PATHS.POINT_OF_SALES}?page=${page}&size=${size}`;
+  if (status) {
+    url += `&status=${status}`;
+  }
+  const response = await client.get(url);
+  return response.data;
+}, "getPointOfSales");
+var getPointOfSaleBySerial = /* @__PURE__ */ __name(async (serialNumber) => {
+  const client = getAPIClient();
+  const response = await client.get(MF1_PATHS.POINT_OF_SALE_BY_SERIAL(serialNumber));
+  return response.data;
+}, "getPointOfSaleBySerial");
+var activatePointOfSale = /* @__PURE__ */ __name(async (serialNumber, registrationKey) => {
+  const client = getAPIClient();
+  await client.post(MF1_PATHS.POINT_OF_SALE_ACTIVATION(serialNumber), {
+    registration_key: registrationKey
+  });
+}, "activatePointOfSale");
+var createInactivityPeriod = /* @__PURE__ */ __name(async (serialNumber) => {
+  const client = getAPIClient();
+  await client.post(MF1_PATHS.POINT_OF_SALE_INACTIVITY(serialNumber));
+}, "createInactivityPeriod");
+var setPointOfSaleOffline = /* @__PURE__ */ __name(async (serialNumber, timestamp, reason) => {
+  const client = getAPIClient();
+  await client.post(MF1_PATHS.POINT_OF_SALE_OFFLINE(serialNumber), {
+    timestamp,
+    reason
+  });
+}, "setPointOfSaleOffline");
+var closeJournal = /* @__PURE__ */ __name(async () => {
+  const client = getAPIClient();
+  await client.post(MF1_PATHS.CLOSE_JOURNAL);
+}, "closeJournal");
+var createReceipt = /* @__PURE__ */ __name(async (data) => {
+  const client = getAPIClient();
+  const response = await client.post(MF1_PATHS.RECEIPTS, data);
+  return response.data;
+}, "createReceipt");
+var getReceipts = /* @__PURE__ */ __name(async (page = 1, size = 30) => {
+  const client = getAPIClient();
+  const response = await client.get(`${MF1_PATHS.RECEIPTS}?page=${page}&size=${size}`);
+  return response.data;
+}, "getReceipts");
+var getReceiptById = /* @__PURE__ */ __name(async (uuid) => {
+  const client = getAPIClient();
+  const response = await client.get(MF1_PATHS.RECEIPT_BY_UUID(uuid));
+  return response.data;
+}, "getReceiptById");
+var getReceiptDetails = /* @__PURE__ */ __name(async (uuid, format = "json") => {
+  const client = getAPIClient();
+  const headers = format === "pdf" ? {
+    Accept: "application/pdf"
+  } : {
+    Accept: "application/json"
+  };
+  const response = await client.get(MF1_PATHS.RECEIPT_DETAILS(uuid), {
+    headers
+  });
+  if (format === "pdf") {
+    return new Blob([
+      response.data
+    ], {
+      type: "application/pdf"
+    });
+  }
+  return response.data;
+}, "getReceiptDetails");
+var voidReceipt = /* @__PURE__ */ __name(async (data) => {
+  const client = getAPIClient();
+  await client.delete(MF1_PATHS.RECEIPTS, {
+    data
+  });
+}, "voidReceipt");
+var voidReceiptWithProof = /* @__PURE__ */ __name(async (data) => {
+  const client = getAPIClient();
+  await client.delete(MF1_PATHS.RECEIPT_VOID_WITH_PROOF, {
+    data
+  });
+}, "voidReceiptWithProof");
+var returnReceiptItems = /* @__PURE__ */ __name(async (data) => {
+  const client = getAPIClient();
+  const response = await client.post(MF1_PATHS.RECEIPT_RETURN, data);
+  return response.data;
+}, "returnReceiptItems");
+var returnReceiptItemsWithProof = /* @__PURE__ */ __name(async (data) => {
+  const client = getAPIClient();
+  const response = await client.post(MF1_PATHS.RECEIPT_RETURN_WITH_PROOF, data);
+  return response.data;
+}, "returnReceiptItemsWithProof");
+var createCashRegister = /* @__PURE__ */ __name(async (data) => {
+  const client = getAPIClient();
+  const response = await client.post(MF1_PATHS.CASH_REGISTER, data);
+  return response.data;
+}, "createCashRegister");
+var getCashRegisters = /* @__PURE__ */ __name(async (page = 1, size = 30) => {
+  const client = getAPIClient();
+  const response = await client.get(`${MF1_PATHS.CASH_REGISTER}?page=${page}&size=${size}`);
+  return response.data;
+}, "getCashRegisters");
+var getCashRegisterById = /* @__PURE__ */ __name(async (id) => {
+  const client = getAPIClient();
+  const response = await client.get(MF1_PATHS.CASH_REGISTER_BY_ID(id));
+  return response.data;
+}, "getCashRegisterById");
+var getMTLSCertificate = /* @__PURE__ */ __name(async (id) => {
+  const client = getAPIClient();
+  const response = await client.get(MF1_PATHS.CASH_REGISTER_MTLS_CERT(id));
+  return response.data;
+}, "getMTLSCertificate");
+
+// src/api/mf2.ts
+var createMerchant = /* @__PURE__ */ __name(async (data) => {
+  const client = getAPIClient();
+  const response = await client.post(MF2_PATHS.MERCHANTS, data);
+  return response.data;
+}, "createMerchant");
+var getMerchants = /* @__PURE__ */ __name(async (page = 1) => {
+  const client = getAPIClient();
+  const response = await client.get(`${MF2_PATHS.MERCHANTS}?page=${page}`);
+  return response.data;
+}, "getMerchants");
+var getMerchantById = /* @__PURE__ */ __name(async (uuid) => {
+  const client = getAPIClient();
+  const response = await client.get(MF2_PATHS.MERCHANT_BY_UUID(uuid));
+  return response.data;
+}, "getMerchantById");
+var updateMerchant = /* @__PURE__ */ __name(async (uuid, data) => {
+  const client = getAPIClient();
+  const response = await client.put(MF2_PATHS.MERCHANT_BY_UUID(uuid), data);
+  return response.data;
+}, "updateMerchant");
+var useAuth = /* @__PURE__ */ __name(() => {
+  const [state, setState] = useState({
+    isAuthenticated: false,
+    isLoading: true,
+    user: null,
+    token: null
+  });
+  const [error, setError] = useState(null);
+  const clearError = useCallback(() => {
+    setError(null);
+  }, []);
+  const checkAuthStatus = useCallback(async () => {
+    try {
+      setState((prev) => ({
+        ...prev,
+        isLoading: true
+      }));
+      const authenticated = await isAuthenticated();
+      if (authenticated) {
+        const user = await getCurrentUser();
+        setState((prev) => ({
+          ...prev,
+          isAuthenticated: true,
+          user,
+          isLoading: false
+        }));
+      } else {
+        setState((prev) => ({
+          ...prev,
+          isAuthenticated: false,
+          user: null,
+          token: null,
+          isLoading: false
+        }));
+      }
+    } catch (err) {
+      console.error("Error checking auth status:", err);
+      setState((prev) => ({
+        ...prev,
+        isAuthenticated: false,
+        user: null,
+        token: null,
+        isLoading: false
+      }));
+    }
+  }, []);
+  const loginAsProvider = useCallback(async (email, password) => {
+    try {
+      setError(null);
+      setState((prev) => ({
+        ...prev,
+        isLoading: true
+      }));
+      const tokenData = await loginProvider(email, password);
+      const user = await getCurrentUser();
+      setState((prev) => ({
+        ...prev,
+        isAuthenticated: true,
+        user,
+        token: tokenData.access_token,
+        isLoading: false
+      }));
+    } catch (err) {
+      const errorMessage = err instanceof AuthenticationError ? err.message : "Login failed. Please try again.";
+      setError(errorMessage);
+      setState((prev) => ({
+        ...prev,
+        isAuthenticated: false,
+        user: null,
+        token: null,
+        isLoading: false
+      }));
+      throw err;
+    }
+  }, []);
+  const loginAsMerchant = useCallback(async (email, password) => {
+    try {
+      setError(null);
+      setState((prev) => ({
+        ...prev,
+        isLoading: true
+      }));
+      const tokenData = await loginMerchant(email, password);
+      const user = await getCurrentUser();
+      setState((prev) => ({
+        ...prev,
+        isAuthenticated: true,
+        user,
+        token: tokenData.access_token,
+        isLoading: false
+      }));
+    } catch (err) {
+      const errorMessage = err instanceof AuthenticationError ? err.message : "Login failed. Please try again.";
+      setError(errorMessage);
+      setState((prev) => ({
+        ...prev,
+        isAuthenticated: false,
+        user: null,
+        token: null,
+        isLoading: false
+      }));
+      throw err;
+    }
+  }, []);
+  const loginAsCashier = useCallback(async (email, password) => {
+    try {
+      setError(null);
+      setState((prev) => ({
+        ...prev,
+        isLoading: true
+      }));
+      const tokenData = await loginCashier(email, password);
+      const user = await getCurrentUser();
+      setState((prev) => ({
+        ...prev,
+        isAuthenticated: true,
+        user,
+        token: tokenData.access_token,
+        isLoading: false
+      }));
+    } catch (err) {
+      const errorMessage = err instanceof AuthenticationError ? err.message : "Login failed. Please try again.";
+      setError(errorMessage);
+      setState((prev) => ({
+        ...prev,
+        isAuthenticated: false,
+        user: null,
+        token: null,
+        isLoading: false
+      }));
+      throw err;
+    }
+  }, []);
+  const handleLogout = useCallback(async () => {
+    try {
+      setState((prev) => ({
+        ...prev,
+        isLoading: true
+      }));
+      await logout();
+      setState({
+        isAuthenticated: false,
+        user: null,
+        token: null,
+        isLoading: false
+      });
+      setError(null);
+    } catch (err) {
+      console.error("Logout error:", err);
+      setState({
+        isAuthenticated: false,
+        user: null,
+        token: null,
+        isLoading: false
+      });
+    }
+  }, []);
+  useEffect(() => {
+    void checkAuthStatus();
+  }, [
+    checkAuthStatus
+  ]);
+  return {
+    // State
+    isAuthenticated: state.isAuthenticated,
+    isLoading: state.isLoading,
+    user: state.user,
+    token: state.token,
+    error,
+    // Actions
+    loginAsProvider,
+    loginAsMerchant,
+    loginAsCashier,
+    logout: handleLogout,
+    checkAuthStatus,
+    clearError
+  };
+}, "useAuth");
+var useRetryQueue = /* @__PURE__ */ __name(() => {
+  const [stats, setStats] = useState({
+    total: 0,
+    byPriority: {
+      high: 0,
+      medium: 0,
+      low: 0
+    }
+  });
+  const [isProcessing, setIsProcessing] = useState(false);
+  const [networkConnected, setNetworkConnected] = useState(isConnected());
+  const refreshStats = useCallback(async () => {
+    try {
+      const queueStats = await RequestQueue.getQueueStats();
+      setStats(queueStats);
+    } catch (error) {
+      networkLogger.error("Failed to refresh queue stats", error);
+    }
+  }, []);
+  const processQueue = useCallback(async () => {
+    if (isProcessing || !networkConnected) {
+      return;
+    }
+    try {
+      setIsProcessing(true);
+      networkLogger.info("Starting manual queue processing");
+      const client = getAPIClient();
+      await client.processOfflineQueue();
+      await refreshStats();
+      networkLogger.info("Manual queue processing completed");
+    } catch (error) {
+      networkLogger.error("Manual queue processing failed", error);
+    } finally {
+      setIsProcessing(false);
+    }
+  }, [
+    isProcessing,
+    networkConnected,
+    refreshStats
+  ]);
+  const clearQueue = useCallback(async () => {
+    try {
+      networkLogger.info("Clearing retry queue");
+      await RequestQueue.clearQueue();
+      await refreshStats();
+      networkLogger.info("Retry queue cleared");
+    } catch (error) {
+      networkLogger.error("Failed to clear retry queue", error);
+    }
+  }, [
+    refreshStats
+  ]);
+  useEffect(() => {
+    let processingTimeout;
+    const handleNetworkChange = /* @__PURE__ */ __name((state) => {
+      setNetworkConnected(state.isConnected);
+      if (state.isConnected && !isProcessing) {
+        processingTimeout = setTimeout(() => {
+          void (async () => {
+            try {
+              networkLogger.info("Network reconnected, auto-processing queue");
+              await processQueue();
+            } catch (error) {
+              networkLogger.error("Auto queue processing failed", error);
+            }
+          })();
+        }, 2e3);
+      }
+    }, "handleNetworkChange");
+    const unsubscribe = addNetworkListener(handleNetworkChange);
+    return () => {
+      unsubscribe();
+      if (processingTimeout) {
+        clearTimeout(processingTimeout);
+      }
+    };
+  }, [
+    processQueue,
+    isProcessing
+  ]);
+  useEffect(() => {
+    void refreshStats();
+    const interval = setInterval(() => {
+      void refreshStats();
+    }, 3e4);
+    return () => clearInterval(interval);
+  }, [
+    refreshStats
+  ]);
+  useEffect(() => {
+    const interval = setInterval(() => {
+      if (!isProcessing) {
+        void refreshStats();
+      }
+    }, 1e4);
+    return () => clearInterval(interval);
+  }, [
+    isProcessing,
+    refreshStats
+  ]);
+  return {
+    stats,
+    isProcessing,
+    isConnected: networkConnected,
+    processQueue,
+    clearQueue,
+    refreshStats
+  };
+}, "useRetryQueue");
+var TOTAL_STEPS = 3;
+var useProviderFlow = /* @__PURE__ */ __name(() => {
+  const [state, setState] = useState({
+    isLoading: false,
+    currentStep: 1,
+    merchantData: {},
+    createdMerchant: null
+  });
+  const [error, setError] = useState(null);
+  const setMerchantData = useCallback((data) => {
+    setState((prev) => ({
+      ...prev,
+      merchantData: {
+        ...prev.merchantData,
+        ...data
+      }
+    }));
+  }, []);
+  const validateCurrentStep = useCallback(() => {
+    const { merchantData, currentStep } = state;
+    switch (currentStep) {
+      case 1: {
+        const emailValidation = validateEmail(merchantData.email ?? "");
+        const fiscalIdValidation = validateFiscalId(merchantData.fiscal_id ?? "");
+        return {
+          isValid: emailValidation.isValid && fiscalIdValidation.isValid,
+          errors: [
+            ...emailValidation.errors,
+            ...fiscalIdValidation.errors
+          ]
+        };
+      }
+      case 2:
+        if (!merchantData.name || merchantData.name.trim() === "") {
+          return {
+            isValid: false,
+            errors: [
+              {
+                field: "name",
+                message: "Business name is required",
+                code: "NAME_REQUIRED"
+              }
+            ]
+          };
+        }
+        return {
+          isValid: true,
+          errors: []
+        };
+      case 3:
+        if (merchantData.address) {
+          return validateAddress(merchantData.address);
+        }
+        return {
+          isValid: true,
+          errors: []
+        };
+      // Address is optional
+      default:
+        return {
+          isValid: true,
+          errors: []
+        };
+    }
+  }, [
+    state
+  ]);
+  const createMerchantFlow = useCallback(async (data) => {
+    try {
+      setError(null);
+      setState((prev) => ({
+        ...prev,
+        isLoading: true
+      }));
+      const merchant = await createMerchant(data);
+      setState((prev) => ({
+        ...prev,
+        createdMerchant: merchant,
+        isLoading: false
+      }));
+      return merchant;
+    } catch (err) {
+      const errorMessage = err.response?.data?.detail || "Failed to create merchant";
+      setError(errorMessage);
+      setState((prev) => ({
+        ...prev,
+        isLoading: false
+      }));
+      throw err;
+    }
+  }, []);
+  const nextStep = useCallback(() => {
+    setState((prev) => ({
+      ...prev,
+      currentStep: Math.min(prev.currentStep + 1, TOTAL_STEPS)
+    }));
+  }, []);
+  const previousStep = useCallback(() => {
+    setState((prev) => ({
+      ...prev,
+      currentStep: Math.max(prev.currentStep - 1, 1)
+    }));
+  }, []);
+  const resetFlow = useCallback(() => {
+    setState({
+      isLoading: false,
+      currentStep: 1,
+      merchantData: {},
+      createdMerchant: null
+    });
+    setError(null);
+  }, []);
+  const clearError = useCallback(() => {
+    setError(null);
+  }, []);
+  return {
+    ...state,
+    error,
+    setMerchantData,
+    validateCurrentStep,
+    createMerchantFlow,
+    nextStep,
+    previousStep,
+    resetFlow,
+    clearError
+  };
+}, "useProviderFlow");
+var Button = /* @__PURE__ */ __name(({ title, onPress, variant = "primary", size = "medium", disabled = false, loading = false, fullWidth = false, style, textStyle, testID }) => {
+  const isDisabled = disabled || loading;
+  const buttonStyle = [
+    styles.base,
+    styles[variant],
+    styles[size],
+    fullWidth && styles.fullWidth,
+    isDisabled && styles.disabled,
+    style
+  ].filter(Boolean);
+  const textColor = [
+    styles.baseText,
+    styles[`${variant}Text`],
+    styles[`${size}Text`],
+    isDisabled && styles.disabledText,
+    textStyle
+  ].filter(Boolean);
+  return /* @__PURE__ */ React2.createElement(TouchableOpacity, {
+    style: buttonStyle,
+    onPress,
+    disabled: isDisabled,
+    testID,
+    accessibilityRole: "button",
+    accessibilityState: {
+      disabled: isDisabled
+    },
+    accessibilityLabel: title
+  }, /* @__PURE__ */ React2.createElement(View, {
+    style: styles.content
+  }, loading && /* @__PURE__ */ React2.createElement(ActivityIndicator, {
+    size: "small",
+    color: variant === "outline" ? "#007AFF" : "#FFFFFF",
+    style: styles.loader
+  }), /* @__PURE__ */ React2.createElement(Text, {
+    style: textColor
+  }, title)));
+}, "Button");
+var styles = StyleSheet.create({
+  base: {
+    borderRadius: 8,
+    justifyContent: "center",
+    alignItems: "center",
+    borderWidth: 1,
+    borderColor: "transparent"
+  },
+  content: {
+    flexDirection: "row",
+    alignItems: "center",
+    justifyContent: "center"
+  },
+  loader: {
+    marginRight: 8
+  },
+  // Variants
+  primary: {
+    backgroundColor: "#007AFF",
+    borderColor: "#007AFF"
+  },
+  secondary: {
+    backgroundColor: "#6C757D",
+    borderColor: "#6C757D"
+  },
+  outline: {
+    backgroundColor: "transparent",
+    borderColor: "#007AFF",
+    borderWidth: 1
+  },
+  danger: {
+    backgroundColor: "#DC3545",
+    borderColor: "#DC3545"
+  },
+  // Sizes
+  small: {
+    paddingHorizontal: 12,
+    paddingVertical: 6,
+    minHeight: 32
+  },
+  medium: {
+    paddingHorizontal: 16,
+    paddingVertical: 10,
+    minHeight: 44
+  },
+  large: {
+    paddingHorizontal: 24,
+    paddingVertical: 14,
+    minHeight: 52
+  },
+  // States
+  disabled: {
+    opacity: 0.5
+  },
+  fullWidth: {
+    width: "100%"
+  },
+  // Text styles
+  baseText: {
+    fontWeight: "600",
+    textAlign: "center"
+  },
+  primaryText: {
+    color: "#FFFFFF"
+  },
+  secondaryText: {
+    color: "#FFFFFF"
+  },
+  outlineText: {
+    color: "#007AFF"
+  },
+  dangerText: {
+    color: "#FFFFFF"
+  },
+  smallText: {
+    fontSize: 14
+  },
+  mediumText: {
+    fontSize: 16
+  },
+  largeText: {
+    fontSize: 18
+  },
+  disabledText: {
+    opacity: 0.7
+  }
+});
+var FormInput = /* @__PURE__ */ forwardRef(({ label, error, helperText, required = false, containerStyle, labelStyle, inputStyle, errorStyle, helperStyle, leftIcon, rightIcon, showPasswordToggle = false, secureTextEntry, ...textInputProps }, ref) => {
+  const [isPasswordVisible, setIsPasswordVisible] = useState(false);
+  const [isFocused, setIsFocused] = useState(false);
+  const isPassword = secureTextEntry ?? showPasswordToggle;
+  const actualSecureTextEntry = isPassword ? !isPasswordVisible : false;
+  const handleTogglePassword = /* @__PURE__ */ __name(() => {
+    setIsPasswordVisible(!isPasswordVisible);
+  }, "handleTogglePassword");
+  const inputContainerStyle = [
+    styles2.inputContainer,
+    isFocused && styles2.inputContainerFocused,
+    error && styles2.inputContainerError
+  ].filter(Boolean);
+  const textInputStyle = [
+    styles2.input,
+    leftIcon && styles2.inputWithLeftIcon,
+    (rightIcon ?? showPasswordToggle) && styles2.inputWithRightIcon,
+    inputStyle
+  ].filter(Boolean);
+  return /* @__PURE__ */ React2.createElement(View, {
+    style: [
+      styles2.container,
+      containerStyle
+    ]
+  }, label && /* @__PURE__ */ React2.createElement(View, {
+    style: styles2.labelContainer
+  }, /* @__PURE__ */ React2.createElement(Text, {
+    style: [
+      styles2.label,
+      labelStyle
+    ]
+  }, label, required && /* @__PURE__ */ React2.createElement(Text, {
+    style: styles2.required
+  }, " *"))), /* @__PURE__ */ React2.createElement(View, {
+    style: inputContainerStyle
+  }, leftIcon && /* @__PURE__ */ React2.createElement(View, {
+    style: styles2.leftIconContainer
+  }, leftIcon), /* @__PURE__ */ React2.createElement(TextInput, {
+    ref,
+    style: textInputStyle,
+    secureTextEntry: actualSecureTextEntry,
+    onFocus: /* @__PURE__ */ __name(() => setIsFocused(true), "onFocus"),
+    onBlur: /* @__PURE__ */ __name(() => setIsFocused(false), "onBlur"),
+    placeholderTextColor: "#999999",
+    ...textInputProps
+  }), (rightIcon ?? showPasswordToggle) && /* @__PURE__ */ React2.createElement(View, {
+    style: styles2.rightIconContainer
+  }, showPasswordToggle ? /* @__PURE__ */ React2.createElement(TouchableOpacity, {
+    onPress: handleTogglePassword,
+    style: styles2.passwordToggle,
+    accessibilityRole: "button",
+    accessibilityLabel: isPasswordVisible ? "Hide password" : "Show password"
+  }, /* @__PURE__ */ React2.createElement(Text, {
+    style: styles2.passwordToggleText
+  }, isPasswordVisible ? "\u{1F648}" : "\u{1F441}\uFE0F")) : rightIcon)), error && /* @__PURE__ */ React2.createElement(Text, {
+    style: [
+      styles2.errorText,
+      errorStyle
+    ]
+  }, error), helperText && !error && /* @__PURE__ */ React2.createElement(Text, {
+    style: [
+      styles2.helperText,
+      helperStyle
+    ]
+  }, helperText));
+});
+FormInput.displayName = "FormInput";
+var styles2 = StyleSheet.create({
+  container: {
+    marginBottom: 16
+  },
+  labelContainer: {
+    marginBottom: 6
+  },
+  label: {
+    fontSize: 16,
+    fontWeight: "500",
+    color: "#333333"
+  },
+  required: {
+    color: "#DC3545"
+  },
+  inputContainer: {
+    flexDirection: "row",
+    alignItems: "center",
+    borderWidth: 1,
+    borderColor: "#CCCCCC",
+    borderRadius: 8,
+    backgroundColor: "#FFFFFF",
+    minHeight: 44
+  },
+  inputContainerFocused: {
+    borderColor: "#007AFF",
+    shadowColor: "#007AFF",
+    shadowOffset: {
+      width: 0,
+      height: 0
+    },
+    shadowOpacity: 0.2,
+    shadowRadius: 4,
+    elevation: 2
+  },
+  inputContainerError: {
+    borderColor: "#DC3545"
+  },
+  input: {
+    flex: 1,
+    fontSize: 16,
+    color: "#333333",
+    paddingHorizontal: 12,
+    paddingVertical: 10
+  },
+  inputWithLeftIcon: {
+    paddingLeft: 8
+  },
+  inputWithRightIcon: {
+    paddingRight: 8
+  },
+  leftIconContainer: {
+    paddingLeft: 12,
+    justifyContent: "center",
+    alignItems: "center"
+  },
+  rightIconContainer: {
+    paddingRight: 12,
+    justifyContent: "center",
+    alignItems: "center"
+  },
+  passwordToggle: {
+    padding: 4
+  },
+  passwordToggleText: {
+    fontSize: 16
+  },
+  errorText: {
+    fontSize: 14,
+    color: "#DC3545",
+    marginTop: 4
+  },
+  helperText: {
+    fontSize: 14,
+    color: "#666666",
+    marginTop: 4
+  }
+});
+
+// src/storage/certificate.ts
+var _CertificateStorage = class _CertificateStorage {
+  /**
+  * Store mTLS certificate securely
+  */
+  static async storeMTLSCertificate(uuid, certificate, privateKey) {
+    const certData = {
+      uuid,
+      certificate,
+      privateKey,
+      createdAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    const certKey = getMTLSCertificateKey(uuid);
+    await SecureTokenStorage.setItem(certKey, JSON.stringify(certData));
+  }
+  /**
+  * Retrieve mTLS certificate
+  */
+  static async getMTLSCertificate(uuid) {
+    try {
+      const certKey = getMTLSCertificateKey(uuid);
+      const certDataStr = await SecureTokenStorage.getItem(certKey);
+      if (!certDataStr) {
+        return null;
+      }
+      return JSON.parse(certDataStr);
+    } catch (error) {
+      console.warn(`Failed to retrieve certificate for ${uuid}:`, error);
+      return null;
+    }
+  }
+  /**
+  * Remove mTLS certificate
+  */
+  static async removeMTLSCertificate(uuid) {
+    const certKey = getMTLSCertificateKey(uuid);
+    const privateKeyKey = getMTLSPrivateKeyKey(uuid);
+    await Promise.all([
+      SecureTokenStorage.removeItem(certKey),
+      SecureTokenStorage.removeItem(privateKeyKey)
+    ]);
+  }
+  /**
+  * List all stored certificates
+  */
+  static async listCertificates() {
+    try {
+      const certificates = [];
+      await new Promise((resolve) => setTimeout(resolve, 1e3));
+      return certificates;
+    } catch (error) {
+      console.warn("Failed to list certificates:", error);
+      return [];
+    }
+  }
+  /**
+  * Check if certificate exists
+  */
+  static async hasCertificate(uuid) {
+    const certificate = await this.getMTLSCertificate(uuid);
+    return certificate !== null;
+  }
+  /**
+  * Validate certificate (basic checks)
+  */
+  static async validateCertificate(uuid) {
+    const certificate = await this.getMTLSCertificate(uuid);
+    if (!certificate) {
+      return false;
+    }
+    if (!certificate.certificate || certificate.certificate.trim() === "") {
+      return false;
+    }
+    if (certificate.expiresAt) {
+      const expiryDate = new Date(certificate.expiresAt);
+      if (expiryDate < /* @__PURE__ */ new Date()) {
+        return false;
+      }
+    }
+    return true;
+  }
+  /**
+  * Parse certificate information (basic implementation)
+  */
+  static parseCertificateInfo(certificatePEM) {
+    try {
+      const cert = certificatePEM.replace(/-----BEGIN CERTIFICATE-----/, "").replace(/-----END CERTIFICATE-----/, "").replace(/\s/g, "");
+      return {
+        fingerprint: cert.substring(0, 40)
+      };
+    } catch (error) {
+      console.warn("Failed to parse certificate:", error);
+      return {};
+    }
+  }
+  /**
+  * Clear all certificates
+  */
+  static async clearAllCertificates() {
+    const certificates = await this.listCertificates();
+    await Promise.all(certificates.map((cert) => this.removeMTLSCertificate(cert.uuid)));
+  }
+};
+__name(_CertificateStorage, "CertificateStorage");
+var CertificateStorage = _CertificateStorage;
+
+// src/constants/roles.ts
+var UserRole = /* @__PURE__ */ function(UserRole2) {
+  UserRole2["PROVIDER"] = "provider";
+  UserRole2["MERCHANT"] = "merchant";
+  UserRole2["CASHIER"] = "cashier";
+  return UserRole2;
+}({});
+var ROLE_PERMISSIONS = {
+  ["provider"]: [
+    "create_merchant",
+    "manage_merchants",
+    "view_all_data"
+  ],
+  ["merchant"]: [
+    "create_cashier",
+    "manage_pos",
+    "create_cash_register",
+    "view_receipts",
+    "manage_business_data"
+  ],
+  ["cashier"]: [
+    "create_receipt",
+    "void_receipt",
+    "return_items",
+    "view_own_receipts"
+  ]
+};
+var hasPermission = /* @__PURE__ */ __name((userRole, permission) => {
+  const permissions = ROLE_PERMISSIONS[userRole];
+  return permissions.includes(permission);
+}, "hasPermission");
+var isProvider = /* @__PURE__ */ __name((role) => role === "provider", "isProvider");
+var isMerchant = /* @__PURE__ */ __name((role) => role === "merchant", "isMerchant");
+var isCashier = /* @__PURE__ */ __name((role) => role === "cashier", "isCashier");
+
+// src/index.ts
+var SDK_VERSION = "1.0.0";
+var SDK_NAME = "a-cube-io/ereceipts-js-sdk";
+var initSDK = /* @__PURE__ */ __name(async (config) => {
+  const { initializeAPIClient: initializeAPIClient2 } = await import('./client-Z2LXQJMF.js');
+  return initializeAPIClient2(config);
+}, "initSDK");
+var quickLoginProvider = /* @__PURE__ */ __name(async (email, password) => {
+  try {
+    const { loginProvider: loginProvider2 } = await import('./auth-RZRIC4PK.js');
+    const token = await loginProvider2(email, password);
+    return {
+      success: true,
+      token
+    };
+  } catch (error) {
+    return {
+      success: false,
+      error
+    };
+  }
+}, "quickLoginProvider");
+var quickLoginMerchant = /* @__PURE__ */ __name(async (email, password) => {
+  try {
+    const { loginMerchant: loginMerchant2 } = await import('./auth-RZRIC4PK.js');
+    const token = await loginMerchant2(email, password);
+    return {
+      success: true,
+      token
+    };
+  } catch (error) {
+    return {
+      success: false,
+      error
+    };
+  }
+}, "quickLoginMerchant");
+var isSDKReady = /* @__PURE__ */ __name(async () => {
+  try {
+    const { getAPIClient: getAPIClient2 } = await import('./client-Z2LXQJMF.js');
+    const client = getAPIClient2();
+    return client !== null;
+  } catch {
+    return false;
+  }
+}, "isSDKReady");
+{
+  if (typeof globalThis !== "undefined") {
+    globalThis.__ACUBE_SDK__ = {
+      getAPIClient: /* @__PURE__ */ __name(async () => {
+        const { getAPIClient: getAPIClient2 } = await import('./client-Z2LXQJMF.js');
+        return getAPIClient2();
+      }, "getAPIClient"),
+      version: SDK_VERSION,
+      clearAllData: /* @__PURE__ */ __name(async () => {
+        const { SecureTokenStorage: SecureTokenStorage2 } = await import('./token-4OAGWTVG.js');
+        const { RequestQueue: RequestQueue2 } = await import('./queue-D7PJ536B.js');
+        await SecureTokenStorage2.clearAll();
+        await RequestQueue2.clearQueue();
+      }, "clearAllData")
+    };
+  }
+}
+
+export { Button, CertificateStorage, FormInput, ROLE_PERMISSIONS, SDK_NAME, SDK_VERSION, UserRole, activatePointOfSale, closeJournal, createCashRegister, createCashier, createInactivityPeriod, createMerchant, createReceipt, deleteCashier, getCashRegisterById, getCashRegisters, getCashierById, getCashiers, getCurrentCashier, getMTLSCertificate, getMerchantById, getMerchants, getPointOfSaleBySerial, getPointOfSales, getReceiptById, getReceiptDetails, getReceipts, hasPermission, initSDK, isCashier, isMerchant, isProvider, isSDKReady, quickLoginMerchant, quickLoginProvider, returnReceiptItems, returnReceiptItemsWithProof, setPointOfSaleOffline, updateMerchant, useAuth, useProviderFlow, useRetryQueue, voidReceipt, voidReceiptWithProof };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map