@passgage/sdk-react-native 1.0.4 → 1.0.6

package/dist/index.js

@@ -1,75 +1,91 @@
-"use strict";
-var __create = Object.create;
+'use strict';
+
+var axios = require('axios');
+var React = require('react');
+var zustand = require('zustand');
+var Keychain = require('react-native-keychain');
+var Geolocation2 = require('react-native-geolocation-service');
+var RNPermissions = require('react-native-permissions');
+var reactNative = require('react-native');
+var NfcManager = require('react-native-nfc-manager');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var axios__default = /*#__PURE__*/_interopDefault(axios);
+var React__default = /*#__PURE__*/_interopDefault(React);
+var Keychain__namespace = /*#__PURE__*/_interopNamespace(Keychain);
+var Geolocation2__default = /*#__PURE__*/_interopDefault(Geolocation2);
+var RNPermissions__default = /*#__PURE__*/_interopDefault(RNPermissions);
+var NfcManager__default = /*#__PURE__*/_interopDefault(NfcManager);
+
 var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
 };
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
+var httpClient = axios__default.default.create();
+var createHttpClient = ({
+  baseURL,
+  apiVersion,
+  timeout = 3e3
+}) => {
+  httpClient = axios__default.default.create({
+    baseURL: `${baseURL}/api/${apiVersion}`,
+    timeout,
+    headers: {
+      "Content-Type": "application/json",
+      Accept: "application/json"
+    }
+  });
+  httpClient.interceptors.request.use(
+    (config) => {
+      return config;
+    },
+    (error) => {
+      return Promise.reject(error);
+    }
+  );
+  httpClient.interceptors.response.use(
+    (response) => {
+      const originalRequest = response.config;
+      if (response.status === 401 && originalRequest) {
+        return new Promise(async (resolve, _reject) => {
+        });
+      }
+      return response.data;
+    },
+    (err) => {
+      return Promise.reject(err);
+    }
+  );
+};
+var setTokenToHttpClient = (token) => {
+  httpClient.defaults.headers["Authorization"] = token ? `Bearer ${token}` : "";
 };
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/index.ts
-var index_exports = {};
-__export(index_exports, {
-  ApiClient: () => ApiClient,
-  AuthService: () => AuthService,
-  CheckInService: () => CheckInService,
-  DeviceAccessService: () => DeviceAccessService,
-  DeviceDirection: () => DeviceDirection,
-  DeviceUsage: () => DeviceUsage,
-  Endpoints: () => endpoints_exports,
-  EntranceType: () => EntranceType,
-  LocationService: () => LocationService,
-  NFCAccessService: () => NFCAccessService,
-  PassgageAccessProvider: () => PassgageAccessProvider,
-  QRAccessService: () => QRAccessService,
-  RemoteWorkService: () => RemoteWorkService,
-  SDK_VERSION: () => SDK_VERSION,
-  calculateDistance: () => calculateDistance,
-  checkOnLocation: () => checkOnLocation,
-  checkRepetitiveRead: () => checkRepetitiveRead,
-  clearReadRecords: () => clearReadRecords,
-  createApiClient: () => createApiClient,
-  formatDate: () => formatDate,
-  formatDateTime: () => formatDateTime,
-  formatISO: () => formatISO,
-  formatTime: () => formatTime,
-  parseISO: () => parseISO,
-  useLocation: () => useLocation,
-  usePassgageAccess: () => usePassgageAccess,
-  usePassgageAuth: () => usePassgageAuth,
-  usePassgageCheckIn: () => usePassgageCheckIn,
-  usePassgageNFCScanner: () => usePassgageNFCScanner,
-  usePassgageQRScanner: () => usePassgageQRScanner,
-  usePassgageRemoteWork: () => usePassgageRemoteWork,
-  validateCoordinates: () => validateCoordinates,
-  validateDeviceId: () => validateDeviceId,
-  validateNFCCode: () => validateNFCCode,
-  validateQRCode: () => validateQRCode
-});
-module.exports = __toCommonJS(index_exports);
-
-// src/api/client.ts
-var import_axios = __toESM(require("axios"));
 var ApiClient = class {
   constructor(config) {
     this.isRefreshing = false;
@@ -79,7 +95,7 @@ var ApiClient = class {
       apiVersion: "v2",
       ...config
     };
-    this.axiosInstance = import_axios.default.create({
+    this.axiosInstance = axios__default.default.create({
       baseURL: `${this.config.baseURL}/api/${this.config.apiVersion}`,
       timeout: this.config.timeout,
       headers: {
@@ -230,32 +246,24 @@ var ApiClient = class {
    * Generic PUT request
    */
   async put(options) {
-    const response = await this.axiosInstance.put(
-      options.endpoint,
-      options.data,
-      {
-        params: options.params,
-        headers: options.headers,
-        ...options.config,
-        skipAuth: options.skipAuth
-      }
-    );
+    const response = await this.axiosInstance.put(options.endpoint, options.data, {
+      params: options.params,
+      headers: options.headers,
+      ...options.config,
+      skipAuth: options.skipAuth
+    });
     return response.data;
   }
   /**
    * Generic PATCH request
    */
   async patch(options) {
-    const response = await this.axiosInstance.patch(
-      options.endpoint,
-      options.data,
-      {
-        params: options.params,
-        headers: options.headers,
-        ...options.config,
-        skipAuth: options.skipAuth
-      }
-    );
+    const response = await this.axiosInstance.patch(options.endpoint, options.data, {
+      params: options.params,
+      headers: options.headers,
+      ...options.config,
+      skipAuth: options.skipAuth
+    });
     return response.data;
   }
   /**
@@ -278,6 +286,7 @@ function createApiClient(config) {
 // src/api/endpoints.ts
 var endpoints_exports = {};
 __export(endpoints_exports, {
+  EP_AZURE_AUTH: () => EP_AZURE_AUTH,
   EP_BRANCHES: () => EP_BRANCHES,
   EP_CREATE_QR: () => EP_CREATE_QR,
   EP_DEVICES: () => EP_DEVICES,
@@ -295,6 +304,7 @@ __export(endpoints_exports, {
 });
 var EP_LOGIN = "users/sign_in";
 var EP_TOKEN = "token";
+var EP_AZURE_AUTH = "auth/azure";
 var EP_DEVICES = "devices";
 var EP_QR_DEVICES = "devices/qr_devices";
 var EP_QR_ACCESS = "qr_access/accessible_qrs";
@@ -328,17 +338,7 @@ var DeviceDirection = /* @__PURE__ */ ((DeviceDirection2) => {
 })(DeviceDirection || {});
 
 // src/services/AuthService.ts
-var AuthService = class {
-  constructor(apiClient) {
-    this.apiClient = apiClient;
-  }
-  /**
-   * Set token storage implementation
-   * This is used by platform-specific implementations (React Native, Android, iOS)
-   */
-  setTokenStorage(storage) {
-    this.tokenStorage = storage;
-  }
+var AuthService = {
   /**
    * Login with credentials
    *
@@ -359,7 +359,7 @@ var AuthService = class {
    * }
    * ```
    */
-  async login(credentials) {
+  login: async (credentials) => {
     try {
       const requestBody = {
         user: {
@@ -367,12 +367,7 @@ var AuthService = class {
           password: credentials.password
         }
       };
-      const response = await this.apiClient.post({
-        endpoint: "/api/v2/users/sign_in",
-        data: requestBody,
-        skipAuth: true
-        // Don't send auth header for login
-      });
+      const response = await httpClient.post(EP_LOGIN, requestBody);
       if (!response.success || !response.data?.tokens) {
         return {
           success: false,
@@ -381,18 +376,12 @@ var AuthService = class {
         };
       }
       const tokens = response.data.tokens;
-      if (this.tokenStorage) {
-        await this.tokenStorage.saveTokens(tokens);
-      }
-      this.apiClient.setToken(tokens.access.token);
+      setTokenToHttpClient(tokens.access.token);
       let user;
       try {
-        const userResult = await this.getCurrentUser();
+        const userResult = await AuthService.getCurrentUser();
         if (userResult.success) {
           user = userResult.user;
-          if (this.tokenStorage) {
-            await this.tokenStorage.saveUser(user);
-          }
         }
       } catch (error) {
         console.warn("Failed to fetch user info after login:", error);
@@ -409,7 +398,68 @@ var AuthService = class {
         code: error.code || "NETWORK_ERROR"
       };
     }
-  }
+  },
+  /**
+   * Login with Azure AD token
+   *
+   * @param credentials - Azure AD login credentials (id_token and optional device_type)
+   * @returns Login result with tokens on success
+   *
+   * @example
+   * ```typescript
+   * const result = await authService.loginWithAzure({
+   *   id_token: 'azure_id_token_here',
+   *   device_type: 'ios'
+   * });
+   *
+   * if (result.success) {
+   *   console.log('Access token:', result.tokens.access.token);
+   * } else {
+   *   console.error('Azure login failed:', result.error);
+   * }
+   * ```
+   */
+  loginWithAzure: async (credentials) => {
+    try {
+      const response = await httpClient.post(
+        EP_AZURE_AUTH,
+        {
+          id_token: credentials.id_token,
+          device_type: credentials.device_type || "android"
+        },
+        { skipAuth: true }
+      );
+      if (!response.success || !response.data?.tokens) {
+        return {
+          success: false,
+          error: response.message || "Azure login failed",
+          code: "AZURE_LOGIN_FAILED"
+        };
+      }
+      const tokens = response.data.tokens;
+      setTokenToHttpClient(tokens.access.token);
+      let user;
+      try {
+        const userResult = await AuthService.getCurrentUser();
+        if (userResult.success) {
+          user = userResult.user;
+        }
+      } catch (error) {
+        console.warn("Failed to fetch user info after Azure login:", error);
+      }
+      return {
+        success: true,
+        tokens,
+        user
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error.message || "An error occurred during Azure login",
+        code: error.code || "NETWORK_ERROR"
+      };
+    }
+  },
   /**
    * Refresh access token using refresh token
    *
@@ -425,16 +475,18 @@ var AuthService = class {
    * }
    * ```
    */
-  async refreshToken(refreshToken) {
+  refreshToken: async (refreshToken) => {
     try {
       const requestBody = {
         refresh_token: refreshToken
       };
-      const response = await this.apiClient.post({
-        endpoint: "/token",
-        data: requestBody,
-        skipAuth: true
-      });
+      const response = await httpClient.post(
+        "/token",
+        {
+          data: requestBody
+        },
+        { skipAuth: true }
+      );
       if (!response.success || !response.data?.token || !response.data?.refresh_token) {
         return {
           success: false,
@@ -444,18 +496,14 @@ var AuthService = class {
       }
       const tokens = {
         access: {
-          token: response.data.token,
+          token: response.data.token ?? "",
           expiresIn: "30 days"
         },
         refresh: {
-          token: response.data.refresh_token,
+          token: response.data.refresh_token ?? "",
           expiresIn: "30 days"
         }
       };
-      if (this.tokenStorage) {
-        await this.tokenStorage.saveTokens(tokens);
-      }
-      this.apiClient.setToken(tokens.access.token);
       return {
         success: true,
         tokens
@@ -467,7 +515,7 @@ var AuthService = class {
         code: error.code || "NETWORK_ERROR"
       };
     }
-  }
+  },
   /**
    * Get current user information
    *
@@ -482,12 +530,10 @@ var AuthService = class {
    * }
    * ```
    */
-  async getCurrentUser() {
+  getCurrentUser: async () => {
     try {
-      const response = await this.apiClient.get({
-        endpoint: "/api/v2/users/me"
-      });
-      if (!response.success || !response.data) {
+      const response = await httpClient.get(EP_ME);
+      if (!response || !response.data) {
         return {
           success: false,
           error: response.message || "Failed to fetch user information"
@@ -521,69 +567,40 @@ var AuthService = class {
       };
     }
   }
+};
+
+// src/services/QRAccessService.ts
+var QRAccessService = {
   /**
-   * Logout current user
-   * Clears tokens from storage and API client
-   *
-   * @example
-   * ```typescript
-   * await authService.logout();
-   * console.log('User logged out');
-   * ```
-   */
-  async logout() {
-    if (this.tokenStorage) {
-      await this.tokenStorage.clearTokens();
-      await this.tokenStorage.clearUser();
-    }
-    this.apiClient.setToken(null);
-  }
-  /**
-   * Check if user is authenticated
-   *
-   * @returns True if user has valid tokens
-   */
-  async isAuthenticated() {
-    if (!this.tokenStorage) {
-      return false;
-    }
-    const tokens = await this.tokenStorage.getTokens();
-    return tokens !== null && tokens.access.token.length > 0;
-  }
-  /**
-   * Get stored tokens
-   *
-   * @returns Stored tokens or null
+   * Trigger IoT device
    */
-  async getStoredTokens() {
-    if (!this.tokenStorage) {
-      return null;
-    }
-    return await this.tokenStorage.getTokens();
-  }
+  triggerIoTDevice: async (deviceId, config) => {
+    return httpClient.post(
+      `${EP_TRIGGER_IOT}/${deviceId}`,
+      config
+    );
+  },
   /**
-   * Get stored user
-   *
-   * @returns Stored user or null
+   * Create entrance from QR code
    */
-  async getStoredUser() {
-    if (!this.tokenStorage) {
-      return null;
-    }
-    return await this.tokenStorage.getUser();
+  createEntranceFromQR: (request2) => {
+    return httpClient.post(
+      EP_CREATE_QR,
+      request2
+    );
   }
 };
 
 // src/utils/location.ts
 function calculateDistance(lat1, lon1, lat2, lon2) {
-  const R = 6371e3;
-  const \u03C61 = lat1 * Math.PI / 180;
-  const \u03C62 = lat2 * Math.PI / 180;
-  const \u0394\u03C6 = (lat2 - lat1) * Math.PI / 180;
-  const \u0394\u03BB = (lon2 - lon1) * Math.PI / 180;
-  const a = Math.sin(\u0394\u03C6 / 2) * Math.sin(\u0394\u03C6 / 2) + Math.cos(\u03C61) * Math.cos(\u03C62) * Math.sin(\u0394\u03BB / 2) * Math.sin(\u0394\u03BB / 2);
+  let earthRadiusKm = 6371;
+  const lat1Rad = lat1 * Math.PI / 180;
+  const lat2Rad = lat2 * Math.PI / 180;
+  const dLat = (lat2 - lat1) * Math.PI / 180;
+  const dLon = (lon2 - lon1) * Math.PI / 180;
+  const a = Math.sin(dLat / 2) * Math.sin(dLat / 2) + Math.cos(lat1Rad) * Math.cos(lat2Rad) * Math.sin(dLon / 2) * Math.sin(dLon / 2);
   const c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a));
-  return R * c;
+  return earthRadiusKm * c;
 }
 function checkOnLocation(targetLat, targetLon, allowedRange, userPosition) {
   if (!userPosition) {
@@ -609,20 +626,27 @@ function validateCoordinates(coords) {
 }
 
 // src/utils/validation.ts
-var READ_TIMEOUT = 15e3;
+var READ_TIMEOUT = 3e4;
 var readRecords = [];
 function checkRepetitiveRead(code) {
   const now = Date.now();
-  readRecords = readRecords.filter((record) => now - record.timestamp < READ_TIMEOUT);
+  readRecords = readRecords.filter(
+    (record) => now - record.timestamp < READ_TIMEOUT
+  );
   const recentRead = readRecords.find(
     (record) => record.code === code && now - record.timestamp < READ_TIMEOUT
   );
   if (recentRead) {
     return false;
   }
-  readRecords.push({ code, timestamp: now });
   return true;
 }
+var addQrReadRecord = (code) => {
+  const now = Date.now();
+  if (code) {
+    readRecords.push({ code, timestamp: now });
+  }
+};
 function clearReadRecords() {
   readRecords = [];
 }
@@ -636,6 +660,27 @@ function validateDeviceId(id) {
   const uuidRegex = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
   return uuidRegex.test(id);
 }
+var shouldValidateLocation = (device) => {
+  return device.range_matter === "1" && !!device.latitude && !!device.longitude;
+};
+var validateLocation = (device, userLocation) => {
+  if (!shouldValidateLocation(device)) {
+    return { valid: true };
+  }
+  if (!userLocation) {
+    return { valid: false };
+  }
+  const locationCheck = checkOnLocation(
+    device.latitude,
+    device.longitude,
+    device.range || 100,
+    userLocation
+  );
+  return {
+    valid: locationCheck.ok,
+    distance: locationCheck.distance
+  };
+};
 
 // src/utils/date.ts
 function formatISO(date = /* @__PURE__ */ new Date()) {
@@ -662,442 +707,162 @@ function parseISO(isoString) {
   return new Date(isoString);
 }
 
-// src/services/QRAccessService.ts
-var QRAccessService = class {
-  constructor(apiClient) {
-    this.apiClient = apiClient;
-  }
-  /**
-   * Validate QR code format
-   */
-  validateQRFormat(code) {
-    return validateQRCode(code);
-  }
-  /**
-   * Check if location validation is required
-   */
-  shouldValidateLocation(device) {
-    return device.range_matter === "1" && !!device.latitude && !!device.longitude;
-  }
-  /**
-   * Validate user location against device location
-   */
-  validateLocation(device, userLocation) {
-    if (!this.shouldValidateLocation(device)) {
+// src/services/NFCAccessService.ts
+var NfcAccessService = {
+  validateNFCFormat: (code) => {
+    return validateNFCCode(code);
+  },
+  shouldValidateLocation: (device) => {
+    return device?.nfc_range_matter === "1" && !!device?.latitude && !!device.longitude;
+  },
+  validateLocation: (device, userLocation) => {
+    if (!NfcAccessService.shouldValidateLocation(device)) {
       return { valid: true };
     }
     if (!userLocation) {
       return { valid: false };
     }
     const locationCheck = checkOnLocation(
-      device.latitude,
-      device.longitude,
-      device.range || 100,
+      device?.latitude,
+      device?.longitude,
+      device?.nfc_range || 100,
       userLocation
     );
     return {
       valid: locationCheck.ok,
       distance: locationCheck.distance
     };
-  }
+  },
   /**
-   * Validate QR code with full checks
+   * Validate NFC code with full checks
    */
-  async validateQR(options) {
-    const { qrCode, device, userLocation, skipLocationCheck, skipRepetitiveCheck } = options;
-    if (!this.validateQRFormat(qrCode)) {
-      return {
-        success: false,
-        message: "Invalid QR code format",
-        error: { code: "INVALID_QR_FORMAT" }
-      };
-    }
-    if (!skipRepetitiveCheck && !checkRepetitiveRead(qrCode)) {
-      return {
-        success: false,
-        message: "QR code was recently scanned. Please wait before scanning again.",
-        error: { code: "REPETITIVE_READ" }
-      };
-    }
-    if (!skipLocationCheck) {
-      const locationValidation = this.validateLocation(device, userLocation);
-      if (!locationValidation.valid) {
+  async validateNFC(options) {
+    const { device } = options;
+    const onlineRequestBody = {
+      device_id: device.id
+    };
+    if (device.is_iot) {
+      try {
+        const enteranceQrRes = await QRAccessService.createEntranceFromQR(
+          onlineRequestBody
+        );
+        return {
+          success: !!enteranceQrRes?.success,
+          message: "QR code validated successfully",
+          entrance: enteranceQrRes.data
+        };
+      } catch (error) {
         return {
           success: false,
-          message: "You are not within the allowed range of this device",
-          error: {
-            code: "LOCATION_OUT_OF_RANGE",
-            details: locationValidation.distance ? `Distance: ${locationValidation.distance.toFixed(2)}m` : void 0
-          }
+          message: error.message || "Failed to validate QR code",
+          error: { code: "NETWORK_ERROR" }
         };
       }
-    }
-    try {
-      const response = await this.apiClient.post({
-        endpoint: EP_QR_CHECK,
-        data: { qr_code: qrCode }
-      });
-      if (!response.success) {
+    } else {
+      try {
+        const enteranceQrRes = await QRAccessService.createEntranceFromQR(
+          onlineRequestBody
+        );
+        return {
+          success: !!enteranceQrRes?.success,
+          message: "QR code validated successfully",
+          entrance: enteranceQrRes.data
+        };
+      } catch (error) {
         return {
           success: false,
-          message: response.message || "QR validation failed",
-          error: { code: "API_ERROR" }
+          message: error.message || "Failed to validate QR code",
+          error: { code: "NETWORK_ERROR" }
         };
       }
-      return {
-        success: true,
-        message: "QR code validated successfully",
-        entrance: response.data
-      };
-    } catch (error) {
-      return {
-        success: false,
-        message: error.message || "Failed to validate QR code",
-        error: { code: "NETWORK_ERROR" }
-      };
     }
   }
+};
+
+// src/services/DeviceAccessService.ts
+var DeviceAccessService = {
   /**
-   * Create entrance from QR code
+   * Get all devices
    */
-  async createEntranceFromQR(request) {
-    return this.apiClient.post({
-      endpoint: EP_CREATE_QR,
-      data: request
+  getDevices: async (params) => {
+    return httpClient.get(EP_DEVICES, {
+      params: params || { per_page: 100 }
     });
-  }
+  },
   /**
-   * Trigger IoT device
+   * Get all QR devices
    */
-  async triggerIoTDevice(deviceId) {
-    return this.apiClient.post({
-      endpoint: `${EP_TRIGGER_IOT}/${deviceId}`
-    });
-  }
-};
-
-// src/services/NFCAccessService.ts
-var NFCAccessService = class {
-  constructor(apiClient) {
-    this.apiClient = apiClient;
-  }
+  getQRDevices: async (params) => {
+    return httpClient.get(
+      EP_QR_DEVICES,
+      {
+        params: params || { per_page: 100 }
+      }
+    );
+  },
   /**
-   * Validate NFC code format
+   * Get all QR devices with pagination support
    */
-  validateNFCFormat(code) {
-    return validateNFCCode(code);
-  }
+  getAllQRDevices: async () => {
+    const perPage = 50;
+    let currentPage = 1;
+    let allData = [];
+    while (true) {
+      const response = await DeviceAccessService.getQRDevices({
+        page: currentPage,
+        per_page: perPage
+      });
+      if (!response.success || !response.data) {
+        break;
+      }
+      allData = [...allData, ...response.data];
+      if (!response.meta || !response.meta.total_pages) {
+        break;
+      }
+      if (currentPage >= response.meta.total_pages) {
+        break;
+      }
+      currentPage++;
+    }
+    return allData;
+  },
   /**
-   * Check if location validation is required
+   * Get accessible QR codes for current user
    */
-  shouldValidateLocation(device) {
-    return device.nfc_range_matter === "1" && !!device.latitude && !!device.longitude;
-  }
+  getAccessibleQRs: async () => {
+    return httpClient.get(
+      EP_QR_ACCESS
+    );
+  },
   /**
-   * Validate user location against device location
+   * Get user devices
    */
-  validateLocation(device, userLocation) {
-    if (!this.shouldValidateLocation(device)) {
-      return { valid: true };
-    }
-    if (!userLocation) {
-      return { valid: false };
-    }
-    const locationCheck = checkOnLocation(
-      device.latitude,
-      device.longitude,
-      device.nfc_range || 100,
-      userLocation
-    );
-    return {
-      valid: locationCheck.ok,
-      distance: locationCheck.distance
-    };
-  }
-  /**
-   * Validate NFC code with full checks
-   */
-  async validateNFC(options) {
-    const { nfcCode, device, userLocation, skipLocationCheck, skipRepetitiveCheck } = options;
-    if (!this.validateNFCFormat(nfcCode)) {
-      return {
-        success: false,
-        message: "Invalid NFC code format",
-        error: { code: "INVALID_NFC_FORMAT" }
-      };
-    }
-    if (!skipRepetitiveCheck && !checkRepetitiveRead(nfcCode)) {
-      return {
-        success: false,
-        message: "NFC card was recently scanned. Please wait before scanning again.",
-        error: { code: "REPETITIVE_READ" }
-      };
-    }
-    if (!skipLocationCheck) {
-      const locationValidation = this.validateLocation(device, userLocation);
-      if (!locationValidation.valid) {
-        return {
-          success: false,
-          message: "You are not within the allowed range of this device",
-          error: {
-            code: "LOCATION_OUT_OF_RANGE",
-            details: locationValidation.distance ? `Distance: ${locationValidation.distance.toFixed(2)}m` : void 0
-          }
-        };
-      }
-    }
-    try {
-      const response = await this.apiClient.post({
-        endpoint: EP_NFC_CHECK,
-        data: { nfc_code: nfcCode }
-      });
-      if (!response.success) {
-        return {
-          success: false,
-          message: response.message || "NFC validation failed",
-          error: { code: "API_ERROR" }
-        };
-      }
-      return {
-        success: true,
-        message: "NFC card validated successfully",
-        entrance: response.data
-      };
-    } catch (error) {
-      return {
-        success: false,
-        message: error.message || "Failed to validate NFC card",
-        error: { code: "NETWORK_ERROR" }
-      };
-    }
-  }
-};
-
-// src/services/CheckInService.ts
-var CheckInService = class {
-  constructor(apiClient) {
-    this.apiClient = apiClient;
-  }
-  /**
-   * Get nearby branches based on user location
-   */
-  async getNearbyBranches(request) {
-    const { latitude, longitude, radius } = request;
-    if (!validateCoordinates({ latitude, longitude })) {
-      throw new Error("Invalid coordinates provided");
-    }
-    return this.apiClient.get({
-      endpoint: EP_BRANCHES,
-      params: {
-        latitude,
-        longitude,
-        ...radius && { radius }
-      }
-    });
-  }
-  /**
-   * Check in to a branch
-   */
-  async checkIn(options) {
-    const { branchId, entranceType, userId, userLocation: _userLocation } = options;
-    try {
-      const entranceRequest = {
-        user_id: userId,
-        branch_id: branchId,
-        entrance_type: entranceType,
-        is_manual_recording: false
-      };
-      const response = await this.apiClient.post({
-        endpoint: EP_ENTRANCES,
-        data: entranceRequest
-      });
-      if (!response.success) {
-        return {
-          success: false,
-          message: response.message || "Check-in failed",
-          error: { code: "API_ERROR" }
-        };
-      }
-      return {
-        success: true,
-        message: "Check-in successful",
-        entrance: response.data
-      };
-    } catch (error) {
-      return {
-        success: false,
-        message: error.message || "Failed to check-in",
-        error: { code: "NETWORK_ERROR" }
-      };
-    }
-  }
-  /**
-   * Get branch by ID
-   */
-  async getBranchById(branchId) {
-    return this.apiClient.get({
-      endpoint: `${EP_BRANCHES}/${branchId}`
-    });
-  }
-  /**
-   * Get all branches (with pagination)
-   */
-  async getAllBranches(params) {
-    return this.apiClient.get({
-      endpoint: EP_BRANCHES,
-      params
-    });
-  }
-};
-
-// src/services/RemoteWorkService.ts
-var RemoteWorkService = class {
-  constructor(apiClient) {
-    this.apiClient = apiClient;
-  }
-  /**
-   * Log remote work entry or exit
-   */
-  async logRemoteWork(options) {
-    const { userId, entranceType, timestamp, description } = options;
-    try {
-      const createdAt = timestamp ? typeof timestamp === "string" ? timestamp : formatISO(timestamp) : formatISO();
-      const entranceRequest = {
-        user_id: userId,
-        entrance_type: entranceType,
-        is_manual_recording: true,
-        is_remote_work: true,
-        created_at: createdAt,
-        description
-      };
-      const response = await this.apiClient.post({
-        endpoint: EP_ENTRANCES,
-        data: { entrance: entranceRequest }
-      });
-      if (!response.success) {
-        return {
-          success: false,
-          message: response.message || "Failed to log remote work",
-          error: { code: "API_ERROR" }
-        };
-      }
-      return {
-        success: true,
-        message: "Remote work logged successfully",
-        entrance: response.data
-      };
-    } catch (error) {
-      return {
-        success: false,
-        message: error.message || "Failed to log remote work",
-        error: { code: "NETWORK_ERROR" }
-      };
-    }
-  }
-  /**
-   * Log remote work entry
-   */
-  async logEntry(options) {
-    return this.logRemoteWork({
-      ...options,
-      entranceType: 0 /* ENTRY */
-    });
-  }
-  /**
-   * Log remote work exit
-   */
-  async logExit(options) {
-    return this.logRemoteWork({
-      ...options,
-      entranceType: 1 /* EXIT */
-    });
-  }
-};
-
-// src/services/DeviceAccessService.ts
-var DeviceAccessService = class {
-  constructor(apiClient) {
-    this.apiClient = apiClient;
-  }
-  /**
-   * Get all devices
-   */
-  async getDevices(params) {
-    return this.apiClient.get({
-      endpoint: EP_DEVICES,
-      params: params || { per_page: 100 }
-    });
-  }
-  /**
-   * Get all QR devices
-   */
-  async getQRDevices(params) {
-    return this.apiClient.get({
-      endpoint: EP_QR_DEVICES,
-      params: params || { per_page: 100 }
-    });
-  }
-  /**
-   * Get all QR devices with pagination support
-   */
-  async getAllQRDevices() {
-    const perPage = 50;
-    let currentPage = 1;
-    let allData = [];
-    while (true) {
-      const response = await this.getQRDevices({
-        page: currentPage,
-        per_page: perPage
-      });
-      if (!response.success || !response.data) {
-        break;
-      }
-      allData = [...allData, ...response.data];
-      if (!response.meta || !response.meta.total_pages) {
-        break;
-      }
-      if (currentPage >= response.meta.total_pages) {
-        break;
-      }
-      currentPage++;
-    }
-    return allData;
-  }
-  /**
-   * Get accessible QR codes for current user
-   */
-  async getAccessibleQRs() {
-    return this.apiClient.get({
-      endpoint: EP_QR_ACCESS
-    });
-  }
-  /**
-   * Get user devices
-   */
-  async getUserDevices(request) {
-    const { userId, page, per_page } = request;
-    return this.apiClient.get({
-      endpoint: `${EP_USERS}/${userId}/devices`,
-      params: {
-        ...page && { page },
-        ...per_page && { per_page }
+  getUserDevices: async (request2) => {
+    const { userId, page, per_page } = request2;
+    return httpClient.get(
+      `${EP_USERS}/${userId}/devices`,
+      {
+        params: {
+          ...page && { page },
+          ...per_page && { per_page }
+        }
       }
-    });
-  }
+    );
+  },
   /**
    * Get device by ID
    */
-  async getDeviceById(deviceId) {
-    return this.apiClient.get({
-      endpoint: `${EP_DEVICES}/${deviceId}`
-    });
-  }
+  getDeviceById: async (deviceId) => {
+    return httpClient.get(
+      `${EP_DEVICES}/${deviceId}`
+    );
+  },
   /**
    * Check if user has access to a device
    */
-  async checkDeviceAccess(deviceId) {
+  checkDeviceAccess: async (deviceId) => {
     try {
-      const response = await this.getAccessibleQRs();
+      const response = await DeviceAccessService.getAccessibleQRs();
       if (!response.success || !response.data) {
         return false;
       }
@@ -1105,24 +870,25 @@ var DeviceAccessService = class {
     } catch {
       return false;
     }
-  }
+  },
   /**
    * Find QR device by QR code ID
    */
-  async findDeviceByQRCode(qrCodeId) {
+  findDeviceByQRCode: async (qrCodeId) => {
     try {
-      const devices = await this.getAllQRDevices();
-      return devices.find((device) => device.qr_code_id === qrCodeId);
+      const devices = await DeviceAccessService.getAllQRDevices();
+      const qr = devices.find((device) => device.qr_code_id === qrCodeId);
+      return qr;
     } catch {
       return void 0;
     }
-  }
+  },
   /**
    * Find QR device by NFC code
    */
-  async findDeviceByNFCCode(nfcCode) {
+  findDeviceByNFCCode: async (nfcCode) => {
     try {
-      const devices = await this.getAllQRDevices();
+      const devices = await DeviceAccessService.getAllQRDevices();
       return devices.find((device) => device.nfc_code === nfcCode);
     } catch {
       return void 0;
@@ -1217,41 +983,35 @@ var LocationService = class {
     return this.logLocationVerification(log);
   }
 };
-
-// src/providers/PassgageAccessProvider.tsx
-var import_react = __toESM(require("react"));
-
-// src/utils/secureStorage.ts
-var Keychain = __toESM(require("react-native-keychain"));
 var STORAGE_KEYS = {
   TOKENS: "passgage_auth_tokens",
   USER: "passgage_user_info"
 };
-var SecureStorage = class {
+var SecureStorage = {
   /**
    * Save tokens to secure storage
    */
-  async saveTokens(tokens) {
+  saveTokens: async (tokens) => {
     try {
-      await Keychain.setGenericPassword(
+      await Keychain__namespace.setGenericPassword(
         STORAGE_KEYS.TOKENS,
         JSON.stringify(tokens),
         {
           service: STORAGE_KEYS.TOKENS,
-          accessible: Keychain.ACCESSIBLE.WHEN_UNLOCKED
+          accessible: Keychain__namespace.ACCESSIBLE.WHEN_UNLOCKED
         }
       );
     } catch (error) {
       console.error("Failed to save tokens to secure storage:", error);
       throw new Error("Failed to save tokens");
     }
-  }
+  },
   /**
    * Get tokens from secure storage
    */
-  async getTokens() {
+  getTokens: async () => {
     try {
-      const credentials = await Keychain.getGenericPassword({
+      const credentials = await Keychain__namespace.getGenericPassword({
         service: STORAGE_KEYS.TOKENS
       });
       if (!credentials) {
@@ -1263,43 +1023,43 @@ var SecureStorage = class {
       console.error("Failed to get tokens from secure storage:", error);
       return null;
     }
-  }
+  },
   /**
    * Clear tokens from secure storage
    */
-  async clearTokens() {
+  clearTokens: async () => {
     try {
-      await Keychain.resetGenericPassword({
+      await Keychain__namespace.resetGenericPassword({
         service: STORAGE_KEYS.TOKENS
       });
     } catch (error) {
       console.error("Failed to clear tokens from secure storage:", error);
     }
-  }
+  },
   /**
    * Save user information
    */
-  async saveUser(user) {
+  saveUser: async (user) => {
     try {
-      await Keychain.setGenericPassword(
+      await Keychain__namespace.setGenericPassword(
         STORAGE_KEYS.USER,
         JSON.stringify(user),
         {
           service: STORAGE_KEYS.USER,
-          accessible: Keychain.ACCESSIBLE.WHEN_UNLOCKED
+          accessible: Keychain__namespace.ACCESSIBLE.WHEN_UNLOCKED
         }
       );
     } catch (error) {
       console.error("Failed to save user to secure storage:", error);
       throw new Error("Failed to save user");
     }
-  }
+  },
   /**
    * Get user information
    */
-  async getUser() {
+  getUser: async () => {
     try {
-      const credentials = await Keychain.getGenericPassword({
+      const credentials = await Keychain__namespace.getGenericPassword({
         service: STORAGE_KEYS.USER
       });
       if (!credentials) {
@@ -1311,269 +1071,579 @@ var SecureStorage = class {
       console.error("Failed to get user from secure storage:", error);
       return null;
     }
-  }
+  },
   /**
    * Clear user information
    */
-  async clearUser() {
+  clearUser: async () => {
     try {
-      await Keychain.resetGenericPassword({
+      await Keychain__namespace.resetGenericPassword({
         service: STORAGE_KEYS.USER
       });
     } catch (error) {
       console.error("Failed to clear user from secure storage:", error);
     }
-  }
+  },
   /**
    * Clear all data (tokens + user)
    */
-  async clearAll() {
-    await this.clearTokens();
-    await this.clearUser();
+  clearAll: async () => {
+    await SecureStorage.clearTokens();
+    await SecureStorage.clearUser();
   }
 };
-function createSecureStorage() {
-  return new SecureStorage();
-}
+var qrScannerStore = zustand.create((set) => ({
+  loading: false,
+  error: null,
+  qrDevices: [],
+  qrAccessDevices: [],
+  handleQrAccess: async () => {
+    const res = await DeviceAccessService.getAccessibleQRs();
+    if (res.data) {
+      set({ qrAccessDevices: res.data.qr_ids });
+    }
+  },
+  fetchQrDevicesAndAccess: async () => {
+    try {
+      const [qrDevicesRes, qrAccessRes] = await Promise.all([
+        DeviceAccessService.getAllQRDevices(),
+        DeviceAccessService.getAccessibleQRs()
+      ]);
+      if (qrDevicesRes && qrDevicesRes.length > 0 && qrAccessRes) {
+        set({
+          qrDevices: qrDevicesRes,
+          qrAccessDevices: qrAccessRes.data?.qr_ids
+        });
+      }
+    } catch (error) {
+    }
+  }
+}));
+var locationStore = zustand.create((set) => ({
+  location: null,
+  error: null,
+  loading: false,
+  refreshLocation: (config = {
+    enableHighAccuracy: true,
+    timeout: 15e3,
+    maximumAge: 1e4
+  }) => {
+    Geolocation2__default.default.getCurrentPosition(
+      (position) => {
+        set({
+          loading: false,
+          error: null,
+          location: {
+            latitude: position.coords.latitude,
+            longitude: position.coords.longitude,
+            accuracy: position.coords.accuracy,
+            altitude: position.coords.altitude ?? void 0,
+            altitudeAccuracy: position.coords.altitudeAccuracy ?? void 0,
+            heading: position.coords.heading ?? void 0,
+            speed: position.coords.speed ?? void 0
+          }
+        });
+      },
+      (err) => {
+        set({
+          loading: false,
+          error: err
+        });
+      },
+      config
+    );
+  }
+}));
 
-// src/providers/PassgageAccessProvider.tsx
-var PassgageAccessContext = (0, import_react.createContext)(void 0);
-function PassgageAccessProvider({
-  children,
-  baseURL,
-  token,
-  apiVersion = "v2",
-  timeout = 3e4,
-  onUnauthorized,
-  onError
-}) {
-  const config = {
-    baseURL,
-    token,
-    apiVersion,
-    timeout,
-    onUnauthorized,
-    onError
-  };
-  const { apiClient, services } = (0, import_react.useMemo)(() => {
-    const secureStorage = createSecureStorage();
-    let authService;
-    const client = createApiClient({
-      baseURL: config.baseURL,
-      token: config.token,
-      apiVersion: config.apiVersion,
-      timeout: config.timeout,
-      onUnauthorized: config.onUnauthorized,
-      onError: config.onError,
-      onTokenRefreshNeeded: async () => {
-        const storedTokens = await authService.getStoredTokens();
-        if (!storedTokens) {
-          return null;
-        }
-        const result = await authService.refreshToken(storedTokens.refresh.token);
-        if (result.success) {
-          return result.tokens.access.token;
-        }
-        return null;
+// src/utils/flowHelpers.ts
+var enteranceFlow = async (data, options) => {
+  const location = locationStore.getState().location;
+  const qrAccessDevices = qrScannerStore.getState().qrAccessDevices;
+  const { qrCode, device, isQrCode, nfcCode = "" } = data;
+  if (isQrCode ? !validateQRCode(qrCode) : validateNFCCode(nfcCode)) {
+    return {
+      success: false,
+      message: "Invalid QR code format",
+      error: { code: "INVALID_QR_FORMAT" }
+    };
+  }
+  const checkAccessible = isQrCode ? qrAccessDevices.find((qrAccessDevice) => qrAccessDevice === qrCode) : qrAccessDevices.find((qrAccessDevice) => qrAccessDevice === nfcCode);
+  if (!checkAccessible) {
+    return {
+      success: false,
+      message: "You do not have permission. Please contact your administrator",
+      error: {
+        code: "QR_ACCESS_DENIED"
       }
-    });
-    authService = new AuthService(client);
-    authService.setTokenStorage(secureStorage);
-    const allServices = {
-      authService,
-      qrAccessService: new QRAccessService(client),
-      nfcAccessService: new NFCAccessService(client),
-      checkInService: new CheckInService(client),
-      remoteWorkService: new RemoteWorkService(client),
-      deviceAccessService: new DeviceAccessService(client),
-      locationService: new LocationService(client)
     };
+  }
+  if (!options.skipRepetitiveCheck && !checkRepetitiveRead(isQrCode ? qrCode : nfcCode)) {
     return {
-      apiClient: client,
-      services: allServices
+      success: false,
+      message: "QR code was recently scanned. Please wait before scanning again.",
+      error: { code: "REPETITIVE_READ" }
     };
-  }, [config.baseURL, config.token, config.apiVersion, config.timeout, config.onUnauthorized, config.onError]);
-  const setToken = (newToken) => {
-    apiClient.setToken(newToken);
-  };
-  const clearToken = () => {
-    apiClient.clearToken();
-  };
-  const contextValue = {
-    apiClient,
-    ...services,
-    config,
-    setToken,
-    clearToken
-  };
-  return /* @__PURE__ */ import_react.default.createElement(PassgageAccessContext.Provider, { value: contextValue }, children);
-}
-function usePassgageAccess() {
-  const context = (0, import_react.useContext)(PassgageAccessContext);
-  if (!context) {
-    throw new Error(
-      "usePassgageAccess must be used within a PassgageAccessProvider"
-    );
   }
-  return context;
-}
-
-// src/hooks/usePassgageAuth.ts
-var import_react2 = require("react");
-function usePassgageAuth(options = {}) {
-  const {
-    onLoginSuccess,
-    onLoginError,
-    onLogoutSuccess,
-    autoRestore = true
-  } = options;
-  const { authService } = usePassgageAccess();
-  const [isAuthenticated, setIsAuthenticated] = (0, import_react2.useState)(false);
-  const [user, setUser] = (0, import_react2.useState)(null);
-  const [isLoading, setIsLoading] = (0, import_react2.useState)(false);
-  const [error, setError] = (0, import_react2.useState)(null);
-  (0, import_react2.useEffect)(() => {
-    if (!autoRestore) {
-      return;
-    }
-    const restoreAuth = async () => {
-      try {
-        setIsLoading(true);
-        const authenticated = await authService.isAuthenticated();
-        if (authenticated) {
-          const storedTokens = await authService.getStoredTokens();
-          const storedUser = await authService.getStoredUser();
-          if (storedTokens && storedUser) {
-            authService["apiClient"].setToken(storedTokens.access.token);
-            setIsAuthenticated(true);
-            setUser(storedUser);
-            try {
-              const userResult = await authService.getCurrentUser();
-              if (userResult.success) {
-                setUser(userResult.user);
-              }
-            } catch (error2) {
-              console.warn("Failed to fetch fresh user info:", error2);
-            }
-          }
+  if (!options.skipLocationCheck) {
+    const locationValidation = validateLocation(device, location ?? void 0);
+    if (!locationValidation.valid) {
+      return {
+        success: false,
+        message: `You are not within the allowed range of this device${location?.latitude},${location?.longitude}`,
+        error: {
+          code: "LOCATION_OUT_OF_RANGE",
+          details: locationValidation.distance ? `Distance: ${locationValidation.distance.toFixed(2)}m` : void 0
         }
-      } catch (error2) {
-        console.error("Failed to restore authentication:", error2);
-        setError(error2.message || "Failed to restore authentication");
-      } finally {
-        setIsLoading(false);
-      }
-    };
-    restoreAuth();
-  }, [authService, autoRestore]);
-  const login = (0, import_react2.useCallback)(
-    async (credentials) => {
-      try {
-        setIsLoading(true);
-        setError(null);
-        const result = await authService.login(credentials);
-        if (result.success) {
-          setIsAuthenticated(true);
-          setUser(result.user || null);
-          if (onLoginSuccess) {
-            onLoginSuccess(result.user);
-          }
-        } else {
-          setError(result.error);
-          if (onLoginError) {
-            onLoginError(result.error);
+      };
+    }
+  }
+  const onlineRequestBody = {
+    device_id: device?.id ?? ""
+  };
+  if (device?.is_iot) {
+    try {
+      const enteranceResIot = await QRAccessService.triggerIoTDevice(device.id);
+      if (enteranceResIot.success) {
+        try {
+          const enteranceQrRes = await QRAccessService.createEntranceFromQR(
+            onlineRequestBody
+          );
+          if (enteranceQrRes.success) {
+            addQrReadRecord(qrCode);
+            return {
+              success: !!enteranceQrRes?.success,
+              message: enteranceQrRes.success ? "Enterance validated successfully" : "Enterance validation failed",
+              entrance: enteranceQrRes.data
+            };
+          } else {
+            return {
+              success: false,
+              message: enteranceQrRes.message ?? "Trigger IOT validation failed"
+            };
           }
+        } catch (error) {
+          return {
+            success: false,
+            message: error?.message ?? "Qr enterance failed"
+          };
         }
-        return result;
-      } catch (error2) {
-        const errorMessage = error2.message || "An error occurred during login";
-        setError(errorMessage);
-        if (onLoginError) {
-          onLoginError(errorMessage);
-        }
+      } else {
         return {
           success: false,
-          error: errorMessage,
-          code: "UNKNOWN_ERROR"
+          message: enteranceResIot.message ?? "Trigger IOT validation failed"
         };
-      } finally {
-        setIsLoading(false);
-      }
-    },
-    [authService, onLoginSuccess, onLoginError]
-  );
-  const logout = (0, import_react2.useCallback)(async () => {
-    try {
-      setIsLoading(true);
-      setError(null);
-      await authService.logout();
-      setIsAuthenticated(false);
-      setUser(null);
-      if (onLogoutSuccess) {
-        onLogoutSuccess();
       }
-    } catch (error2) {
-      const errorMessage = error2.message || "An error occurred during logout";
-      setError(errorMessage);
-      console.error("Logout failed:", error2);
-    } finally {
-      setIsLoading(false);
+    } catch (error) {
+      return {
+        success: false,
+        message: error ?? "Trigger IOT validation failed"
+      };
     }
-  }, [authService, onLogoutSuccess]);
-  const refreshToken = (0, import_react2.useCallback)(async () => {
+  } else {
     try {
-      const storedTokens = await authService.getStoredTokens();
-      if (!storedTokens) {
+      const enteranceQrRes = await QRAccessService.createEntranceFromQR(
+        onlineRequestBody
+      );
+      addQrReadRecord(qrCode);
+      return {
+        success: !!enteranceQrRes?.success,
+        message: enteranceQrRes.success ? "QR code validated successfully" : "QR code validation failed",
+        entrance: enteranceQrRes.data
+      };
+    } catch (error) {
+      return {
+        success: false,
+        message: error.message || "Failed to validate QR code",
+        error: { code: "NETWORK_ERROR" }
+      };
+    }
+  }
+};
+var loginSuccessFlow = async (result) => {
+  qrScannerStore.getState().fetchQrDevicesAndAccess();
+  if (result.success) {
+    await SecureStorage.saveTokens(result.tokens);
+    if (result.user) {
+      await SecureStorage.saveUser?.(result.user);
+    }
+  }
+};
+
+// src/stores/authStore.ts
+var useAuthStore = zustand.create((set, get) => ({
+  loading: false,
+  error: null,
+  authStatus: false,
+  user: null,
+  restoreAuth: async () => {
+    const tokens = await SecureStorage.getTokens?.();
+    try {
+      set({ loading: true });
+      const isAuthenticated = tokens !== null && tokens?.access?.token?.length > 0;
+      if (isAuthenticated) {
+        const storedTokens = await SecureStorage.getTokens?.();
+        const storedUser = await SecureStorage.getUser?.();
+        if (storedTokens && storedUser) {
+          setTokenToHttpClient(storedTokens.access.token);
+          set({
+            user: storedUser,
+            authStatus: true
+          });
+          try {
+            const userResult = await AuthService.getCurrentUser();
+            if (userResult.success) {
+              set({
+                user: userResult.user
+              });
+              qrScannerStore.getState().fetchQrDevicesAndAccess();
+            }
+          } catch (error) {
+            console.warn("Failed to fetch fresh user info:", error);
+          }
+        }
+      }
+    } catch (error) {
+      console.error("Failed to restore authentication:", error);
+      set({ error: error.message || "Failed to restore authentication" });
+    } finally {
+      set({ loading: false });
+    }
+  },
+  login: async (credentials, resolve, reject) => {
+    try {
+      set({ loading: true, error: null });
+      const result = await AuthService.login(credentials);
+      if (result.success) {
+        resolve?.(result.user);
+        loginSuccessFlow(result);
+        set({ authStatus: true, user: result.user || null });
+      } else {
+        get().logout();
+        reject?.(result.error);
+        set({ error: result.error });
+      }
+    } catch (error) {
+      get().logout();
+      const errorMessage = error.message || "An error occurred during login";
+      set({ error: errorMessage });
+      reject?.(errorMessage);
+    } finally {
+      set({ loading: false });
+    }
+  },
+  loginWithAzure: async (credentials, resolve, reject) => {
+    try {
+      set({ loading: true, error: null });
+      const result = await AuthService.loginWithAzure(credentials);
+      if (result.success) {
+        loginSuccessFlow(result);
+        resolve?.(result.user);
+        set({ authStatus: true, user: result.user || null });
+      } else {
+        reject?.(result.error);
+        get().logout();
+        set({ error: result.error });
+      }
+    } catch (error) {
+      const errorMessage = error.message || "An error occurred during Azure login";
+      get().logout();
+      set({ error: errorMessage });
+      reject?.(errorMessage);
+    } finally {
+      set({ loading: false });
+    }
+  },
+  logout: async (resolve) => {
+    try {
+      set({
+        loading: true,
+        error: null
+      });
+      await SecureStorage.clearTokens?.();
+      await SecureStorage.clearUser?.();
+      set({ authStatus: false, user: null });
+      resolve?.();
+    } catch (error) {
+      const errorMessage = error.message || "An error occurred during logout";
+      set({ error: errorMessage });
+      console.error("Logout failed:", error);
+    } finally {
+      set({ loading: false });
+    }
+  },
+  refreshToken: async () => {
+    try {
+      const storedTokens = await SecureStorage.getTokens?.();
+      if (!storedTokens) {
         return false;
       }
-      const result = await authService.refreshToken(storedTokens.refresh.token);
+      const result = await AuthService.refreshToken(storedTokens.refresh.token);
       if (result.success) {
         return true;
       } else {
-        await logout();
+        await get().logout();
         return false;
       }
-    } catch (error2) {
-      console.error("Token refresh failed:", error2);
-      await logout();
+    } catch (error) {
+      console.error("Token refresh failed:", error);
+      await get().logout();
       return false;
     }
-  }, [authService, logout]);
-  const clearError = (0, import_react2.useCallback)(() => {
-    setError(null);
+  },
+  clearError: () => {
+    set({ error: null });
+  }
+}));
+var PassgageAccessProvideContext = React.createContext(void 0);
+function PassgageAccessProvider(props) {
+  const {
+    children,
+    baseURL,
+    msalToken,
+    apiVersion = "v2",
+    timeout = 3e4,
+    rememberUser = true,
+    onUnauthorized = () => {
+    },
+    locationPermissionErrorCallback = () => {
+    },
+    getLocationErrorCallback = () => {
+    }
+  } = props;
+  const useLocationStore = locationStore();
+  const authStore = useAuthStore();
+  React.useEffect(() => {
+    const msalTokenInitFlow = async () => {
+      try {
+        await authStore.loginWithAzure(
+          {
+            id_token: msalToken ?? "",
+            device_type: reactNative.Platform.OS === "ios" ? "ios" : "android"
+          },
+          () => {
+          },
+          (error) => {
+            console.error("Failed to login with Azure:", error);
+            authStore.logout();
+          }
+        );
+      } catch (error) {
+        console.error("Failed to login with Azure:", error);
+        authStore.logout();
+      }
+    };
+    const LocationPermission = reactNative.Platform.select({
+      android: RNPermissions.PERMISSIONS.ANDROID.ACCESS_FINE_LOCATION,
+      ios: RNPermissions.PERMISSIONS.IOS.LOCATION_WHEN_IN_USE,
+      default: RNPermissions.PERMISSIONS.IOS.LOCATION_WHEN_IN_USE
+    });
+    if (LocationPermission) {
+      RNPermissions__default.default.check(LocationPermission).then((status) => {
+        switch (status) {
+          case RNPermissions.RESULTS.DENIED:
+            RNPermissions.request(LocationPermission).then(() => {
+              useLocationStore.refreshLocation();
+            });
+            break;
+          case RNPermissions.RESULTS.BLOCKED:
+          case RNPermissions.RESULTS.UNAVAILABLE:
+          case RNPermissions.RESULTS.GRANTED:
+          case RNPermissions.RESULTS.LIMITED:
+            useLocationStore.refreshLocation();
+            break;
+        }
+      }).catch((error) => {
+        locationPermissionErrorCallback(error);
+        console.error(error);
+      });
+    }
+    createHttpClient({ apiVersion, baseURL, timeout });
+    if (msalToken) {
+      msalTokenInitFlow();
+    } else {
+      authStore.logout();
+      onUnauthorized({
+        name: "Unauthorized",
+        message: "MSAL Token is required"
+      });
+    }
+    if (rememberUser) {
+      authStore.restoreAuth();
+    }
   }, []);
+  React.useEffect(() => {
+    if (useLocationStore.error) {
+      getLocationErrorCallback(useLocationStore.error);
+    }
+  }, [useLocationStore.error]);
+  return /* @__PURE__ */ React__default.default.createElement(PassgageAccessProvideContext.Provider, { value: { ...props } }, children);
+}
+var usePassgageAccessContext = () => {
+  const ctx = React.useContext(PassgageAccessProvideContext);
+  if (!ctx) {
+    throw new Error(
+      "usePassgageAccessContext must be used inside AuthProvider"
+    );
+  }
+  return ctx;
+};
+var usePassgageQRScanner = (payload) => {
+  const [isLoading, setIsLoading] = React.useState(false);
+  const [error, setError] = React.useState(null);
+  const { qrDevices } = qrScannerStore();
+  const scan = async (qrCode, device) => {
+    setIsLoading(true);
+    setError(null);
+    try {
+      let qrDevice = device;
+      if (!qrDevice) {
+        qrDevice = qrDevices.find((item) => item.qr_code_id === qrCode);
+        if (!qrDevice) {
+          payload.onError?.(
+            error ?? { message: "QR Device not found", success: false }
+          );
+          return;
+        }
+      }
+      const result = await enteranceFlow(
+        {
+          device: qrDevice,
+          qrCode,
+          isQrCode: true
+        },
+        payload.options
+      );
+      if (!result.success) {
+        payload.onError?.(result);
+      } else {
+        payload.onSuccess?.(result.entrance);
+      }
+    } catch (err) {
+      const errorObj = {
+        success: false,
+        message: err?.message || "Qr scan failed",
+        error: { code: "QR_SCAN_FAILED" }
+      };
+      setError(errorObj);
+      payload.onError?.(errorObj);
+    } finally {
+      setIsLoading(false);
+    }
+  };
   return {
-    login,
-    logout,
-    refreshToken,
-    isAuthenticated,
-    user,
+    scan,
     isLoading,
+    error
+  };
+};
+var bigInt = __require("big-integer");
+var reversedHexToDec = (reversedHex) => {
+  try {
+    reversedHex = reversedHex.replace(/\s+/g, "");
+    let originalHex = "";
+    for (let i = reversedHex.length; i > 0; i -= 2) {
+      originalHex += reversedHex.substring(i - 2, i);
+    }
+    let decimalValue = bigInt(originalHex, 16);
+    return decimalValue.toString();
+  } catch (error) {
+    return reversedHex;
+  }
+};
+function usePassgageNFCScanner(payload) {
+  const [supportNFC, setSupportNFC] = React.useState();
+  const [isScanning, setIsScanning] = React.useState(false);
+  const [nfcData, setNfcData] = React.useState();
+  const { qrDevices } = qrScannerStore();
+  const [error, setError] = React.useState(null);
+  React.useEffect(() => {
+    NfcManager__default.default.isSupported().then((supported) => {
+      if (supported) {
+        setSupportNFC(true);
+      } else {
+        setSupportNFC(false);
+      }
+    });
+    return () => {
+      NfcManager__default.default.cancelTechnologyRequest();
+    };
+  }, []);
+  const stopScanning = async () => {
+    try {
+      NfcManager__default.default.cancelTechnologyRequest().finally(() => {
+        setIsScanning(false);
+      });
+    } catch {
+    }
+  };
+  const handleNFCTag = async (tag) => {
+    if (!tag.id) {
+      return;
+    }
+    try {
+      const nfcCode = reversedHexToDec(tag.id);
+      if (reactNative.Platform.OS === "ios") {
+        await NfcManager__default.default.cancelTechnologyRequest();
+      }
+      const device = qrDevices.find((device2) => device2.nfc_code === nfcCode);
+      if (!device) {
+        throw new Error("NFC device not found");
+      }
+      const result = await enteranceFlow(
+        {
+          device,
+          nfcCode,
+          isQrCode: false
+        },
+        payload.options
+      );
+      if (!result.success) {
+        throw new Error(result.message);
+      }
+      payload.onSuccess?.(result.entrance);
+      stopScanning();
+    } catch (err) {
+      const error2 = err;
+      setError(error2);
+      payload.onError?.(error2);
+      stopScanning();
+    }
+  };
+  const startScanning = async () => {
+    await NfcManager__default.default.requestTechnology(NfcManager.NfcTech.Ndef, {
+      invalidateAfterFirstRead: true
+    });
+    await NfcManager__default.default.getTag().then((tag) => {
+      setNfcData(tag?.id ?? "");
+      handleNFCTag(tag || {});
+    }).catch(() => false);
+    NfcManager__default.default.cancelTechnologyRequest();
+    setIsScanning(true);
+    setError(null);
+  };
+  return {
+    nfcData,
+    supportNFC,
+    startScanning,
+    stopScanning,
     error,
-    clearError
+    isScanning
   };
 }
-
-// src/hooks/usePassgageQRScanner.ts
-var import_react4 = require("react");
-
-// src/hooks/useLocation.ts
-var import_react3 = require("react");
-var import_geolocation = __toESM(require("@react-native-community/geolocation"));
 function useLocation(options = {}) {
-  const [location, setLocation] = (0, import_react3.useState)(null);
-  const [error, setError] = (0, import_react3.useState)(null);
-  const [isLoading, setIsLoading] = (0, import_react3.useState)(true);
+  const [location, setLocation] = React.useState(null);
+  const [error, setError] = React.useState(null);
+  const [isLoading, setIsLoading] = React.useState(true);
   const config = {
     enableHighAccuracy: options.enableHighAccuracy ?? true,
     timeout: options.timeout ?? 15e3,
     maximumAge: options.maximumAge ?? 1e4
   };
-  const refreshLocation = (0, import_react3.useCallback)(async () => {
+  const refreshLocation = React.useCallback(async () => {
     setIsLoading(true);
     setError(null);
     return new Promise((resolve) => {
-      import_geolocation.default.getCurrentPosition(
+      Geolocation2__default.default.getCurrentPosition(
         (position) => {
           setLocation({
             latitude: position.coords.latitude,
@@ -1596,10 +1666,10 @@ function useLocation(options = {}) {
       );
     });
   }, [config.enableHighAccuracy, config.timeout, config.maximumAge]);
-  (0, import_react3.useEffect)(() => {
+  React.useEffect(() => {
     refreshLocation();
     if (options.watchPosition) {
-      const watchId = import_geolocation.default.watchPosition(
+      const watchId = Geolocation2__default.default.watchPosition(
         (position) => {
           setLocation({
             latitude: position.coords.latitude,
@@ -1617,7 +1687,7 @@ function useLocation(options = {}) {
         config
       );
       return () => {
-        import_geolocation.default.clearWatch(watchId);
+        Geolocation2__default.default.clearWatch(watchId);
       };
     }
     return void 0;
@@ -1630,377 +1700,43 @@ function useLocation(options = {}) {
   };
 }
 
-// src/hooks/usePassgageQRScanner.ts
-function usePassgageQRScanner(options = {}) {
-  const { qrAccessService, deviceAccessService } = usePassgageAccess();
-  const { location } = useLocation();
-  const [isLoading, setIsLoading] = (0, import_react4.useState)(false);
-  const [error, setError] = (0, import_react4.useState)(null);
-  const scan = (0, import_react4.useCallback)(
-    async (qrCode, device) => {
-      setIsLoading(true);
-      setError(null);
-      try {
-        let qrDevice = device;
-        if (!qrDevice) {
-          qrDevice = await deviceAccessService.findDeviceByQRCode(qrCode);
-          if (!qrDevice) {
-            throw new Error("QR device not found");
-          }
-        }
-        const result = await qrAccessService.validateQR({
-          qrCode,
-          device: qrDevice,
-          userLocation: location || void 0,
-          skipLocationCheck: options.skipLocationCheck,
-          skipRepetitiveCheck: options.skipRepetitiveCheck
-        });
-        if (!result.success) {
-          throw new Error(result.message);
-        }
-        options.onSuccess?.(result.entrance);
-      } catch (err) {
-        const error2 = err;
-        setError(error2);
-        options.onError?.(error2);
-      } finally {
-        setIsLoading(false);
-      }
-    },
-    [qrAccessService, deviceAccessService, location, options]
-  );
-  return {
-    scan,
-    isLoading,
-    error
-  };
-}
-
-// src/hooks/usePassgageNFCScanner.ts
-var import_react5 = require("react");
-var import_react_native_nfc_manager = __toESM(require("react-native-nfc-manager"));
-function reversedHexToDec(hexString) {
-  const hex = hexString.replace(/:/g, "");
-  return parseInt(hex, 16).toString();
-}
-function usePassgageNFCScanner(options = {}) {
-  const { nfcAccessService, deviceAccessService } = usePassgageAccess();
-  const { location } = useLocation();
-  const [isScanning, setIsScanning] = (0, import_react5.useState)(false);
-  const [error, setError] = (0, import_react5.useState)(null);
-  const stopScanning = (0, import_react5.useCallback)(async () => {
-    try {
-      await import_react_native_nfc_manager.default.cancelTechnologyRequest();
-      setIsScanning(false);
-    } catch {
-    }
-  }, []);
-  const handleNFCTag = (0, import_react5.useCallback)(
-    async (tag) => {
-      if (!tag.id) {
-        return;
-      }
-      try {
-        const nfcCode = reversedHexToDec(tag.id);
-        const device = await deviceAccessService.findDeviceByNFCCode(nfcCode);
-        if (!device) {
-          throw new Error("NFC device not found");
-        }
-        const result = await nfcAccessService.validateNFC({
-          nfcCode,
-          device,
-          userLocation: location || void 0,
-          skipLocationCheck: options.skipLocationCheck,
-          skipRepetitiveCheck: options.skipRepetitiveCheck
-        });
-        if (!result.success) {
-          throw new Error(result.message);
-        }
-        options.onSuccess?.(result.entrance);
-        await stopScanning();
-      } catch (err) {
-        const error2 = err;
-        setError(error2);
-        options.onError?.(error2);
-        await stopScanning();
-      }
-    },
-    [nfcAccessService, deviceAccessService, location, options, stopScanning]
-  );
-  const startScanning = (0, import_react5.useCallback)(async () => {
-    setIsScanning(true);
-    setError(null);
-    try {
-      await import_react_native_nfc_manager.default.requestTechnology(import_react_native_nfc_manager.NfcTech.Ndef, {
-        invalidateAfterFirstRead: true
-      });
-      const tag = await import_react_native_nfc_manager.default.getTag();
-      await handleNFCTag(tag || {});
-    } catch (err) {
-      const error2 = err;
-      setError(error2);
-      options.onError?.(error2);
-      setIsScanning(false);
-    }
-  }, [handleNFCTag, options]);
-  (0, import_react5.useEffect)(() => {
-    if (options.autoStart) {
-      startScanning();
-    }
-    return () => {
-      stopScanning();
-    };
-  }, [options.autoStart, startScanning, stopScanning]);
-  return {
-    startScanning,
-    stopScanning,
-    isScanning,
-    error
-  };
-}
-
-// src/hooks/usePassgageCheckIn.ts
-var import_react6 = require("react");
-function usePassgageCheckIn(options = {}) {
-  const { checkInService } = usePassgageAccess();
-  const { location } = useLocation();
-  const [isLoading, setIsLoading] = (0, import_react6.useState)(false);
-  const [error, setError] = (0, import_react6.useState)(null);
-  const getNearbyBranches = (0, import_react6.useCallback)(
-    async (params) => {
-      if (!location) {
-        return {
-          success: false,
-          error: "Location not available"
-        };
-      }
-      setIsLoading(true);
-      setError(null);
-      try {
-        const response = await checkInService.getNearbyBranches({
-          latitude: location.latitude,
-          longitude: location.longitude,
-          radius: params?.radius || options.radius
-        });
-        if (response.success && response.data) {
-          return {
-            success: true,
-            data: response.data
-          };
-        }
-        return {
-          success: false,
-          error: response.message || "Failed to fetch nearby branches"
-        };
-      } catch (err) {
-        const error2 = err;
-        setError(error2);
-        return {
-          success: false,
-          error: error2.message || "Failed to fetch nearby branches"
-        };
-      } finally {
-        setIsLoading(false);
-      }
-    },
-    [checkInService, location, options.radius]
-  );
-  const checkInEntry = (0, import_react6.useCallback)(
-    async (params) => {
-      setIsLoading(true);
-      setError(null);
-      try {
-        const result = await checkInService.checkIn({
-          branchId: params.branchId,
-          userId: params.userId,
-          entranceType: 0 /* ENTRY */,
-          userLocation: location || void 0
-        });
-        if (result.success) {
-          return {
-            success: true,
-            data: result.entrance
-          };
-        }
-        return {
-          success: false,
-          error: result.message || "Check-in failed"
-        };
-      } catch (err) {
-        const error2 = err;
-        setError(error2);
-        return {
-          success: false,
-          error: error2.message || "Check-in failed"
-        };
-      } finally {
-        setIsLoading(false);
-      }
-    },
-    [checkInService, location]
-  );
-  const checkInExit = (0, import_react6.useCallback)(
-    async (params) => {
-      setIsLoading(true);
-      setError(null);
-      try {
-        const result = await checkInService.checkIn({
-          branchId: params.branchId,
-          userId: params.userId,
-          entranceType: 1 /* EXIT */,
-          userLocation: location || void 0
-        });
-        if (result.success) {
-          return {
-            success: true,
-            data: result.entrance
-          };
-        }
-        return {
-          success: false,
-          error: result.message || "Check-out failed"
-        };
-      } catch (err) {
-        const error2 = err;
-        setError(error2);
-        return {
-          success: false,
-          error: error2.message || "Check-out failed"
-        };
-      } finally {
-        setIsLoading(false);
-      }
-    },
-    [checkInService, location]
-  );
-  return {
-    getNearbyBranches,
-    checkInEntry,
-    checkInExit,
-    isLoading,
-    error
-  };
-}
-
-// src/hooks/usePassgageRemoteWork.ts
-var import_react7 = require("react");
-function usePassgageRemoteWork() {
-  const { remoteWorkService } = usePassgageAccess();
-  const [isLoading, setIsLoading] = (0, import_react7.useState)(false);
-  const [error, setError] = (0, import_react7.useState)(null);
-  const logEntry = (0, import_react7.useCallback)(
-    async (params) => {
-      setIsLoading(true);
-      setError(null);
-      try {
-        const result = await remoteWorkService.logRemoteWork({
-          userId: params.userId,
-          entranceType: 0 /* ENTRY */,
-          timestamp: params.timestamp,
-          description: params.description
-        });
-        if (result.success) {
-          return {
-            success: true,
-            data: result.entrance
-          };
-        }
-        return {
-          success: false,
-          error: result.message || "Failed to log entry"
-        };
-      } catch (err) {
-        const error2 = err;
-        setError(error2);
-        return {
-          success: false,
-          error: error2.message || "Failed to log entry"
-        };
-      } finally {
-        setIsLoading(false);
-      }
-    },
-    [remoteWorkService]
-  );
-  const logExit = (0, import_react7.useCallback)(
-    async (params) => {
-      setIsLoading(true);
-      setError(null);
-      try {
-        const result = await remoteWorkService.logRemoteWork({
-          userId: params.userId,
-          entranceType: 1 /* EXIT */,
-          timestamp: params.timestamp,
-          description: params.description
-        });
-        if (result.success) {
-          return {
-            success: true,
-            data: result.entrance
-          };
-        }
-        return {
-          success: false,
-          error: result.message || "Failed to log exit"
-        };
-      } catch (err) {
-        const error2 = err;
-        setError(error2);
-        return {
-          success: false,
-          error: error2.message || "Failed to log exit"
-        };
-      } finally {
-        setIsLoading(false);
-      }
-    },
-    [remoteWorkService]
-  );
-  return {
-    logEntry,
-    logExit,
-    isLoading,
-    error
-  };
-}
-
 // src/index.ts
-var SDK_VERSION = "1.0.4";
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  ApiClient,
-  AuthService,
-  CheckInService,
-  DeviceAccessService,
-  DeviceDirection,
-  DeviceUsage,
-  Endpoints,
-  EntranceType,
-  LocationService,
-  NFCAccessService,
-  PassgageAccessProvider,
-  QRAccessService,
-  RemoteWorkService,
-  SDK_VERSION,
-  calculateDistance,
-  checkOnLocation,
-  checkRepetitiveRead,
-  clearReadRecords,
-  createApiClient,
-  formatDate,
-  formatDateTime,
-  formatISO,
-  formatTime,
-  parseISO,
-  useLocation,
-  usePassgageAccess,
-  usePassgageAuth,
-  usePassgageCheckIn,
-  usePassgageNFCScanner,
-  usePassgageQRScanner,
-  usePassgageRemoteWork,
-  validateCoordinates,
-  validateDeviceId,
-  validateNFCCode,
-  validateQRCode
-});
+var SDK_VERSION = "1.0.6";
+
+exports.ApiClient = ApiClient;
+exports.AuthService = AuthService;
+exports.DeviceAccessService = DeviceAccessService;
+exports.DeviceDirection = DeviceDirection;
+exports.DeviceUsage = DeviceUsage;
+exports.Endpoints = endpoints_exports;
+exports.EntranceType = EntranceType;
+exports.LocationService = LocationService;
+exports.NfcAccessService = NfcAccessService;
+exports.PassgageAccessProvider = PassgageAccessProvider;
+exports.QRAccessService = QRAccessService;
+exports.SDK_VERSION = SDK_VERSION;
+exports.addQrReadRecord = addQrReadRecord;
+exports.calculateDistance = calculateDistance;
+exports.checkOnLocation = checkOnLocation;
+exports.checkRepetitiveRead = checkRepetitiveRead;
+exports.clearReadRecords = clearReadRecords;
+exports.createApiClient = createApiClient;
+exports.formatDate = formatDate;
+exports.formatDateTime = formatDateTime;
+exports.formatISO = formatISO;
+exports.formatTime = formatTime;
+exports.locationStore = locationStore;
+exports.parseISO = parseISO;
+exports.qrScannerStore = qrScannerStore;
+exports.reversedHexToDec = reversedHexToDec;
+exports.shouldValidateLocation = shouldValidateLocation;
+exports.useAuthStore = useAuthStore;
+exports.useLocation = useLocation;
+exports.usePassgageAccessContext = usePassgageAccessContext;
+exports.usePassgageNFCScanner = usePassgageNFCScanner;
+exports.usePassgageQRScanner = usePassgageQRScanner;
+exports.validateCoordinates = validateCoordinates;
+exports.validateDeviceId = validateDeviceId;
+exports.validateLocation = validateLocation;
+exports.validateNFCCode = validateNFCCode;
+exports.validateQRCode = validateQRCode;