@passgage/sdk-react-native 1.0.1 → 1.0.3

package/dist/index.mjs

@@ -1,15 +1,1161 @@
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/api/client.ts
+import axios from "axios";
+var ApiClient = class {
+  constructor(config) {
+    this.isRefreshing = false;
+    this.refreshQueue = [];
+    this.config = {
+      timeout: 3e4,
+      apiVersion: "v2",
+      ...config
+    };
+    this.axiosInstance = axios.create({
+      baseURL: `${this.config.baseURL}/api/${this.config.apiVersion}`,
+      timeout: this.config.timeout,
+      headers: {
+        "Content-Type": "application/json",
+        Accept: "application/json",
+        ...this.config.headers
+      }
+    });
+    this.setupInterceptors();
+  }
+  /**
+   * Setup request and response interceptors
+   */
+  setupInterceptors() {
+    this.axiosInstance.interceptors.request.use(
+      (config) => {
+        const skipAuth = config.skipAuth;
+        if (this.config.token && !skipAuth) {
+          config.headers.Authorization = `Bearer ${this.config.token}`;
+        }
+        return config;
+      },
+      (error) => {
+        return Promise.reject(this.handleError(error));
+      }
+    );
+    this.axiosInstance.interceptors.response.use(
+      (response) => response,
+      async (error) => {
+        const originalRequest = error.config;
+        if (error.response?.status === 401 && originalRequest && !originalRequest._retry) {
+          const skipAuth = originalRequest.skipAuth;
+          if (skipAuth) {
+            return Promise.reject(this.handleError(error));
+          }
+          if (this.config.onTokenRefreshNeeded) {
+            originalRequest._retry = true;
+            const retryOriginalRequest = new Promise((resolve, reject) => {
+              this.refreshQueue.push({
+                config: originalRequest,
+                resolve,
+                reject
+              });
+            });
+            if (!this.isRefreshing) {
+              this.isRefreshing = true;
+              try {
+                const newToken = await this.config.onTokenRefreshNeeded();
+                if (newToken) {
+                  this.setToken(newToken);
+                  this.refreshQueue.forEach(({ config, resolve, reject }) => {
+                    if (config.headers) {
+                      config.headers.Authorization = `Bearer ${newToken}`;
+                    }
+                    this.axiosInstance.request(config).then(resolve).catch(reject);
+                  });
+                  this.refreshQueue = [];
+                } else {
+                  this.refreshQueue.forEach(({ reject }) => {
+                    reject(new Error("Token refresh failed"));
+                  });
+                  this.refreshQueue = [];
+                  if (this.config.onUnauthorized) {
+                    this.config.onUnauthorized();
+                  }
+                }
+              } catch (refreshError) {
+                this.refreshQueue.forEach(({ reject }) => {
+                  reject(refreshError);
+                });
+                this.refreshQueue = [];
+                if (this.config.onUnauthorized) {
+                  this.config.onUnauthorized();
+                }
+              } finally {
+                this.isRefreshing = false;
+              }
+            }
+            return retryOriginalRequest;
+          } else {
+            if (this.config.onUnauthorized) {
+              this.config.onUnauthorized();
+            }
+          }
+        }
+        const apiError = this.handleError(error);
+        if (this.config.onError) {
+          this.config.onError(apiError);
+        }
+        return Promise.reject(apiError);
+      }
+    );
+  }
+  /**
+   * Handle API errors
+   */
+  handleError(error) {
+    const responseData = error.response?.data;
+    const apiError = new Error(
+      responseData?.message || error.message || "An unknown error occurred"
+    );
+    apiError.code = error.code;
+    apiError.status = error.response?.status;
+    apiError.response = responseData;
+    return apiError;
+  }
+  /**
+   * Update authorization token
+   */
+  setToken(token) {
+    this.config.token = token || void 0;
+  }
+  /**
+   * Remove authorization token
+   */
+  clearToken() {
+    this.config.token = void 0;
+  }
+  /**
+   * Generic GET request
+   */
+  async get(options) {
+    const response = await this.axiosInstance.get(options.endpoint, {
+      params: options.params,
+      headers: options.headers,
+      ...options.config,
+      skipAuth: options.skipAuth
+    });
+    return response.data;
+  }
+  /**
+   * Generic POST request
+   */
+  async post(options) {
+    const response = await this.axiosInstance.post(
+      options.endpoint,
+      options.data,
+      {
+        params: options.params,
+        headers: options.headers,
+        ...options.config,
+        skipAuth: options.skipAuth
+      }
+    );
+    return response.data;
+  }
+  /**
+   * 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
+      }
+    );
+    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
+      }
+    );
+    return response.data;
+  }
+  /**
+   * Generic DELETE request
+   */
+  async delete(options) {
+    const response = await this.axiosInstance.delete(options.endpoint, {
+      params: options.params,
+      headers: options.headers,
+      ...options.config,
+      skipAuth: options.skipAuth
+    });
+    return response.data;
+  }
+};
+function createApiClient(config) {
+  return new ApiClient(config);
+}
+
+// src/api/endpoints.ts
+var endpoints_exports = {};
+__export(endpoints_exports, {
+  EP_BRANCHES: () => EP_BRANCHES,
+  EP_CREATE_QR: () => EP_CREATE_QR,
+  EP_DEVICES: () => EP_DEVICES,
+  EP_ENTRANCES: () => EP_ENTRANCES,
+  EP_LOCATION_VERIFICATION: () => EP_LOCATION_VERIFICATION,
+  EP_LOGIN: () => EP_LOGIN,
+  EP_ME: () => EP_ME,
+  EP_NFC_CHECK: () => EP_NFC_CHECK,
+  EP_QR_ACCESS: () => EP_QR_ACCESS,
+  EP_QR_CHECK: () => EP_QR_CHECK,
+  EP_QR_DEVICES: () => EP_QR_DEVICES,
+  EP_TOKEN: () => EP_TOKEN,
+  EP_TRIGGER_IOT: () => EP_TRIGGER_IOT,
+  EP_USERS: () => EP_USERS
+});
+var EP_LOGIN = "users/sign_in";
+var EP_TOKEN = "token";
+var EP_DEVICES = "devices";
+var EP_QR_DEVICES = "devices/qr_devices";
+var EP_QR_ACCESS = "qr_access/accessible_qrs";
+var EP_QR_CHECK = "qr_check";
+var EP_NFC_CHECK = "nfc_check";
+var EP_ENTRANCES = "entrances";
+var EP_CREATE_QR = "entrances/create_from_qr";
+var EP_BRANCHES = "branches";
+var EP_LOCATION_VERIFICATION = "location_verification_logs";
+var EP_TRIGGER_IOT = "iot/trigger";
+var EP_USERS = "users";
+var EP_ME = "users/lite_me";
+
+// src/models/common.ts
+var EntranceType = /* @__PURE__ */ ((EntranceType2) => {
+  EntranceType2[EntranceType2["ENTRY"] = 0] = "ENTRY";
+  EntranceType2[EntranceType2["EXIT"] = 1] = "EXIT";
+  return EntranceType2;
+})(EntranceType || {});
+var DeviceUsage = /* @__PURE__ */ ((DeviceUsage2) => {
+  DeviceUsage2["PDKS"] = "pdks";
+  DeviceUsage2["MEETING_ROOM"] = "meeting_room";
+  DeviceUsage2["FOOD"] = "food";
+  return DeviceUsage2;
+})(DeviceUsage || {});
+var DeviceDirection = /* @__PURE__ */ ((DeviceDirection2) => {
+  DeviceDirection2[DeviceDirection2["ENTRY"] = 0] = "ENTRY";
+  DeviceDirection2[DeviceDirection2["EXIT"] = 1] = "EXIT";
+  DeviceDirection2[DeviceDirection2["BIDIRECTIONAL"] = 2] = "BIDIRECTIONAL";
+  return 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;
+  }
+  /**
+   * Login with credentials
+   *
+   * @param credentials - User login credentials (email/phone and password)
+   * @returns Login result with tokens on success
+   *
+   * @example
+   * ```typescript
+   * const result = await authService.login({
+   *   login: 'user@example.com',
+   *   password: 'password123'
+   * });
+   *
+   * if (result.success) {
+   *   console.log('Access token:', result.tokens.access.token);
+   * } else {
+   *   console.error('Login failed:', result.error);
+   * }
+   * ```
+   */
+  async login(credentials) {
+    try {
+      const requestBody = {
+        user: {
+          login: credentials.login,
+          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
+      });
+      if (!response.success || !response.data?.tokens) {
+        return {
+          success: false,
+          error: response.message || "Login failed",
+          code: "LOGIN_FAILED"
+        };
+      }
+      const tokens = response.data.tokens;
+      if (this.tokenStorage) {
+        await this.tokenStorage.saveTokens(tokens);
+      }
+      this.apiClient.setToken(tokens.access.token);
+      let user;
+      try {
+        const userResult = await this.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);
+      }
+      return {
+        success: true,
+        tokens,
+        user
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error.message || "An error occurred during login",
+        code: error.code || "NETWORK_ERROR"
+      };
+    }
+  }
+  /**
+   * Refresh access token using refresh token
+   *
+   * @param refreshToken - The refresh token
+   * @returns Refresh result with new tokens on success
+   *
+   * @example
+   * ```typescript
+   * const result = await authService.refreshToken('refresh_token_here');
+   *
+   * if (result.success) {
+   *   console.log('New access token:', result.tokens.access.token);
+   * }
+   * ```
+   */
+  async refreshToken(refreshToken) {
+    try {
+      const requestBody = {
+        refresh_token: refreshToken
+      };
+      const response = await this.apiClient.post({
+        endpoint: "/token",
+        data: requestBody,
+        skipAuth: true
+      });
+      if (!response.success || !response.data?.token || !response.data?.refresh_token) {
+        return {
+          success: false,
+          error: response.message || "Token refresh failed",
+          code: "REFRESH_FAILED"
+        };
+      }
+      const tokens = {
+        access: {
+          token: response.data.token,
+          expiresIn: "30 days"
+        },
+        refresh: {
+          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
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error.message || "An error occurred during token refresh",
+        code: error.code || "NETWORK_ERROR"
+      };
+    }
+  }
+  /**
+   * Get current user information
+   *
+   * @returns Result with user information
+   *
+   * @example
+   * ```typescript
+   * const result = await authService.getCurrentUser();
+   *
+   * if (result.success) {
+   *   console.log('User name:', result.user.fullName);
+   * }
+   * ```
+   */
+  async getCurrentUser() {
+    try {
+      const response = await this.apiClient.get({
+        endpoint: "/api/v2/users/me"
+      });
+      if (!response.success || !response.data) {
+        return {
+          success: false,
+          error: response.message || "Failed to fetch user information"
+        };
+      }
+      const userData = response.data;
+      const user = {
+        id: userData.id,
+        email: userData.email,
+        firstName: userData.first_name,
+        lastName: userData.last_name,
+        company: {
+          id: userData.company.id,
+          name: userData.company.name
+        },
+        fullName: userData.full_name || `${userData.first_name} ${userData.last_name}`,
+        gsm: userData.gsm,
+        avatar: userData.avatar?.url,
+        jobTitle: userData.job_title,
+        birthDate: userData.birth_date,
+        cardNo: userData.card_no
+      };
+      return {
+        success: true,
+        user
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error.message || "Failed to fetch user information"
+      };
+    }
+  }
+  /**
+   * 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
+   */
+  async getStoredTokens() {
+    if (!this.tokenStorage) {
+      return null;
+    }
+    return await this.tokenStorage.getTokens();
+  }
+  /**
+   * Get stored user
+   *
+   * @returns Stored user or null
+   */
+  async getStoredUser() {
+    if (!this.tokenStorage) {
+      return null;
+    }
+    return await this.tokenStorage.getUser();
+  }
+};
+
+// 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);
+  const c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a));
+  return R * c;
+}
+function checkOnLocation(targetLat, targetLon, allowedRange, userPosition) {
+  if (!userPosition) {
+    return { ok: false };
+  }
+  const distance = calculateDistance(
+    targetLat,
+    targetLon,
+    userPosition.latitude,
+    userPosition.longitude
+  );
+  return {
+    ok: distance <= allowedRange,
+    distance
+  };
+}
+function validateCoordinates(coords) {
+  if (!coords) {
+    return false;
+  }
+  const { latitude, longitude } = coords;
+  return typeof latitude === "number" && typeof longitude === "number" && latitude >= -90 && latitude <= 90 && longitude >= -180 && longitude <= 180;
+}
+
+// src/utils/validation.ts
+var READ_TIMEOUT = 15e3;
+var readRecords = [];
+function checkRepetitiveRead(code) {
+  const now = Date.now();
+  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;
+}
+function clearReadRecords() {
+  readRecords = [];
+}
+function validateQRCode(code) {
+  return typeof code === "string" && code.length > 0;
+}
+function validateNFCCode(code) {
+  return typeof code === "string" && code.length > 0;
+}
+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);
+}
+
+// src/utils/date.ts
+function formatISO(date = /* @__PURE__ */ new Date()) {
+  return date.toISOString();
+}
+function formatDate(date = /* @__PURE__ */ new Date()) {
+  const year = date.getFullYear();
+  const month = String(date.getMonth() + 1).padStart(2, "0");
+  const day = String(date.getDate()).padStart(2, "0");
+  return `${year}-${month}-${day}`;
+}
+function formatTime(date = /* @__PURE__ */ new Date()) {
+  const hours = String(date.getHours()).padStart(2, "0");
+  const minutes = String(date.getMinutes()).padStart(2, "0");
+  return `${hours}:${minutes}`;
+}
+function formatDateTime(date = /* @__PURE__ */ new Date()) {
+  const dateStr = formatDate(date);
+  const timeStr = formatTime(date);
+  const seconds = String(date.getSeconds()).padStart(2, "0");
+  return `${dateStr} ${timeStr}:${seconds}`;
+}
+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)) {
+      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
+    };
+  }
+  /**
+   * Validate QR 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) {
+        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_QR_CHECK,
+        data: { qr_code: qrCode }
+      });
+      if (!response.success) {
+        return {
+          success: false,
+          message: response.message || "QR validation failed",
+          error: { code: "API_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" }
+      };
+    }
+  }
+  /**
+   * Create entrance from QR code
+   */
+  async createEntranceFromQR(request) {
+    return this.apiClient.post({
+      endpoint: EP_CREATE_QR,
+      data: request
+    });
+  }
+  /**
+   * Trigger IoT device
+   */
+  async triggerIoTDevice(deviceId) {
+    return this.apiClient.post({
+      endpoint: `${EP_TRIGGER_IOT}/${deviceId}`
+    });
+  }
+};
+
+// src/services/NFCAccessService.ts
+var NFCAccessService = class {
+  constructor(apiClient) {
+    this.apiClient = apiClient;
+  }
+  /**
+   * Validate NFC code format
+   */
+  validateNFCFormat(code) {
+    return validateNFCCode(code);
+  }
+  /**
+   * Check if location validation is required
+   */
+  shouldValidateLocation(device) {
+    return device.nfc_range_matter === "1" && !!device.latitude && !!device.longitude;
+  }
+  /**
+   * Validate user location against device location
+   */
+  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 }
+      }
+    });
+  }
+  /**
+   * Get device by ID
+   */
+  async getDeviceById(deviceId) {
+    return this.apiClient.get({
+      endpoint: `${EP_DEVICES}/${deviceId}`
+    });
+  }
+  /**
+   * Check if user has access to a device
+   */
+  async checkDeviceAccess(deviceId) {
+    try {
+      const response = await this.getAccessibleQRs();
+      if (!response.success || !response.data) {
+        return false;
+      }
+      return response.data.qr_ids.includes(deviceId);
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Find QR device by QR code ID
+   */
+  async findDeviceByQRCode(qrCodeId) {
+    try {
+      const devices = await this.getAllQRDevices();
+      return devices.find((device) => device.qr_code_id === qrCodeId);
+    } catch {
+      return void 0;
+    }
+  }
+  /**
+   * Find QR device by NFC code
+   */
+  async findDeviceByNFCCode(nfcCode) {
+    try {
+      const devices = await this.getAllQRDevices();
+      return devices.find((device) => device.nfc_code === nfcCode);
+    } catch {
+      return void 0;
+    }
+  }
+};
+
+// src/services/LocationService.ts
+var LocationService = class {
+  constructor(apiClient) {
+    this.apiClient = apiClient;
+  }
+  /**
+   * Log location verification
+   */
+  async logLocationVerification(log) {
+    return this.apiClient.post({
+      endpoint: EP_LOCATION_VERIFICATION,
+      data: { log }
+    });
+  }
+  /**
+   * Create location verification log for QR scan
+   */
+  async logQRScan(params) {
+    const log = {
+      mobileLatitude: params.mobileLocation.latitude,
+      mobileLongitude: params.mobileLocation.longitude,
+      accuracy: params.mobileLocation.accuracy,
+      altitude: params.mobileLocation.altitude,
+      qrLatitude: params.qrLocation?.latitude ?? -1,
+      qrLongitude: params.qrLocation?.longitude ?? -1,
+      currentScreen: params.currentScreen,
+      qr: params.qrCode,
+      errorCode: params.errorCode,
+      message: params.message,
+      navigation_step: "qr_scan_location",
+      isGps: true,
+      deviceRange: params.deviceRange || 0,
+      distance: params.distance,
+      additionalInfo: params.additionalInfo || "",
+      customData: params.customData
+    };
+    return this.logLocationVerification(log);
+  }
+  /**
+   * Create location verification log for NFC scan
+   */
+  async logNFCScan(params) {
+    const log = {
+      mobileLatitude: params.mobileLocation.latitude,
+      mobileLongitude: params.mobileLocation.longitude,
+      accuracy: params.mobileLocation.accuracy,
+      altitude: params.mobileLocation.altitude,
+      qrLatitude: params.nfcLocation?.latitude ?? -1,
+      qrLongitude: params.nfcLocation?.longitude ?? -1,
+      currentScreen: params.currentScreen,
+      qr: params.nfcCode,
+      errorCode: params.errorCode,
+      message: params.message,
+      navigation_step: "nfc_scan_location",
+      isGps: true,
+      deviceRange: params.deviceRange || 0,
+      distance: params.distance,
+      additionalInfo: params.additionalInfo || "",
+      customData: params.customData
+    };
+    return this.logLocationVerification(log);
+  }
+  /**
+   * Create location verification log for check-in
+   */
+  async logCheckIn(params) {
+    const log = {
+      mobileLatitude: params.mobileLocation.latitude,
+      mobileLongitude: params.mobileLocation.longitude,
+      accuracy: params.mobileLocation.accuracy,
+      altitude: params.mobileLocation.altitude,
+      qrLatitude: params.branchLocation?.latitude ?? -1,
+      qrLongitude: params.branchLocation?.longitude ?? -1,
+      currentScreen: params.currentScreen,
+      qr: "-",
+      errorCode: params.errorCode,
+      message: params.message,
+      navigation_step: "check_in",
+      isGps: true,
+      deviceRange: 0,
+      distance: params.distance,
+      additionalInfo: params.additionalInfo || "buraday\u0131m",
+      customData: params.customData
+    };
+    return this.logLocationVerification(log);
+  }
+};
+
 // src/providers/PassgageAccessProvider.tsx
 import React, { createContext, useContext, useMemo } from "react";
-import {
-  createApiClient,
-  AuthService,
-  QRAccessService,
-  NFCAccessService,
-  CheckInService,
-  RemoteWorkService,
-  DeviceAccessService,
-  LocationService
-} from "@passgage/sdk-core";
 
 // src/utils/secureStorage.ts
 import * as Keychain from "react-native-keychain";
@@ -344,7 +1490,7 @@ function usePassgageAuth(options = {}) {
   };
 }
 
-// src/hooks/useQRScanner.ts
+// src/hooks/usePassgageQRScanner.ts
 import { useState as useState3, useCallback as useCallback3 } from "react";
 
 // src/hooks/useLocation.ts
@@ -420,8 +1566,8 @@ function useLocation(options = {}) {
   };
 }
 
-// src/hooks/useQRScanner.ts
-function useQRScanner(options = {}) {
+// src/hooks/usePassgageQRScanner.ts
+function usePassgageQRScanner(options = {}) {
   const { qrAccessService, deviceAccessService } = usePassgageAccess();
   const { location } = useLocation();
   const [isLoading, setIsLoading] = useState3(false);
@@ -466,14 +1612,14 @@ function useQRScanner(options = {}) {
   };
 }
 
-// src/hooks/useNFCScanner.ts
+// src/hooks/usePassgageNFCScanner.ts
 import { useState as useState4, useCallback as useCallback4, useEffect as useEffect3 } from "react";
 import NfcManager, { NfcTech } from "react-native-nfc-manager";
 function reversedHexToDec(hexString) {
   const hex = hexString.replace(/:/g, "");
   return parseInt(hex, 16).toString();
 }
-function useNFCScanner(options = {}) {
+function usePassgageNFCScanner(options = {}) {
   const { nfcAccessService, deviceAccessService } = usePassgageAccess();
   const { location } = useLocation();
   const [isScanning, setIsScanning] = useState4(false);
@@ -549,137 +1695,247 @@ function useNFCScanner(options = {}) {
   };
 }
 
-// src/hooks/useCheckIn.ts
-import { useState as useState5, useEffect as useEffect4, useCallback as useCallback5 } from "react";
-function useCheckIn(options = {}) {
-  const { checkInService, config: _config } = usePassgageAccess();
+// src/hooks/usePassgageCheckIn.ts
+import { useState as useState5, useCallback as useCallback5 } from "react";
+function usePassgageCheckIn(options = {}) {
+  const { checkInService } = usePassgageAccess();
   const { location } = useLocation();
-  const [nearbyBranches, setNearbyBranches] = useState5([]);
   const [isLoading, setIsLoading] = useState5(false);
   const [error, setError] = useState5(null);
-  const fetchNearbyBranches = useCallback5(async () => {
-    if (!location) {
-      return;
-    }
-    setIsLoading(true);
-    setError(null);
-    try {
-      const response = await checkInService.getNearbyBranches({
-        latitude: location.latitude,
-        longitude: location.longitude,
-        radius: options.radius
-      });
-      if (response.success && response.data) {
-        setNearbyBranches(response.data);
+  const getNearbyBranches = useCallback5(
+    async (params) => {
+      if (!location) {
+        return {
+          success: false,
+          error: "Location not available"
+        };
       }
-    } catch (err) {
-      setError(err);
-    } finally {
-      setIsLoading(false);
-    }
-  }, [checkInService, location, options.radius]);
-  const checkIn = useCallback5(
+      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 = useCallback5(
     async (params) => {
       setIsLoading(true);
       setError(null);
       try {
-        const userId = "";
         const result = await checkInService.checkIn({
-          ...params,
-          userId,
+          branchId: params.branchId,
+          userId: params.userId,
+          entranceType: 0 /* ENTRY */,
           userLocation: location || void 0
         });
-        if (!result.success) {
-          throw new Error(result.message);
+        if (result.success) {
+          return {
+            success: true,
+            data: result.entrance
+          };
         }
-        return result.entrance;
+        return {
+          success: false,
+          error: result.message || "Check-in failed"
+        };
       } catch (err) {
-        setError(err);
-        throw err;
+        const error2 = err;
+        setError(error2);
+        return {
+          success: false,
+          error: error2.message || "Check-in failed"
+        };
+      } finally {
+        setIsLoading(false);
+      }
+    },
+    [checkInService, location]
+  );
+  const checkInExit = useCallback5(
+    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]
   );
-  useEffect4(() => {
-    if (options.autoFetch && location) {
-      fetchNearbyBranches();
-    }
-  }, [options.autoFetch, location, fetchNearbyBranches]);
   return {
-    nearbyBranches,
-    fetchNearbyBranches,
-    checkIn,
+    getNearbyBranches,
+    checkInEntry,
+    checkInExit,
     isLoading,
     error
   };
 }
 
-// src/hooks/useRemoteWork.ts
+// src/hooks/usePassgageRemoteWork.ts
 import { useState as useState6, useCallback as useCallback6 } from "react";
-import { EntranceType } from "@passgage/sdk-core";
-function useRemoteWork() {
+function usePassgageRemoteWork() {
   const { remoteWorkService } = usePassgageAccess();
   const [isLoading, setIsLoading] = useState6(false);
   const [error, setError] = useState6(null);
-  const logRemoteWork = useCallback6(
-    async (entranceType, options = {}) => {
+  const logEntry = useCallback6(
+    async (params) => {
       setIsLoading(true);
       setError(null);
       try {
-        const userId = "";
         const result = await remoteWorkService.logRemoteWork({
-          userId,
-          entranceType,
-          timestamp: options.timestamp,
-          description: options.description
+          userId: params.userId,
+          entranceType: 0 /* ENTRY */,
+          timestamp: params.timestamp,
+          description: params.description
         });
-        if (!result.success) {
-          throw new Error(result.message);
+        if (result.success) {
+          return {
+            success: true,
+            data: result.entrance
+          };
         }
-        return result.entrance;
+        return {
+          success: false,
+          error: result.message || "Failed to log entry"
+        };
       } catch (err) {
         const error2 = err;
         setError(error2);
-        throw error2;
+        return {
+          success: false,
+          error: error2.message || "Failed to log entry"
+        };
       } finally {
         setIsLoading(false);
       }
     },
     [remoteWorkService]
   );
-  const logEntry = useCallback6(
-    async (options) => {
-      return logRemoteWork(EntranceType.ENTRY, options);
-    },
-    [logRemoteWork]
-  );
   const logExit = useCallback6(
-    async (options) => {
-      return logRemoteWork(EntranceType.EXIT, options);
+    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);
+      }
     },
-    [logRemoteWork]
+    [remoteWorkService]
   );
   return {
     logEntry,
     logExit,
-    logRemoteWork,
     isLoading,
     error
   };
 }
 
-// src/index.tsx
-var SDK_VERSION = "1.0.0";
+// src/index.ts
+var SDK_VERSION = "1.0.3";
 export {
+  ApiClient,
+  AuthService,
+  CheckInService,
+  DeviceAccessService,
+  DeviceDirection,
+  DeviceUsage,
+  endpoints_exports as Endpoints,
+  EntranceType,
+  LocationService,
+  NFCAccessService,
   PassgageAccessProvider,
+  QRAccessService,
+  RemoteWorkService,
   SDK_VERSION,
-  useCheckIn,
+  calculateDistance,
+  checkOnLocation,
+  checkRepetitiveRead,
+  clearReadRecords,
+  createApiClient,
+  formatDate,
+  formatDateTime,
+  formatISO,
+  formatTime,
+  parseISO,
   useLocation,
-  useNFCScanner,
   usePassgageAccess,
   usePassgageAuth,
-  useQRScanner,
-  useRemoteWork
+  usePassgageCheckIn,
+  usePassgageNFCScanner,
+  usePassgageQRScanner,
+  usePassgageRemoteWork,
+  validateCoordinates,
+  validateDeviceId,
+  validateNFCCode,
+  validateQRCode
 };