@passgage/sdk-react-native 1.0.1 → 1.0.3

package/dist/index.d.mts

@@ -1,6 +1,994 @@
+import { AxiosRequestConfig } from 'axios';
 import React, { ReactNode } from 'react';
-import { ApiClient, AuthService, QRAccessService, NFCAccessService, CheckInService, RemoteWorkService, DeviceAccessService, LocationService, User, LoginCredentials, LoginResult, Entrance, QrDevice, EntranceType, Branch, Coordinates } from '@passgage/sdk-core';
-export { BaseResponse, Branch, Coordinates, Device, Entrance, EntranceType, QrDevice } from '@passgage/sdk-core';
+
+/**
+ * Common types and interfaces used across the SDK
+ */
+interface BaseResponse<T = unknown> {
+    success: boolean;
+    status: number;
+    message: string;
+    data?: T;
+    meta?: PaginationMeta;
+    errors?: Record<string, string[]>;
+}
+interface PaginationMeta {
+    current_page: number;
+    total_pages: number;
+    total_count: number;
+    per_page: number;
+}
+interface Coordinates {
+    latitude: number;
+    longitude: number;
+    accuracy?: number;
+    altitude?: number;
+    altitudeAccuracy?: number;
+    heading?: number;
+    speed?: number;
+}
+interface LocationVerificationLog {
+    mobileLatitude: number;
+    mobileLongitude: number;
+    currentScreen: string;
+    qrLatitude: number;
+    qrLongitude: number;
+    message: string;
+    navigation_step: string;
+    errorCode: string;
+    additionalInfo: string;
+    qr: string;
+    accuracy?: number;
+    altitude?: number;
+    isGps: boolean;
+    deviceRange: number;
+    distance?: number;
+    reduxPosition?: string;
+    customData?: Record<string, unknown>;
+}
+declare enum EntranceType {
+    ENTRY = 0,
+    EXIT = 1
+}
+declare enum DeviceUsage {
+    PDKS = "pdks",
+    MEETING_ROOM = "meeting_room",
+    FOOD = "food"
+}
+declare enum DeviceDirection {
+    ENTRY = 0,
+    EXIT = 1,
+    BIDIRECTIONAL = 2
+}
+interface APIError extends Error {
+    code?: string;
+    status?: number;
+    response?: BaseResponse;
+}
+
+/**
+ * Device-related types and interfaces
+ */
+
+interface Device {
+    id: string;
+    name: string;
+    description?: string;
+    ip?: string;
+    device_type?: string;
+    device_usage?: DeviceUsage;
+    direction?: DeviceDirection;
+    branch_id?: string;
+    company_id: string;
+    is_active: boolean;
+    is_remote_work?: boolean;
+    anti_passback_enabled?: boolean;
+    created_at: string;
+    updated_at: string;
+}
+interface QrDevice {
+    id: string;
+    qr_code_id: string;
+    nfc_code?: string;
+    name: string;
+    description?: string;
+    latitude?: number;
+    longitude?: number;
+    range?: number;
+    nfc_range?: number;
+    range_matter?: '0' | '1';
+    nfc_range_matter?: '0' | '1';
+    company_id: string;
+    branch_id?: string;
+    is_active: boolean;
+    device_type?: string;
+    created_at: string;
+    updated_at: string;
+}
+interface DeviceAccessRequest {
+    userId?: string;
+    page?: number;
+    per_page?: number;
+}
+interface QrAccessResponse {
+    qr_ids: string[];
+}
+
+/**
+ * Entrance-related types and interfaces
+ */
+
+interface Entrance {
+    id: string;
+    user_id: string;
+    device_id: string;
+    branch_id?: string;
+    building_id?: string;
+    zone_id?: string;
+    company_id: string;
+    entrance_type: EntranceType;
+    description?: string;
+    is_manual_recording?: boolean;
+    is_remote_work?: boolean;
+    service_id?: string;
+    log_date?: string;
+    log_date_time?: string;
+    created_at: string;
+    updated_at: string;
+}
+interface CreateEntranceRequest {
+    user_id: string;
+    device_id?: string;
+    branch_id?: string;
+    building_id?: string;
+    zone_id?: string;
+    entrance_type: EntranceType;
+    description?: string;
+    is_manual_recording?: boolean;
+    is_remote_work?: boolean;
+    service_id?: string;
+    created_at?: string;
+    log_date?: string;
+    log_date_time?: string;
+}
+interface CreateEntranceFromQRRequest {
+    device_id: string;
+    created_at?: string;
+    service_id?: string;
+}
+interface EntranceQueryParams {
+    user_id?: string;
+    device_id?: string;
+    entrance_type?: EntranceType;
+    created_at_gteq?: string;
+    created_at_lteq?: string;
+    page?: number;
+    per_page?: number;
+}
+
+/**
+ * Branch-related types and interfaces
+ */
+interface Branch {
+    id: string;
+    title: string;
+    name?: string;
+    address?: string;
+    city?: string;
+    country?: string;
+    latitude?: number;
+    longitude?: number;
+    distance?: number | null;
+    company_id: string;
+    is_active: boolean;
+    created_at: string;
+    updated_at: string;
+}
+interface NearbyBranchesRequest {
+    latitude: number;
+    longitude: number;
+    radius?: number;
+}
+
+/**
+ * Authentication Models
+ */
+/**
+ * Login credentials
+ */
+interface LoginCredentials {
+    /** Email or phone number */
+    login: string;
+    /** User password */
+    password: string;
+}
+/**
+ * Token information
+ */
+interface TokenInfo {
+    /** JWT token string */
+    token: string;
+    /** Token expiration time (e.g., "30 days from now") */
+    expiresIn: string;
+}
+/**
+ * Authentication tokens (access and refresh)
+ */
+interface AuthTokens {
+    /** Access token for API requests */
+    access: TokenInfo;
+    /** Refresh token for getting new access tokens */
+    refresh: TokenInfo;
+}
+/**
+ * Company information
+ */
+interface CompanyInfo {
+    /** Company ID */
+    id: string;
+    /** Company name */
+    name: string;
+}
+/**
+ * User information
+ */
+interface User {
+    /** User ID */
+    id: string;
+    /** User email */
+    email: string;
+    /** User first name */
+    firstName: string;
+    /** User last name */
+    lastName: string;
+    /** User's company */
+    company: CompanyInfo;
+    /** Full name (computed) */
+    fullName?: string;
+    /** User's phone number */
+    gsm?: string;
+    /** Avatar URL */
+    avatar?: string | null;
+    /** Job title */
+    jobTitle?: string | null;
+    /** Birth date */
+    birthDate?: string | null;
+    /** Card number */
+    cardNo?: string | null;
+}
+/**
+ * Login request payload
+ */
+interface LoginRequest {
+    user: {
+        login: string;
+        password: string;
+    };
+}
+/**
+ * Login response data from API
+ */
+interface LoginResponse {
+    tokens: AuthTokens;
+}
+/**
+ * Token refresh request payload
+ */
+interface RefreshTokenRequest {
+    token?: string;
+    refresh_token?: string;
+}
+/**
+ * Token refresh response data from API
+ */
+interface RefreshTokenResponse {
+    token?: string;
+    refresh_token?: string;
+}
+/**
+ * Login result (success or error)
+ */
+type LoginResult = {
+    success: true;
+    tokens: AuthTokens;
+    user?: User;
+} | {
+    success: false;
+    error: string;
+    code?: string;
+};
+/**
+ * Refresh token result (success or error)
+ */
+type RefreshTokenResult = {
+    success: true;
+    tokens: AuthTokens;
+} | {
+    success: false;
+    error: string;
+    code?: string;
+};
+/**
+ * Auth state
+ */
+interface AuthState {
+    /** Whether user is authenticated */
+    isAuthenticated: boolean;
+    /** Current user information */
+    user: User | null;
+    /** Current access token */
+    accessToken: string | null;
+    /** Current refresh token */
+    refreshToken: string | null;
+}
+/**
+ * Token storage interface for platform-specific implementations
+ */
+interface TokenStorage {
+    /**
+     * Save tokens to secure storage
+     */
+    saveTokens(tokens: AuthTokens): Promise<void>;
+    /**
+     * Get tokens from secure storage
+     */
+    getTokens(): Promise<AuthTokens | null>;
+    /**
+     * Clear tokens from secure storage
+     */
+    clearTokens(): Promise<void>;
+    /**
+     * Save user information
+     */
+    saveUser(user: User): Promise<void>;
+    /**
+     * Get user information
+     */
+    getUser(): Promise<User | null>;
+    /**
+     * Clear user information
+     */
+    clearUser(): Promise<void>;
+}
+
+/**
+ * API Client implementation using Axios
+ */
+
+interface ApiClientConfig {
+    baseURL: string;
+    token?: string;
+    timeout?: number;
+    apiVersion?: string;
+    headers?: Record<string, string>;
+    onUnauthorized?: () => void;
+    onError?: (error: APIError) => void;
+    /**
+     * Callback to refresh token when 401 is received
+     * Should return new access token or null if refresh failed
+     */
+    onTokenRefreshNeeded?: () => Promise<string | null>;
+}
+interface RequestOptions<T = unknown> {
+    endpoint: string;
+    method?: 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
+    data?: T;
+    params?: Record<string, unknown>;
+    headers?: Record<string, string>;
+    config?: AxiosRequestConfig;
+    skipAuth?: boolean;
+}
+declare class ApiClient {
+    private axiosInstance;
+    private config;
+    private isRefreshing;
+    private refreshQueue;
+    constructor(config: ApiClientConfig);
+    /**
+     * Setup request and response interceptors
+     */
+    private setupInterceptors;
+    /**
+     * Handle API errors
+     */
+    private handleError;
+    /**
+     * Update authorization token
+     */
+    setToken(token: string | null): void;
+    /**
+     * Remove authorization token
+     */
+    clearToken(): void;
+    /**
+     * Generic GET request
+     */
+    get<T = unknown>(options: Omit<RequestOptions, 'method' | 'data'>): Promise<BaseResponse<T>>;
+    /**
+     * Generic POST request
+     */
+    post<T = unknown, R = unknown>(options: Omit<RequestOptions<T>, 'method'>): Promise<BaseResponse<R>>;
+    /**
+     * Generic PUT request
+     */
+    put<T = unknown, R = unknown>(options: Omit<RequestOptions<T>, 'method'>): Promise<BaseResponse<R>>;
+    /**
+     * Generic PATCH request
+     */
+    patch<T = unknown, R = unknown>(options: Omit<RequestOptions<T>, 'method'>): Promise<BaseResponse<R>>;
+    /**
+     * Generic DELETE request
+     */
+    delete<T = unknown>(options: Omit<RequestOptions, 'method' | 'data'>): Promise<BaseResponse<T>>;
+}
+/**
+ * Factory function to create API client instance
+ */
+declare function createApiClient(config: ApiClientConfig): ApiClient;
+
+/**
+ * API endpoint constants
+ */
+declare const EP_LOGIN = "users/sign_in";
+declare const EP_TOKEN = "token";
+declare const EP_DEVICES = "devices";
+declare const EP_QR_DEVICES = "devices/qr_devices";
+declare const EP_QR_ACCESS = "qr_access/accessible_qrs";
+declare const EP_QR_CHECK = "qr_check";
+declare const EP_NFC_CHECK = "nfc_check";
+declare const EP_ENTRANCES = "entrances";
+declare const EP_CREATE_QR = "entrances/create_from_qr";
+declare const EP_BRANCHES = "branches";
+declare const EP_LOCATION_VERIFICATION = "location_verification_logs";
+declare const EP_TRIGGER_IOT = "iot/trigger";
+declare const EP_USERS = "users";
+declare const EP_ME = "users/lite_me";
+
+declare const endpoints_EP_BRANCHES: typeof EP_BRANCHES;
+declare const endpoints_EP_CREATE_QR: typeof EP_CREATE_QR;
+declare const endpoints_EP_DEVICES: typeof EP_DEVICES;
+declare const endpoints_EP_ENTRANCES: typeof EP_ENTRANCES;
+declare const endpoints_EP_LOCATION_VERIFICATION: typeof EP_LOCATION_VERIFICATION;
+declare const endpoints_EP_LOGIN: typeof EP_LOGIN;
+declare const endpoints_EP_ME: typeof EP_ME;
+declare const endpoints_EP_NFC_CHECK: typeof EP_NFC_CHECK;
+declare const endpoints_EP_QR_ACCESS: typeof EP_QR_ACCESS;
+declare const endpoints_EP_QR_CHECK: typeof EP_QR_CHECK;
+declare const endpoints_EP_QR_DEVICES: typeof EP_QR_DEVICES;
+declare const endpoints_EP_TOKEN: typeof EP_TOKEN;
+declare const endpoints_EP_TRIGGER_IOT: typeof EP_TRIGGER_IOT;
+declare const endpoints_EP_USERS: typeof EP_USERS;
+declare namespace endpoints {
+  export { endpoints_EP_BRANCHES as EP_BRANCHES, endpoints_EP_CREATE_QR as EP_CREATE_QR, endpoints_EP_DEVICES as EP_DEVICES, endpoints_EP_ENTRANCES as EP_ENTRANCES, endpoints_EP_LOCATION_VERIFICATION as EP_LOCATION_VERIFICATION, endpoints_EP_LOGIN as EP_LOGIN, endpoints_EP_ME as EP_ME, endpoints_EP_NFC_CHECK as EP_NFC_CHECK, endpoints_EP_QR_ACCESS as EP_QR_ACCESS, endpoints_EP_QR_CHECK as EP_QR_CHECK, endpoints_EP_QR_DEVICES as EP_QR_DEVICES, endpoints_EP_TOKEN as EP_TOKEN, endpoints_EP_TRIGGER_IOT as EP_TRIGGER_IOT, endpoints_EP_USERS as EP_USERS };
+}
+
+/**
+ * Authentication Service
+ *
+ * Handles user authentication, token management, and user information retrieval.
+ */
+
+/**
+ * Authentication Service
+ *
+ * Provides methods for user authentication and token management.
+ *
+ * @example
+ * ```typescript
+ * const authService = new AuthService(apiClient);
+ *
+ * // Login
+ * const result = await authService.login({
+ *   login: 'user@example.com',
+ *   password: 'password123'
+ * });
+ *
+ * if (result.success) {
+ *   console.log('Logged in:', result.tokens);
+ * }
+ * ```
+ */
+declare class AuthService {
+    private apiClient;
+    private tokenStorage?;
+    constructor(apiClient: ApiClient);
+    /**
+     * Set token storage implementation
+     * This is used by platform-specific implementations (React Native, Android, iOS)
+     */
+    setTokenStorage(storage: TokenStorage): void;
+    /**
+     * 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);
+     * }
+     * ```
+     */
+    login(credentials: LoginCredentials): Promise<LoginResult>;
+    /**
+     * 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);
+     * }
+     * ```
+     */
+    refreshToken(refreshToken: string): Promise<RefreshTokenResult>;
+    /**
+     * 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);
+     * }
+     * ```
+     */
+    getCurrentUser(): Promise<{
+        success: true;
+        user: User;
+    } | {
+        success: false;
+        error: string;
+    }>;
+    /**
+     * Logout current user
+     * Clears tokens from storage and API client
+     *
+     * @example
+     * ```typescript
+     * await authService.logout();
+     * console.log('User logged out');
+     * ```
+     */
+    logout(): Promise<void>;
+    /**
+     * Check if user is authenticated
+     *
+     * @returns True if user has valid tokens
+     */
+    isAuthenticated(): Promise<boolean>;
+    /**
+     * Get stored tokens
+     *
+     * @returns Stored tokens or null
+     */
+    getStoredTokens(): Promise<AuthTokens | null>;
+    /**
+     * Get stored user
+     *
+     * @returns Stored user or null
+     */
+    getStoredUser(): Promise<User | null>;
+}
+
+/**
+ * QR Access Service
+ * Handles QR code validation and entrance creation
+ */
+
+interface QRValidationOptions {
+    qrCode: string;
+    device: QrDevice;
+    userLocation?: Coordinates;
+    skipLocationCheck?: boolean;
+    skipRepetitiveCheck?: boolean;
+}
+interface QRValidationResult {
+    success: boolean;
+    message: string;
+    entrance?: Entrance;
+    error?: {
+        code: string;
+        details?: string;
+    };
+}
+declare class QRAccessService {
+    private apiClient;
+    constructor(apiClient: ApiClient);
+    /**
+     * Validate QR code format
+     */
+    private validateQRFormat;
+    /**
+     * Check if location validation is required
+     */
+    private shouldValidateLocation;
+    /**
+     * Validate user location against device location
+     */
+    private validateLocation;
+    /**
+     * Validate QR code with full checks
+     */
+    validateQR(options: QRValidationOptions): Promise<QRValidationResult>;
+    /**
+     * Create entrance from QR code
+     */
+    createEntranceFromQR(request: CreateEntranceFromQRRequest): Promise<BaseResponse<Entrance>>;
+    /**
+     * Trigger IoT device
+     */
+    triggerIoTDevice(deviceId: string): Promise<BaseResponse>;
+}
+
+/**
+ * NFC Access Service
+ * Handles NFC code validation and entrance creation
+ */
+
+interface NFCValidationOptions {
+    nfcCode: string;
+    device: QrDevice;
+    userLocation?: Coordinates;
+    skipLocationCheck?: boolean;
+    skipRepetitiveCheck?: boolean;
+}
+interface NFCValidationResult {
+    success: boolean;
+    message: string;
+    entrance?: Entrance;
+    error?: {
+        code: string;
+        details?: string;
+    };
+}
+declare class NFCAccessService {
+    private apiClient;
+    constructor(apiClient: ApiClient);
+    /**
+     * Validate NFC code format
+     */
+    private validateNFCFormat;
+    /**
+     * Check if location validation is required
+     */
+    private shouldValidateLocation;
+    /**
+     * Validate user location against device location
+     */
+    private validateLocation;
+    /**
+     * Validate NFC code with full checks
+     */
+    validateNFC(options: NFCValidationOptions): Promise<NFCValidationResult>;
+}
+
+/**
+ * Check-In Service
+ * Handles GPS-based check-in to nearby branches
+ */
+
+interface CheckInOptions {
+    branchId: string;
+    entranceType: EntranceType;
+    userId: string;
+    userLocation?: Coordinates;
+}
+interface CheckInResult {
+    success: boolean;
+    message: string;
+    entrance?: Entrance;
+    error?: {
+        code: string;
+        details?: string;
+    };
+}
+declare class CheckInService {
+    private apiClient;
+    constructor(apiClient: ApiClient);
+    /**
+     * Get nearby branches based on user location
+     */
+    getNearbyBranches(request: NearbyBranchesRequest): Promise<BaseResponse<Branch[]>>;
+    /**
+     * Check in to a branch
+     */
+    checkIn(options: CheckInOptions): Promise<CheckInResult>;
+    /**
+     * Get branch by ID
+     */
+    getBranchById(branchId: string): Promise<BaseResponse<Branch>>;
+    /**
+     * Get all branches (with pagination)
+     */
+    getAllBranches(params?: {
+        page?: number;
+        per_page?: number;
+    }): Promise<BaseResponse<Branch[]>>;
+}
+
+/**
+ * Remote Work Service
+ * Handles remote work entry and exit logging
+ */
+
+interface RemoteWorkEntryOptions {
+    userId: string;
+    entranceType: EntranceType;
+    timestamp?: Date | string;
+    description?: string;
+}
+interface RemoteWorkResult {
+    success: boolean;
+    message: string;
+    entrance?: Entrance;
+    error?: {
+        code: string;
+        details?: string;
+    };
+}
+declare class RemoteWorkService {
+    private apiClient;
+    constructor(apiClient: ApiClient);
+    /**
+     * Log remote work entry or exit
+     */
+    logRemoteWork(options: RemoteWorkEntryOptions): Promise<RemoteWorkResult>;
+    /**
+     * Log remote work entry
+     */
+    logEntry(options: Omit<RemoteWorkEntryOptions, 'entranceType'>): Promise<RemoteWorkResult>;
+    /**
+     * Log remote work exit
+     */
+    logExit(options: Omit<RemoteWorkEntryOptions, 'entranceType'>): Promise<RemoteWorkResult>;
+}
+
+/**
+ * Device Access Service
+ * Handles device access control and management
+ */
+
+declare class DeviceAccessService {
+    private apiClient;
+    constructor(apiClient: ApiClient);
+    /**
+     * Get all devices
+     */
+    getDevices(params?: {
+        page?: number;
+        per_page?: number;
+    }): Promise<BaseResponse<Device[]>>;
+    /**
+     * Get all QR devices
+     */
+    getQRDevices(params?: {
+        page?: number;
+        per_page?: number;
+    }): Promise<BaseResponse<QrDevice[]>>;
+    /**
+     * Get all QR devices with pagination support
+     */
+    getAllQRDevices(): Promise<QrDevice[]>;
+    /**
+     * Get accessible QR codes for current user
+     */
+    getAccessibleQRs(): Promise<BaseResponse<QrAccessResponse>>;
+    /**
+     * Get user devices
+     */
+    getUserDevices(request: DeviceAccessRequest): Promise<BaseResponse<Device[]>>;
+    /**
+     * Get device by ID
+     */
+    getDeviceById(deviceId: string): Promise<BaseResponse<Device>>;
+    /**
+     * Check if user has access to a device
+     */
+    checkDeviceAccess(deviceId: string): Promise<boolean>;
+    /**
+     * Find QR device by QR code ID
+     */
+    findDeviceByQRCode(qrCodeId: string): Promise<QrDevice | undefined>;
+    /**
+     * Find QR device by NFC code
+     */
+    findDeviceByNFCCode(nfcCode: string): Promise<QrDevice | undefined>;
+}
+
+/**
+ * Location Service
+ * Handles location verification and logging
+ */
+
+declare class LocationService {
+    private apiClient;
+    constructor(apiClient: ApiClient);
+    /**
+     * Log location verification
+     */
+    logLocationVerification(log: LocationVerificationLog): Promise<BaseResponse>;
+    /**
+     * Create location verification log for QR scan
+     */
+    logQRScan(params: {
+        mobileLocation: {
+            latitude: number;
+            longitude: number;
+            accuracy?: number;
+            altitude?: number;
+        };
+        qrLocation?: {
+            latitude: number;
+            longitude: number;
+        };
+        currentScreen: string;
+        qrCode: string;
+        errorCode: string;
+        message: string;
+        distance?: number;
+        deviceRange?: number;
+        additionalInfo?: string;
+        customData?: Record<string, unknown>;
+    }): Promise<BaseResponse>;
+    /**
+     * Create location verification log for NFC scan
+     */
+    logNFCScan(params: {
+        mobileLocation: {
+            latitude: number;
+            longitude: number;
+            accuracy?: number;
+            altitude?: number;
+        };
+        nfcLocation?: {
+            latitude: number;
+            longitude: number;
+        };
+        currentScreen: string;
+        nfcCode: string;
+        errorCode: string;
+        message: string;
+        distance?: number;
+        deviceRange?: number;
+        additionalInfo?: string;
+        customData?: Record<string, unknown>;
+    }): Promise<BaseResponse>;
+    /**
+     * Create location verification log for check-in
+     */
+    logCheckIn(params: {
+        mobileLocation: {
+            latitude: number;
+            longitude: number;
+            accuracy?: number;
+            altitude?: number;
+        };
+        branchLocation?: {
+            latitude: number;
+            longitude: number;
+        };
+        currentScreen: string;
+        errorCode: string;
+        message: string;
+        distance?: number;
+        additionalInfo?: string;
+        customData?: Record<string, unknown>;
+    }): Promise<BaseResponse>;
+}
+
+/**
+ * Location utility functions
+ */
+
+/**
+ * Calculate distance between two coordinates using Haversine formula
+ * @param lat1 - Latitude of first point
+ * @param lon1 - Longitude of first point
+ * @param lat2 - Latitude of second point
+ * @param lon2 - Longitude of second point
+ * @returns Distance in meters
+ */
+declare function calculateDistance(lat1: number, lon1: number, lat2: number, lon2: number): number;
+/**
+ * Check if user is within allowed range of a location
+ * @param targetLat - Target location latitude
+ * @param targetLon - Target location longitude
+ * @param allowedRange - Allowed range in meters
+ * @param userPosition - User's current position
+ * @returns Object with ok status and distance
+ */
+declare function checkOnLocation(targetLat: number, targetLon: number, allowedRange: number, userPosition?: Coordinates): {
+    ok: boolean;
+    distance?: number;
+};
+/**
+ * Validate coordinates
+ * @param coords - Coordinates to validate
+ * @returns true if coordinates are valid
+ */
+declare function validateCoordinates(coords?: Coordinates): boolean;
+
+/**
+ * Validation utility functions
+ */
+/**
+ * Check if a code was recently read (within 15 seconds)
+ * @param code - Code to check
+ * @returns true if this is a new read, false if repetitive
+ */
+declare function checkRepetitiveRead(code: string): boolean;
+/**
+ * Clear all read records
+ */
+declare function clearReadRecords(): void;
+/**
+ * Validate QR code format
+ * @param code - QR code to validate
+ * @returns true if valid
+ */
+declare function validateQRCode(code: string): boolean;
+/**
+ * Validate NFC code format
+ * @param code - NFC code to validate
+ * @returns true if valid
+ */
+declare function validateNFCCode(code: string): boolean;
+/**
+ * Validate device ID format (UUID)
+ * @param id - Device ID to validate
+ * @returns true if valid UUID
+ */
+declare function validateDeviceId(id: string): boolean;
+
+/**
+ * Date utility functions
+ */
+/**
+ * Format date to ISO string
+ * @param date - Date to format
+ * @returns ISO string
+ */
+declare function formatISO(date?: Date): string;
+/**
+ * Format date for API (YYYY-MM-DD)
+ * @param date - Date to format
+ * @returns Formatted date string
+ */
+declare function formatDate(date?: Date): string;
+/**
+ * Format time for API (HH:mm)
+ * @param date - Date to format
+ * @returns Formatted time string
+ */
+declare function formatTime(date?: Date): string;
+/**
+ * Format datetime for API (YYYY-MM-DD HH:mm:ss)
+ * @param date - Date to format
+ * @returns Formatted datetime string
+ */
+declare function formatDateTime(date?: Date): string;
+/**
+ * Parse ISO date string to Date object
+ * @param isoString - ISO date string
+ * @returns Date object
+ */
+declare function parseISO(isoString: string): Date;
 
 /**
  * Passgage Access Provider
@@ -145,82 +1133,112 @@ interface UsePassgageAuthReturn {
 declare function usePassgageAuth(options?: UsePassgageAuthOptions): UsePassgageAuthReturn;
 
 /**
- * useQRScanner hook
+ * usePassgageQRScanner hook
  * QR code scanning with validation
  */
 
-interface UseQRScannerOptions {
+interface UsePassgageQRScannerOptions {
     onSuccess?: (entrance?: Entrance) => void;
     onError?: (error: Error) => void;
     skipLocationCheck?: boolean;
     skipRepetitiveCheck?: boolean;
 }
-interface UseQRScannerReturn {
+interface UsePassgageQRScannerReturn {
     scan: (qrCode: string, device?: QrDevice) => Promise<void>;
     isLoading: boolean;
     error: Error | null;
 }
-declare function useQRScanner(options?: UseQRScannerOptions): UseQRScannerReturn;
+declare function usePassgageQRScanner(options?: UsePassgageQRScannerOptions): UsePassgageQRScannerReturn;
 
 /**
- * useNFCScanner hook
+ * usePassgageNFCScanner hook
  * NFC card scanning with validation
  */
 
-interface UseNFCScannerOptions {
+interface UsePassgageNFCScannerOptions {
     onSuccess?: (entrance?: Entrance) => void;
     onError?: (error: Error) => void;
     skipLocationCheck?: boolean;
     skipRepetitiveCheck?: boolean;
     autoStart?: boolean;
 }
-interface UseNFCScannerReturn {
+interface UsePassgageNFCScannerReturn {
     startScanning: () => Promise<void>;
     stopScanning: () => Promise<void>;
     isScanning: boolean;
     error: Error | null;
 }
-declare function useNFCScanner(options?: UseNFCScannerOptions): UseNFCScannerReturn;
+declare function usePassgageNFCScanner(options?: UsePassgageNFCScannerOptions): UsePassgageNFCScannerReturn;
 
 /**
- * useCheckIn hook
+ * usePassgageCheckIn hook
  * GPS-based check-in to nearby branches
  */
 
-interface UseCheckInOptions {
+interface UsePassgageCheckInOptions {
     radius?: number;
-    autoFetch?: boolean;
 }
-interface CheckInParams {
+interface CheckInEntryParams {
     branchId: string;
-    entranceType: EntranceType;
+    userId: string;
+}
+interface CheckInExitParams {
+    branchId: string;
+    userId: string;
+}
+interface GetNearbyBranchesParams {
+    radius?: number;
 }
-interface UseCheckInReturn {
-    nearbyBranches: Branch[];
-    fetchNearbyBranches: () => Promise<void>;
-    checkIn: (params: CheckInParams) => Promise<Entrance | undefined>;
+interface UsePassgageCheckInReturn {
+    getNearbyBranches: (params?: GetNearbyBranchesParams) => Promise<{
+        success: boolean;
+        data?: Branch[];
+        error?: string;
+    }>;
+    checkInEntry: (params: CheckInEntryParams) => Promise<{
+        success: boolean;
+        data?: any;
+        error?: string;
+    }>;
+    checkInExit: (params: CheckInExitParams) => Promise<{
+        success: boolean;
+        data?: any;
+        error?: string;
+    }>;
     isLoading: boolean;
     error: Error | null;
 }
-declare function useCheckIn(options?: UseCheckInOptions): UseCheckInReturn;
+declare function usePassgageCheckIn(options?: UsePassgageCheckInOptions): UsePassgageCheckInReturn;
 
 /**
- * useRemoteWork hook
+ * usePassgageRemoteWork hook
  * Remote work entry/exit logging
  */
-
-interface RemoteWorkOptions {
+interface RemoteWorkEntryParams {
+    userId: string;
+    description?: string;
     timestamp?: Date | string;
+}
+interface RemoteWorkExitParams {
+    userId: string;
     description?: string;
+    timestamp?: Date | string;
 }
-interface UseRemoteWorkReturn {
-    logEntry: (options?: RemoteWorkOptions) => Promise<Entrance | undefined>;
-    logExit: (options?: RemoteWorkOptions) => Promise<Entrance | undefined>;
-    logRemoteWork: (entranceType: EntranceType, options?: RemoteWorkOptions) => Promise<Entrance | undefined>;
+interface UsePassgageRemoteWorkReturn {
+    logEntry: (params: RemoteWorkEntryParams) => Promise<{
+        success: boolean;
+        data?: any;
+        error?: string;
+    }>;
+    logExit: (params: RemoteWorkExitParams) => Promise<{
+        success: boolean;
+        data?: any;
+        error?: string;
+    }>;
     isLoading: boolean;
     error: Error | null;
 }
-declare function useRemoteWork(): UseRemoteWorkReturn;
+declare function usePassgageRemoteWork(): UsePassgageRemoteWorkReturn;
 
 /**
  * useLocation hook
@@ -243,9 +1261,9 @@ declare function useLocation(options?: UseLocationOptions): UseLocationReturn;
 
 /**
  * Passgage Access SDK - React Native Package
- * React Native wrapper with components and hooks
+ * Complete SDK with core functionality and React Native integration
  */
 
-declare const SDK_VERSION = "1.0.0";
+declare const SDK_VERSION = "1.0.3";
 
-export { type CheckInParams, type PassgageAccessConfig, type PassgageAccessContextValue, PassgageAccessProvider, type PassgageAccessProviderProps, type RemoteWorkOptions, SDK_VERSION, type UseCheckInOptions, type UseCheckInReturn, type UseLocationOptions, type UseLocationReturn, type UseNFCScannerOptions, type UseNFCScannerReturn, type UsePassgageAuthOptions, type UsePassgageAuthReturn, type UseQRScannerOptions, type UseQRScannerReturn, type UseRemoteWorkReturn, useCheckIn, useLocation, useNFCScanner, usePassgageAccess, usePassgageAuth, useQRScanner, useRemoteWork };
+export { type APIError, ApiClient, type ApiClientConfig, AuthService, type AuthState, type AuthTokens, type BaseResponse, type Branch, type CheckInEntryParams, type CheckInExitParams, type CheckInOptions, type CheckInResult, CheckInService, type CompanyInfo, type Coordinates, type CreateEntranceFromQRRequest, type CreateEntranceRequest, type Device, type DeviceAccessRequest, DeviceAccessService, DeviceDirection, DeviceUsage, endpoints as Endpoints, type Entrance, type EntranceQueryParams, EntranceType, type GetNearbyBranchesParams, LocationService, type LocationVerificationLog, type LoginCredentials, type LoginRequest, type LoginResponse, type LoginResult, NFCAccessService, type NFCValidationOptions, type NFCValidationResult, type NearbyBranchesRequest, type PaginationMeta, type PassgageAccessConfig, type PassgageAccessContextValue, PassgageAccessProvider, type PassgageAccessProviderProps, QRAccessService, type QRValidationOptions, type QRValidationResult, type QrAccessResponse, type QrDevice, type RefreshTokenRequest, type RefreshTokenResponse, type RefreshTokenResult, type RemoteWorkEntryOptions, type RemoteWorkEntryParams, type RemoteWorkExitParams, type RemoteWorkResult, RemoteWorkService, type RequestOptions, SDK_VERSION, type TokenInfo, type TokenStorage, type UseLocationOptions, type UseLocationReturn, type UsePassgageAuthOptions, type UsePassgageAuthReturn, type UsePassgageCheckInOptions, type UsePassgageCheckInReturn, type UsePassgageNFCScannerOptions, type UsePassgageNFCScannerReturn, type UsePassgageQRScannerOptions, type UsePassgageQRScannerReturn, type UsePassgageRemoteWorkReturn, type User, calculateDistance, checkOnLocation, checkRepetitiveRead, clearReadRecords, createApiClient, formatDate, formatDateTime, formatISO, formatTime, parseISO, useLocation, usePassgageAccess, usePassgageAuth, usePassgageCheckIn, usePassgageNFCScanner, usePassgageQRScanner, usePassgageRemoteWork, validateCoordinates, validateDeviceId, validateNFCCode, validateQRCode };