import { L as Logger, B as BaseClient, R as RequestOptions } from './client-ePzhQKp9.js'; import { P as PaginationParams } from './types-B4Ezqo7V.js'; interface DeviceFingerprintRequest { device_id: string; user_agent: string; platform: string; browser?: string; browser_version?: string; os?: string; os_version?: string; screen_resolution?: string; language?: string; timezone?: string; } /** * Raw device and location data collected from the client * This data is encrypted into a cipherText before being sent to the server */ interface CipherTextPayload { /** Device fingerprint data */ device: { device_id: string; user_agent: string; platform: string; browser?: string; browser_version?: string; os?: string; os_version?: string; screen_resolution?: string; language?: string; timezone?: string; color_depth?: number; hardware_concurrency?: number; device_memory?: number; touch_support?: boolean; webgl_vendor?: string; webgl_renderer?: string; }; /** GPS/Geolocation data (if available) */ location?: { latitude: number; longitude: number; accuracy: number; altitude?: number; altitude_accuracy?: number; heading?: number; speed?: number; timestamp: number; }; /** Network information */ network?: { effective_type?: string; downlink?: number; rtt?: number; save_data?: boolean; }; /** Collection metadata */ metadata: { collected_at: string; sdk_version: string; collection_reason: CipherTextReason; page_url?: string; referrer?: string; }; } /** * Reason for collecting the cipherText */ type CipherTextReason = 'registration' | 'login' | 'transaction' | 'interval_check' | 'ip_change' | 'game_launch' | 'withdrawal' | 'manual_verification'; /** * Options for generating cipherText */ interface CipherTextOptions { /** Reason for collection (required) */ reason: CipherTextReason; /** Public signing key (pk_) for HMAC signing (produces v02 signed cipherText) */ signingKey?: string; /** @deprecated Use signingKey instead. API key for HMAC signing (backward compat) */ apiKey?: string; /** Request GPS location (default: false) */ requestLocation?: boolean; /** GPS timeout in milliseconds (default: 10000) */ locationTimeout?: number; /** High accuracy GPS (default: true) */ highAccuracy?: boolean; /** Include network info (default: true) */ includeNetworkInfo?: boolean; /** Include WebGL info for fingerprinting (default: true) */ includeWebGL?: boolean; /** Custom user ID to include */ userId?: string; } /** * Result from cipherText generation */ interface CipherTextResult { /** The encrypted cipherText string */ cipherText: string; /** Whether GPS location was successfully captured */ locationCaptured: boolean; /** Any errors that occurred during collection (non-fatal) */ warnings?: string[]; /** Timestamp when cipherText was generated */ generatedAt: string; /** Expiry time for the cipherText */ expiresAt: string; } /** * Decrypted cipherText data (returned by server after validation) */ interface DecryptedCipherText { /** Whether the cipherText is valid */ valid: boolean; /** Validation errors if any */ errors?: string[]; /** The decrypted payload */ payload?: CipherTextPayload; /** Extracted device UUID */ device_uuid?: string; /** Extracted IP address (from server) */ ip_address?: string; /** Risk assessment */ risk?: { score: number; level: 'low' | 'medium' | 'high' | 'critical'; factors: string[]; }; } /** * Optional customer data for risk profile creation during cipherText validation. * When a user is blocked (e.g., from a sanctioned country), this data is used to * create a risk profile with complete customer information for the alert. */ interface CipherTextCustomerData { /** Customer's full name */ full_name?: string; /** Customer's email address */ email?: string; /** Customer's phone number */ phone?: string; /** Customer's date of birth (ISO format) */ date_of_birth?: string; /** Customer's country */ country?: string; /** Customer's state/province */ state?: string; /** Customer's city */ city?: string; /** Customer's postal/zip code */ zip_code?: string; } /** * Request to validate cipherText on the server */ interface ValidateCipherTextRequest { cipher_text: string; user_id: string; event_type: CipherTextReason; expected_ip?: string; /** * Optional customer data for risk profile creation. * This is used when creating alerts for blocked users so the risk profile * has complete customer information (name, email, etc.) */ customer_data?: CipherTextCustomerData; } /** * Response from cipherText validation */ interface ValidateCipherTextResponse { valid: boolean; device_uuid: string; ip_address: string; location?: { latitude: number; longitude: number; accuracy: number; country?: string; country_iso?: string; city?: string; region?: string; }; device: { platform: string; browser?: string; os?: string; is_mobile: boolean; is_tablet: boolean; }; risk: { score: number; level: 'low' | 'medium' | 'high' | 'critical'; factors: string[]; is_vpn: boolean; is_proxy: boolean; is_tor: boolean; is_hosting?: boolean; /** Whether access is blocked based on tenant's geofence rules configuration */ is_blocked: boolean; /** Reasons for blocking (only present if is_blocked is true) */ block_reasons?: string[]; /** GPS-vs-IP location mismatch detected (possible spoofing) */ location_mismatch?: boolean; /** Distance in km between GPS and IP-derived location */ location_mismatch_distance_km?: number; }; errors?: string[]; is_compliant?: boolean; jurisdiction?: JurisdictionConfig; geofence_evaluation?: GeofenceEvaluation; record_id?: string; gps_required?: boolean; } interface VerifyIPRequest { ip_address: string; user_id: string; event_type: string; device_fingerprint?: DeviceFingerprintRequest; } interface GeoIPResult { country: string; country_iso: string; city: string; region: string; postal_code: string; latitude: number; longitude: number; timezone: string; is_vpn: boolean; is_proxy: boolean; is_tor: boolean; is_hosting: boolean; is_anonymizer: boolean; } interface JurisdictionConfig { id: string; tenant_id: string; country_iso: string; country_name: string; status: 'allowed' | 'restricted' | 'blocked' | 'sanctioned'; risk_level: 'low' | 'medium' | 'high'; allow_login: boolean; allow_registration: boolean; allow_transactions: boolean; max_transaction_amount?: number; require_kyc: boolean; require_enhanced_verification: boolean; compliance_notes?: string; created_at: string; updated_at: string; } interface GeofenceEvaluation { matched_rules: string[]; blocked: boolean; should_alert: boolean; reasons: string[]; } interface DeviceFingerprint { id: string; tenant_id: string; user_id: string; device_id: string; user_agent: string; platform: string; browser?: string; browser_version?: string; os?: string; os_version?: string; screen_resolution?: string; language?: string; timezone?: string; ip_address?: string; last_ip_address?: string; last_location?: string; is_trusted: boolean; trust_score: number; risk_flags?: string; first_seen_at: string; last_seen_at: string; login_count: number; location_changes: number; } interface DeviceTrustResult { device: DeviceFingerprint; is_new_device: boolean; is_trusted: boolean; trust_score: number; risk_factors: string[]; recommendations: string[]; } interface LocationVerification { ip_address: string; location: GeoIPResult; is_compliant: boolean; is_blocked: boolean; risk_level: 'low' | 'medium' | 'high' | 'critical'; risk_score: number; risk_reasons: string[]; jurisdiction?: JurisdictionConfig; geofence_evaluation?: GeofenceEvaluation; device_trust?: DeviceTrustResult; record_id: string; /** Whether GPS verification is required for this event type (based on tenant config) */ gps_required?: boolean; } interface ComplianceCheckResponse { jurisdiction?: JurisdictionConfig; is_compliant: boolean; message: string; } type AlertStatus = 'active' | 'under_review' | 'resolved' | 'false_positive' | 'blocked'; type AlertSeverity = 'low' | 'medium' | 'high' | 'critical'; type AlertType = 'high_risk_login' | 'sanctioned_region' | 'geofence_violation' | 'tor_detected' | 'vpn_detected' | 'proxy_detected' | 'anonymization_detected' | 'anonymization_tool_detected' | 'high_risk_country' | 'impossible_travel' | 'device_fingerprint_mismatch'; interface GeolocationAlert { id: string; tenant_id: string; user_id: string; alert_type: AlertType; severity: AlertSeverity; status: AlertStatus; ip_address?: string; location?: string; risk_score?: number; risk_factors?: string; geolocation_record_id?: string; assigned_to?: string; resolution?: string; notes?: string; resolved_by?: string; resolved_at?: string; created_at: string; updated_at: string; } interface AlertFilters { status?: AlertStatus; severity?: AlertSeverity; alert_type?: AlertType; user_id?: string; assigned_to?: string; start_date?: string; end_date?: string; } interface AlertListResponse { alerts: GeolocationAlert[]; total: number; page: number; page_size: number; } interface DashboardMetrics { total_alerts: number; active_alerts: number; critical_alerts: number; high_alerts: number; alerts_by_status: Record; alerts_by_severity: Record; alerts_by_type: Record; top_risk_users: Array<{ user_id: string; alert_count: number; max_risk_score: number; }>; top_risk_countries: Array<{ country: string; alert_count: number; }>; } interface CreateJurisdictionRequest { country_iso: string; country_name: string; status: 'allowed' | 'restricted' | 'blocked' | 'sanctioned'; risk_level: 'low' | 'medium' | 'high'; allow_login: boolean; allow_registration: boolean; allow_transactions: boolean; max_transaction_amount?: number; require_kyc: boolean; require_enhanced_verification: boolean; compliance_notes?: string; } interface UpdateJurisdictionRequest extends Partial { } type GeofenceRuleType = 'block_list' | 'allow_list' | 'risk_threshold'; type GeofenceAction = 'block' | 'alert' | 'allow_with_warning'; interface GeofenceRule { id: string; tenant_id: string; name: string; description?: string; rule_type: GeofenceRuleType; action: GeofenceAction; priority: number; countries?: string; cities?: string; latitude?: number; longitude?: number; radius_km?: number; risk_threshold?: number; event_types?: string; is_active: boolean; created_by: string; created_at: string; updated_at: string; } interface CreateGeofenceRuleRequest { name: string; description?: string; rule_type: GeofenceRuleType; action: GeofenceAction; priority?: number; countries?: string[]; cities?: string[]; latitude?: number; longitude?: number; radius_km?: number; risk_threshold?: number; event_types?: string[]; is_active?: boolean; } interface UpdateGeofenceRuleRequest extends Partial { } interface UpdateDeviceTrustRequest { device_id: string; action: 'trust' | 'untrust'; } interface GeolocationRecord { id: string; tenant_id: string; user_id: string; ip_address: string; event_type: string; country: string; country_iso: string; city: string; region: string; postal_code?: string; latitude: number; longitude: number; /** Source of the coordinates: "gps" when device GPS was provided, "ip" when derived from IP lookup */ position_source?: 'gps' | 'ip'; /** GPS accuracy in meters (only present when position_source is "gps") */ gps_accuracy?: number; timezone?: string; is_vpn: boolean; is_proxy: boolean; is_tor: boolean; is_hosting: boolean; is_anonymizer: boolean; risk_score: number; risk_level: string; provider: string; provider_response?: string; created_at: string; } interface APIError { error: string; message?: string; details?: Record; } /** * GPS requirement configuration per event type, returned by GET /api/v1/geo/config */ interface GeolocationConfigResponse { require_gps: { login: boolean; registration: boolean; transaction: boolean; }; /** When true, GPS-verified location overrides anonymizer-based blocking */ trust_gps_over_anonymizer: boolean; /** Public signing key (pk_) for client-side HMAC signing */ signing_key?: string; } interface GeolocationClientConfig { /** Base URL of the API Gateway (e.g., "https://api.example.com") */ baseURL: string; /** Tenant ID for multi-tenancy */ tenantId: string; /** API key or JWT token for authentication */ apiKey?: string; /** Custom headers to include in every request */ headers?: Record; /** Request timeout in milliseconds (default: 10000) */ timeout?: number; /** Enable debug logging */ debug?: boolean; /** Custom logger instance */ logger?: Logger; /** Environment mode - 'sandbox' uses isolated sandbox data */ environment?: 'production' | 'sandbox'; } interface UseGeolocationOptions { /** Auto-detect and verify user's IP on mount */ autoVerify?: boolean; /** Event type for verification */ eventType?: string; /** Include device fingerprint in verification */ includeDeviceFingerprint?: boolean; /** User ID to include in verification requests */ userId?: string; } interface UseGeolocationResult { /** Current verification result */ verification: LocationVerification | null; /** Loading state */ loading: boolean; /** Error state */ error: Error | null; /** Verify an IP address */ verifyIP: (request: VerifyIPRequest) => Promise; /** Check compliance for a country */ checkCompliance: (countryISO: string) => Promise; /** Refresh verification */ refresh: () => Promise; } interface UseAlertsOptions { /** Auto-fetch alerts on mount */ autoFetch?: boolean; /** Initial filters */ filters?: AlertFilters; /** Pagination settings */ pagination?: PaginationParams; /** Poll interval in milliseconds (0 = no polling) */ pollInterval?: number; } interface UseAlertsResult { /** List of alerts */ alerts: GeolocationAlert[]; /** Total count */ total: number; /** Loading state */ loading: boolean; /** Error state */ error: Error | null; /** Fetch alerts with filters */ fetchAlerts: (filters?: AlertFilters, pagination?: PaginationParams) => Promise; /** Update alert status */ updateStatus: (alertId: string, status: AlertStatus) => Promise; /** Assign alert */ assignAlert: (alertId: string, assignedTo: string) => Promise; /** Resolve alert */ resolveAlert: (alertId: string, resolution: string, notes?: string) => Promise; /** Dismiss alert as false positive */ dismissAlert: (alertId: string, notes?: string) => Promise; /** Refresh alerts */ refresh: () => Promise; } type LocationRequestStatus = 'pending' | 'sent' | 'completed' | 'expired' | 'cancelled' | 'failed'; type LocationRequestChannel = 'sms' | 'email' | 'push'; interface LocationRequest { id: string; tenant_id: string; user_id: string; requested_by: string; channel: LocationRequestChannel; status: LocationRequestStatus; reason?: string; token_expires_at: string; latitude?: number; longitude?: number; accuracy?: number; country?: string; country_iso?: string; city?: string; region?: string; formatted_address?: string; position_source?: string; notification_sent_at?: string; responded_at?: string; viewed_at?: string; created_at: string; updated_at: string; } interface CreateLocationRequestRequest { /** Customer user ID to request location from */ user_id: string; /** Notification channel to use */ channel: LocationRequestChannel; /** Reason for requesting location (for compliance/audit) */ reason?: string; /** Customer email (required for email channel) */ email?: string; /** Customer phone (required for SMS channel) */ phone?: string; /** Custom expiry time in hours (default: 24) */ expiry_hours?: number; } interface LocationRequestResult { request: LocationRequest; share_link: string; token_expiry: string; } interface LocationRequestFilters { status?: LocationRequestStatus; user_id?: string; requested_by?: string; channel?: LocationRequestChannel; date_from?: string; date_to?: string; } interface LocationRequestListResponse { requests: LocationRequest[]; total: number; page: number; limit: number; total_pages: number; } interface ResendLocationRequestRequest { email?: string; phone?: string; } interface WiFiNetwork { /** MAC address (BSSID) */ macAddress: string; /** Signal strength in dBm (negative number) */ signalStrength?: number; /** WiFi channel */ channel?: number; /** Network name (optional) */ ssid?: string; } interface LocationCaptureRequest { /** GPS latitude (if available) */ latitude?: number; /** GPS longitude (if available) */ longitude?: number; /** GPS accuracy in meters */ accuracy?: number; /** WiFi networks for positioning (if GPS not available) */ wifi_networks?: WiFiNetwork[]; /** User agent string */ user_agent?: string; /** Device metadata */ device_info?: { platform?: string; browser?: string; browser_version?: string; os?: string; os_version?: string; }; } interface LocationShareInfo { request_id: string; tenant_id: string; reason?: string; expires_at: string; status: string; is_expired: boolean; is_completed: boolean; requires_wifi: boolean; } interface LocationCaptureResponse { success: boolean; status: string; position_source?: string; latitude?: number; longitude?: number; accuracy?: number; /** Resolved country name (from Nominatim or MaxMind fallback) */ country?: string; /** ISO country code */ country_iso?: string; /** Resolved city name */ city?: string; /** Resolved region/state name */ region?: string; /** GPS-vs-IP location mismatch detected (possible spoofing) */ location_mismatch?: boolean; /** Distance in km between GPS and IP-derived location */ mismatch_distance_km?: number; } interface UseLocationRequestsOptions { /** Auto-fetch location requests on mount */ autoFetch?: boolean; /** Initial filters */ filters?: LocationRequestFilters; /** Pagination settings */ pagination?: PaginationParams; /** Poll interval in milliseconds (0 = no polling) */ pollInterval?: number; } interface UseLocationRequestsResult { /** List of location requests */ requests: LocationRequest[]; /** Total count */ total: number; /** Current page */ page: number; /** Total pages */ totalPages: number; /** Loading state */ loading: boolean; /** Error state */ error: Error | null; /** Fetch location requests with filters */ fetchRequests: (filters?: LocationRequestFilters, pagination?: PaginationParams) => Promise; /** Create a new location request */ createRequest: (request: CreateLocationRequestRequest) => Promise; /** Get a specific location request by ID */ getRequest: (requestId: string) => Promise; /** Cancel a pending location request */ cancelRequest: (requestId: string) => Promise; /** Resend notification for a location request */ resendRequest: (requestId: string, contact: { email?: string; phone?: string; }) => Promise; /** Refresh location requests */ refresh: () => Promise; } interface UseLocationCaptureOptions { /** Token from share link */ token: string; /** Auto-fetch share info on mount */ autoFetch?: boolean; /** Auto-request GPS permission on mount */ autoRequestGPS?: boolean; /** Collect WiFi data as fallback (requires explicit permission) */ collectWiFi?: boolean; } interface UseLocationCaptureResult { /** Location share info */ shareInfo: LocationShareInfo | null; /** Capture response after submission */ captureResponse: LocationCaptureResponse | null; /** Loading state */ loading: boolean; /** Submitting state (during capture) */ submitting: boolean; /** Error state */ error: Error | null; /** Whether the request is expired */ isExpired: boolean; /** Whether the request is already completed */ isCompleted: boolean; /** Fetch share info */ fetchShareInfo: () => Promise; /** Submit location capture */ submitLocation: (capture: LocationCaptureRequest) => Promise; /** Request GPS and auto-submit location */ captureAndSubmitGPS: () => Promise; } /** * GeolocationClient - TypeScript SDK for Vesant Geolocation & Compliance Service * * Provides type-safe methods to interact with the geolocation service API. * Extends BaseClient for consistent retry logic, timeout handling, and error management. */ /** * GeolocationClient extends BaseClient for: * - Consistent retry logic with exponential backoff * - Unified error handling (VesantError, NetworkError, TimeoutError, etc.) * - Automatic timeout management * - Debug logging * * All geolocation verification calls use requestWithRetry() to handle * transient failures gracefully. */ declare class GeolocationClient extends BaseClient { private cachedSigningKey?; constructor(config: GeolocationClientConfig); /** * Verify an IP address and check compliance * * Uses requestWithRetry() for automatic retry on transient failures. * * @param request - Verification request with IP, user ID, event type, and optional device fingerprint * @returns Location verification result with risk assessment * * @example * ```typescript * const result = await client.verifyIP({ * ip_address: "8.8.8.8", * user_id: "user_123", * event_type: "login", * device_fingerprint: { * device_id: "device_abc", * user_agent: navigator.userAgent, * platform: "web" * } * }); * * if (result.is_blocked) { * console.log("Access blocked:", result.risk_reasons); * } * ``` */ verifyIP(request: VerifyIPRequest, requestOptions?: RequestOptions): Promise; /** * Check compliance for a specific country * * @param countryISO - ISO 3166-1 alpha-2 country code (e.g., "US", "GB") * @returns Jurisdiction configuration and compliance status * * @example * ```typescript * const compliance = await client.checkCompliance("KP"); // North Korea * if (!compliance.is_compliant) { * console.log("Country is not allowed:", compliance.jurisdiction?.status); * } * ``` */ checkCompliance(countryISO: string, requestOptions?: RequestOptions): Promise; /** * Get the tenant's GPS requirement configuration * * Returns which event types require GPS location to be collected. * Use this to auto-enable GPS collection in generateCipherText when required. * * @returns GPS requirement config per event type * * @example * ```typescript * const config = await client.getGPSConfig(); * if (config.require_gps.login) { * // GPS is required for login — auto-enable location * } * ``` */ getGPSConfig(requestOptions?: RequestOptions): Promise; /** * Fetch the signing key from the dedicated authenticated endpoint. * * Falls back to getGPSConfig() for backward compatibility with older servers * that don't expose `/api/v1/geo/signing-key`. * * @returns The signing key string, or undefined if unavailable */ fetchSigningKey(requestOptions?: RequestOptions): Promise; /** * Validate a cipherText generated by the frontend SDK * * The cipherText contains encrypted device fingerprint and optional location data. * This method decrypts and validates the data, returning device info, location, * and risk assessment. * * @param cipherText - The encrypted cipherText string from generateCipherText() * @param userId - User ID associated with this verification * @param eventType - Reason for verification (login, registration, etc.) * @param expectedIP - Optional expected IP address for additional validation * @param customerData - Optional customer data for risk profile creation (used when user is blocked) * @returns Validation result with device info, location, and risk assessment * * @example * ```typescript * // Validate cipherText during registration with customer data * const result = await client.validateCipherText( * cipherText, * "user_123", * "registration", * clientIP, * { * full_name: "John Doe", * email: "john@example.com", * country: "US", * state: "CA" * } * ); * * if (!result.valid) { * console.log("CipherText validation failed:", result.errors); * return; * } * * if (result.risk.is_blocked) { * console.log("Access blocked:", result.risk.block_reasons); * // A risk profile with full customer data has been created for the alert * } * ``` */ validateCipherText(cipherText: string, userId: string, eventType: CipherTextReason, expectedIP?: string, customerData?: CipherTextCustomerData, requestOptions?: RequestOptions): Promise; /** * Validate cipherText and verify IP in a single call * * Combines cipherText validation with IP verification for complete * location and device verification in one request. * * @param cipherText - The encrypted cipherText string * @param ipAddress - Client IP address * @param userId - User ID * @param eventType - Event type (login, registration, etc.) * @returns Combined validation and verification result * * @example * ```typescript * const result = await client.validateAndVerify( * cipherText, * clientIP, * "user_123", * "registration" * ); * * if (!result.ciphertext_valid) { * throw new Error("Device verification failed"); * } * * if (result.location.is_blocked) { * throw new Error("Location not allowed"); * } * ``` */ validateAndVerify(cipherText: string, ipAddress: string, userId: string, eventType: CipherTextReason, requestOptions?: RequestOptions): Promise<{ ciphertext_valid: boolean; ciphertext_result: ValidateCipherTextResponse; location: LocationVerification; }>; /** * Create a location request to get customer's live location * * @param request - Location request details * @returns Location request result with share link * * @example * ```typescript * const result = await client.createLocationRequest({ * user_id: "customer_123", * channel: "sms", * phone: "+1234567890", * reason: "Verification for high-value transaction" * }); * * console.log(`Share link sent: ${result.share_link}`); * console.log(`Expires at: ${result.token_expiry}`); * ``` */ createLocationRequest(request: CreateLocationRequestRequest, requestOptions?: RequestOptions): Promise; /** * Get a location request by ID * * @param requestId - Location request ID * @returns Location request details */ getLocationRequest(requestId: string, requestOptions?: RequestOptions): Promise; /** * List location requests with filters and pagination * * @param filters - Optional filters * @param pagination - Optional pagination * @returns Paginated list of location requests * * @example * ```typescript * const requests = await client.listLocationRequests( * { status: "completed", user_id: "customer_123" }, * { page: 1, limit: 20 } * ); * ``` */ listLocationRequests(filters?: LocationRequestFilters, pagination?: PaginationParams, requestOptions?: RequestOptions): Promise; /** * Cancel a pending location request * * @param requestId - Location request ID */ cancelLocationRequest(requestId: string, requestOptions?: RequestOptions): Promise; /** * Resend notification for a location request * * @param requestId - Location request ID * @param contact - Email or phone to send to */ resendLocationRequest(requestId: string, contact: ResendLocationRequestRequest, requestOptions?: RequestOptions): Promise; /** * Get location share info (customer-facing) * This is called from the customer's device to get request details * * @param token - Secure token from share link * @returns Location share info */ getLocationShareInfo(token: string, requestOptions?: RequestOptions): Promise; /** * Submit location capture (customer-facing) * This is called from the customer's device to submit their location * * @param token - Secure token from share link * @param capture - Location capture data (GPS or WiFi) * @returns Capture response * * @example * ```typescript * // Using GPS (preferred) * const result = await client.captureLocation(token, { * latitude: 37.7749, * longitude: -122.4194, * accuracy: 10 * }); * * // Using WiFi positioning (fallback) * const result = await client.captureLocation(token, { * wifi_networks: [ * { macAddress: "00:11:22:33:44:55", signalStrength: -50 }, * { macAddress: "AA:BB:CC:DD:EE:FF", signalStrength: -70 } * ] * }); * ``` */ captureLocation(token: string, capture: LocationCaptureRequest, requestOptions?: RequestOptions): Promise; /** * Generate a signed cipherText containing device and location data. * * Automatically passes the client's API key for HMAC signing (v02 format). * If no API key is configured, falls back to unsigned v01 format. * * @param options - Options for cipherText generation * @param gpsConfig - Optional GPS config (from getGPSConfig) * @returns CipherText result with the signed string * * @example * ```typescript * const result = await client.generateCipherText({ reason: 'login' }); * console.log(result.cipherText); // v02 signed cipherText * ``` */ generateCipherText(options: Omit, gpsConfig?: GeolocationConfigResponse): Promise; } export { type UseLocationRequestsOptions as $, type AlertStatus as A, type APIError as B, type CipherTextPayload as C, type DeviceFingerprintRequest as D, type GeolocationConfigResponse as E, type GeolocationClientConfig as F, GeolocationClient as G, type UseGeolocationOptions as H, type UseGeolocationResult as I, type JurisdictionConfig as J, type UseAlertsOptions as K, type LocationVerification as L, type UseAlertsResult as M, type LocationRequestStatus as N, type LocationRequestChannel as O, type LocationRequest as P, type CreateLocationRequestRequest as Q, type LocationRequestResult as R, type LocationRequestFilters as S, type LocationRequestListResponse as T, type UpdateJurisdictionRequest as U, type ValidateCipherTextRequest as V, type ResendLocationRequestRequest as W, type WiFiNetwork as X, type LocationCaptureRequest as Y, type LocationShareInfo as Z, type LocationCaptureResponse as _, type CipherTextReason as a, type UseLocationRequestsResult as a0, type UseLocationCaptureOptions as a1, type UseLocationCaptureResult as a2, type CipherTextOptions as b, type CipherTextResult as c, type DecryptedCipherText as d, type CipherTextCustomerData as e, type ValidateCipherTextResponse as f, type VerifyIPRequest as g, type GeoIPResult as h, type GeofenceEvaluation as i, type DeviceFingerprint as j, type DeviceTrustResult as k, type ComplianceCheckResponse as l, type AlertSeverity as m, type AlertType as n, type GeolocationAlert as o, type AlertFilters as p, type AlertListResponse as q, type DashboardMetrics as r, type CreateJurisdictionRequest as s, type GeofenceRuleType as t, type GeofenceAction as u, type GeofenceRule as v, type CreateGeofenceRuleRequest as w, type UpdateGeofenceRuleRequest as x, type UpdateDeviceTrustRequest as y, type GeolocationRecord as z };