vesant-sdk 1.0.4

package/dist/client-DMNkESa0.d.mts

@@ -0,0 +1,1108 @@
+import { P as PaginationParams, B as BaseClient } from './types-Bnsnejor.mjs';
+
+/**
+ * TypeScript type definitions for CGS Geolocation Service API
+ *
+ * These types match the Go API structures in:
+ * - services/geolocation-service/internal/domain/
+ * - services/geolocation-service/internal/service/
+ * - services/geolocation-service/internal/handler/
+ */
+
+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;
+    /** 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[];
+    };
+}
+/**
+ * Request to validate cipherText on the server
+ */
+interface ValidateCipherTextRequest {
+    cipher_text: string;
+    user_id: string;
+    event_type: CipherTextReason;
+    expected_ip?: string;
+}
+/**
+ * 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;
+    };
+    errors?: string[];
+}
+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;
+}
+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<AlertStatus, number>;
+    alerts_by_severity: Record<AlertSeverity, number>;
+    alerts_by_type: Record<string, number>;
+    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<CreateJurisdictionRequest> {
+}
+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<CreateGeofenceRuleRequest> {
+}
+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;
+    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<string, unknown>;
+}
+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<string, string>;
+    /** Request timeout in milliseconds (default: 10000) */
+    timeout?: number;
+    /** Enable debug logging */
+    debug?: boolean;
+}
+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;
+}
+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<LocationVerification>;
+    /** Check compliance for a country */
+    checkCompliance: (countryISO: string) => Promise<ComplianceCheckResponse>;
+    /** Refresh verification */
+    refresh: () => Promise<void>;
+}
+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<void>;
+    /** Update alert status */
+    updateStatus: (alertId: string, status: AlertStatus) => Promise<void>;
+    /** Assign alert */
+    assignAlert: (alertId: string, assignedTo: string) => Promise<void>;
+    /** Resolve alert */
+    resolveAlert: (alertId: string, resolution: string, notes?: string) => Promise<void>;
+    /** Dismiss alert as false positive */
+    dismissAlert: (alertId: string, notes?: string) => Promise<void>;
+    /** Refresh alerts */
+    refresh: () => Promise<void>;
+}
+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;
+}
+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<void>;
+    /** Create a new location request */
+    createRequest: (request: CreateLocationRequestRequest) => Promise<LocationRequestResult>;
+    /** Get a specific location request by ID */
+    getRequest: (requestId: string) => Promise<LocationRequest>;
+    /** Cancel a pending location request */
+    cancelRequest: (requestId: string) => Promise<void>;
+    /** Resend notification for a location request */
+    resendRequest: (requestId: string, contact: {
+        email?: string;
+        phone?: string;
+    }) => Promise<void>;
+    /** Refresh location requests */
+    refresh: () => Promise<void>;
+}
+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<LocationShareInfo>;
+    /** Submit location capture */
+    submitLocation: (capture: LocationCaptureRequest) => Promise<LocationCaptureResponse>;
+    /** Request GPS and auto-submit location */
+    captureAndSubmitGPS: () => Promise<LocationCaptureResponse>;
+}
+
+/**
+ * GeolocationClient - TypeScript SDK for CGS 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 (CGSError, NetworkError, TimeoutError, etc.)
+ * - Automatic timeout management
+ * - Debug logging
+ *
+ * All geolocation verification calls use requestWithRetry() to handle
+ * transient failures gracefully.
+ */
+declare class GeolocationClient extends BaseClient {
+    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): Promise<LocationVerification>;
+    /**
+     * 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): Promise<ComplianceCheckResponse>;
+    /**
+     * 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
+     * @returns Validation result with device info, location, and risk assessment
+     *
+     * @example
+     * ```typescript
+     * // Validate cipherText during login
+     * const result = await client.validateCipherText(
+     *   cipherText,
+     *   "user_123",
+     *   "login"
+     * );
+     *
+     * if (!result.valid) {
+     *   console.log("CipherText validation failed:", result.errors);
+     *   return;
+     * }
+     *
+     * console.log("Device UUID:", result.device_uuid);
+     * console.log("IP Address:", result.ip_address);
+     * console.log("Risk Level:", result.risk.level);
+     *
+     * if (result.risk.is_vpn) {
+     *   console.log("VPN detected");
+     * }
+     * ```
+     */
+    validateCipherText(cipherText: string, userId: string, eventType: CipherTextReason, expectedIP?: string): Promise<ValidateCipherTextResponse>;
+    /**
+     * 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): Promise<{
+        ciphertext_valid: boolean;
+        ciphertext_result: ValidateCipherTextResponse;
+        location: LocationVerification;
+    }>;
+    /**
+     * Get location history for a user
+     *
+     * @param userId - User ID to retrieve history for
+     * @param limit - Maximum number of records to return (default: 100)
+     * @returns Array of geolocation records
+     */
+    getUserLocationHistory(userId: string, limit?: number): Promise<GeolocationRecord[]>;
+    /**
+     * Get a specific alert by ID
+     *
+     * @param alertId - Alert ID
+     * @returns Alert details
+     */
+    getAlert(alertId: string): Promise<GeolocationAlert>;
+    /**
+     * List alerts with filters and pagination
+     *
+     * @param filters - Optional filters (status, severity, type, user, dates)
+     * @param pagination - Optional pagination (page, page_size)
+     * @returns Paginated list of alerts
+     *
+     * @example
+     * ```typescript
+     * const alerts = await client.listAlerts(
+     *   { status: "active", severity: "critical" },
+     *   { page: 1, page_size: 20 }
+     * );
+     * console.log(`Found ${alerts.total} critical alerts`);
+     * ```
+     */
+    listAlerts(filters?: AlertFilters, pagination?: PaginationParams): Promise<AlertListResponse>;
+    /**
+     * Update alert status
+     *
+     * @param alertId - Alert ID
+     * @param status - New status
+     */
+    updateAlertStatus(alertId: string, status: AlertStatus): Promise<void>;
+    /**
+     * Assign an alert to an analyst
+     *
+     * @param alertId - Alert ID
+     * @param assignedTo - User ID to assign to
+     */
+    assignAlert(alertId: string, assignedTo: string): Promise<void>;
+    /**
+     * Resolve an alert
+     *
+     * @param alertId - Alert ID
+     * @param resolution - Resolution type
+     * @param notes - Optional notes
+     */
+    resolveAlert(alertId: string, resolution: string, notes?: string): Promise<void>;
+    /**
+     * Dismiss an alert as false positive
+     *
+     * @param alertId - Alert ID
+     * @param notes - Optional notes explaining why it's a false positive
+     */
+    dismissAlert(alertId: string, notes?: string): Promise<void>;
+    /**
+     * Escalate an alert to higher severity or different assignee
+     *
+     * @param alertId - Alert ID
+     * @param assignedTo - New assignee user ID
+     * @param severity - New severity level
+     * @param notes - Escalation notes
+     */
+    escalateAlert(alertId: string, assignedTo: string, severity: string, notes: string): Promise<void>;
+    /**
+     * Block an alert (mark as blocked)
+     *
+     * @param alertId - Alert ID
+     * @param notes - Optional notes
+     */
+    blockAlert(alertId: string, notes?: string): Promise<void>;
+    /**
+     * Get dashboard metrics
+     *
+     * @param timeRangeHours - Time range in hours (default: 24)
+     * @returns Dashboard metrics and statistics
+     *
+     * @example
+     * ```typescript
+     * const metrics = await client.getDashboardMetrics(168); // Last 7 days
+     * console.log(`${metrics.critical_alerts} critical alerts in last week`);
+     * ```
+     */
+    getDashboardMetrics(timeRangeHours?: number): Promise<DashboardMetrics>;
+    /**
+     * List all jurisdiction configurations
+     *
+     * @returns Array of jurisdiction configurations
+     */
+    listJurisdictions(): Promise<JurisdictionConfig[]>;
+    /**
+     * Get a jurisdiction configuration by ID
+     *
+     * @param jurisdictionId - Jurisdiction ID
+     * @returns Jurisdiction configuration
+     */
+    getJurisdiction(jurisdictionId: string): Promise<JurisdictionConfig>;
+    /**
+     * Create a new jurisdiction configuration
+     *
+     * @param request - Jurisdiction configuration data
+     * @returns Created jurisdiction
+     *
+     * @example
+     * ```typescript
+     * const jurisdiction = await client.createJurisdiction({
+     *   country_iso: "US",
+     *   country_name: "United States",
+     *   status: "allowed",
+     *   risk_level: "low",
+     *   allow_login: true,
+     *   allow_registration: true,
+     *   allow_transactions: true,
+     *   require_kyc: false,
+     *   require_enhanced_verification: false
+     * });
+     * ```
+     */
+    createJurisdiction(request: CreateJurisdictionRequest): Promise<JurisdictionConfig>;
+    /**
+     * Update a jurisdiction configuration
+     *
+     * @param jurisdictionId - Jurisdiction ID
+     * @param request - Updated fields
+     * @returns Updated jurisdiction
+     */
+    updateJurisdiction(jurisdictionId: string, request: UpdateJurisdictionRequest): Promise<JurisdictionConfig>;
+    /**
+     * Delete a jurisdiction configuration
+     *
+     * @param jurisdictionId - Jurisdiction ID
+     */
+    deleteJurisdiction(jurisdictionId: string): Promise<void>;
+    /**
+     * List all geofence rules
+     *
+     * @returns Array of geofence rules
+     */
+    listGeofenceRules(): Promise<GeofenceRule[]>;
+    /**
+     * Get a geofence rule by ID
+     *
+     * @param ruleId - Geofence rule ID
+     * @returns Geofence rule
+     */
+    getGeofenceRule(ruleId: string): Promise<GeofenceRule>;
+    /**
+     * Create a new geofence rule
+     *
+     * @param request - Geofence rule data
+     * @returns Created geofence rule
+     *
+     * @example
+     * ```typescript
+     * const rule = await client.createGeofenceRule({
+     *   name: "Block High Risk Countries",
+     *   rule_type: "block_list",
+     *   action: "block",
+     *   countries: ["KP", "IR", "SY"],
+     *   event_types: ["login", "transaction"],
+     *   priority: 100
+     * });
+     * ```
+     */
+    createGeofenceRule(request: CreateGeofenceRuleRequest): Promise<GeofenceRule>;
+    /**
+     * Update a geofence rule
+     *
+     * @param ruleId - Geofence rule ID
+     * @param request - Updated fields
+     * @returns Updated geofence rule
+     */
+    updateGeofenceRule(ruleId: string, request: UpdateGeofenceRuleRequest): Promise<GeofenceRule>;
+    /**
+     * Delete a geofence rule
+     *
+     * @param ruleId - Geofence rule ID
+     */
+    deleteGeofenceRule(ruleId: string): Promise<void>;
+    /**
+     * Get all devices for a user
+     *
+     * @param userId - User ID
+     * @returns Array of device fingerprints
+     */
+    getUserDevices(userId: string): Promise<DeviceFingerprint[]>;
+    /**
+     * Get a specific device by device ID
+     *
+     * @param deviceId - Device ID
+     * @returns Device fingerprint
+     */
+    getDevice(deviceId: string): Promise<DeviceFingerprint>;
+    /**
+     * Update device trust status
+     *
+     * @param deviceId - Device ID
+     * @param action - "trust" or "untrust"
+     *
+     * @example
+     * ```typescript
+     * // Mark a device as trusted
+     * await client.updateDeviceTrust("device_abc", "trust");
+     *
+     * // Mark a device as untrusted
+     * await client.updateDeviceTrust("device_xyz", "untrust");
+     * ```
+     */
+    updateDeviceTrust(deviceId: string, action: 'trust' | 'untrust'): Promise<void>;
+    /**
+     * 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): Promise<LocationRequestResult>;
+    /**
+     * Get a location request by ID
+     *
+     * @param requestId - Location request ID
+     * @returns Location request details
+     */
+    getLocationRequest(requestId: string): Promise<LocationRequest>;
+    /**
+     * 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): Promise<LocationRequestListResponse>;
+    /**
+     * Cancel a pending location request
+     *
+     * @param requestId - Location request ID
+     */
+    cancelLocationRequest(requestId: string): Promise<void>;
+    /**
+     * Resend notification for a location request
+     *
+     * @param requestId - Location request ID
+     * @param contact - Email or phone to send to
+     */
+    resendLocationRequest(requestId: string, contact: ResendLocationRequestRequest): Promise<void>;
+    /**
+     * 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): Promise<LocationShareInfo>;
+    /**
+     * 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): Promise<LocationCaptureResponse>;
+}
+
+export { type UseLocationCaptureOptions as $, type AlertStatus as A, type GeolocationClientConfig as B, type CipherTextPayload as C, type DeviceFingerprintRequest as D, type UseGeolocationOptions as E, type UseGeolocationResult as F, GeolocationClient as G, type UseAlertsOptions as H, type UseAlertsResult as I, type JurisdictionConfig as J, type LocationRequestStatus as K, type LocationVerification as L, type LocationRequestChannel as M, type LocationRequest as N, type CreateLocationRequestRequest as O, type LocationRequestResult as P, type LocationRequestFilters as Q, type LocationRequestListResponse as R, type ResendLocationRequestRequest as S, type LocationCaptureRequest as T, type UpdateJurisdictionRequest as U, type ValidateCipherTextRequest as V, type WiFiNetwork as W, type LocationShareInfo as X, type LocationCaptureResponse as Y, type UseLocationRequestsOptions as Z, type UseLocationRequestsResult as _, type CipherTextReason as a, type UseLocationCaptureResult as a0, type CipherTextOptions as b, type CipherTextResult as c, type DecryptedCipherText as d, type ValidateCipherTextResponse as e, type VerifyIPRequest as f, type GeoIPResult as g, type GeofenceEvaluation as h, type DeviceFingerprint as i, type DeviceTrustResult as j, type ComplianceCheckResponse as k, type AlertSeverity as l, type AlertType as m, type GeolocationAlert as n, type AlertFilters as o, type AlertListResponse as p, type DashboardMetrics as q, type CreateJurisdictionRequest as r, type GeofenceRuleType as s, type GeofenceAction as t, type GeofenceRule as u, type CreateGeofenceRuleRequest as v, type UpdateGeofenceRuleRequest as w, type UpdateDeviceTrustRequest as x, type GeolocationRecord as y, type APIError as z };