@safepassage/sdk 3.4.8 → 3.4.10

package/dist/core/SafePassageSDK.js

@@ -1,651 +0,0 @@
-/**
- * SafePassage SDK - Redirect-based age verification
- *
- * Lightweight SDK for integrating SafePassage age verification using redirect flow.
- * Provides a secure, easy-to-implement solution for age verification with comprehensive
- * security features and flexible integration options.
- *
- * Key Features:
- * - Redirect and new-tab verification modes
- * - Automatic session management for public API keys
- * - HMAC-signed state parameters for security
- * - Rate limiting and race condition protection
- * - Comprehensive security validation and logging
- * - PostMessage communication for new-tab mode
- * - Automatic cleanup and resource management
- * - Environment-specific configuration
- *
- * Security Features:
- * - Origin validation for PostMessage communication
- * - HTTPS enforcement in production
- * - Rate limiting per API key and origin
- * - State parameter signing with timestamps and nonces
- * - Comprehensive security event logging
- * - Protection against race conditions and replay attacks
- *
- * @author SafePassage Engineering
- * @version 2.0.0
- * @since 1.0.0
- */
-import { generateState, validateConfig } from '../utils/validation';
-import { getEnvironmentUrl, validateEnvironmentSecurity, } from '../utils/environment';
-import { validatePostMessageOrigin, validateSafePassageMessage, enforceHTTPS, verificationRateLimit, logSecurityEvent, } from '../utils/security';
-/**
- * SafePassage SDK Main Class
- *
- * Primary SDK class that manages age verification sessions with comprehensive
- * security and error handling. Supports both redirect and new-tab modes with
- * automatic session management and PostMessage communication.
- *
- * The class implements multiple security layers including origin validation,
- * rate limiting, state signing, and comprehensive event logging to ensure
- * secure verification flows.
- */
-export class SafePassage {
-    /**
-     * Initialize SafePassage SDK
-     *
-     * Validates configuration, sets up security measures, and prepares the SDK
-     * for verification operations. Performs comprehensive environment validation
-     * and security initialization.
-     *
-     * @param {SafePassageConfig} config - SDK configuration object
-     * @throws {Error} If configuration validation fails
-     */
-    constructor(config) {
-        this.popupWindow = null;
-        this.messageListener = null;
-        this.popupMonitorInterval = null;
-        this.unloadListener = null;
-        this.isVerificationInProgress = false;
-        this.currentSessionId = null;
-        // Server-provided verify URL (includes sessionToken)
-        this.lastVerifyUrl = null;
-        // Server-provided session token (WS auth)
-        this.lastSessionToken = null;
-        // Temporary storage for QR handoff token to include in state
-        this.temporaryHandoffToken = null;
-        validateConfig(config);
-        // Normalize environment: treat 'development' or any unknown value as 'production'
-        let normalizedEnvironment = config.environment || this.detectEnvironment();
-        if (normalizedEnvironment !== 'staging' && normalizedEnvironment !== 'production') {
-            console.warn(`SafePassage SDK: Unknown environment '${normalizedEnvironment}', defaulting to 'production'`);
-            normalizedEnvironment = 'production';
-        }
-        this.config = Object.assign(Object.assign({}, config), { environment: normalizedEnvironment, mode: config.mode || 'redirect' });
-        // Comprehensive environment security validation
-        validateEnvironmentSecurity(this.config.environment);
-        // Enforce HTTPS in production (additional layer)
-        enforceHTTPS(this.config.environment);
-        // Log initialization for security monitoring
-        logSecurityEvent('SDK_INITIALIZED', {
-            environment: this.config.environment,
-            mode: this.config.mode,
-            origin: window.location.origin,
-            protocol: window.location.protocol,
-            hostname: window.location.hostname,
-        });
-        // Set up automatic cleanup on page unload
-        this.setupAutoCleanup();
-    }
-    /**
-     * Initiate age verification with race condition protection
-     *
-     * Main verification method that handles session creation, security validation,
-     * and verification flow initiation. Includes race condition protection and
-     * comprehensive error handling.
-     *
-     * For public keys (pk_*), automatically creates sessions via the portal API.
-     * For private keys (sk_*), requires a pre-created sessionId.
-     *
-     * @param {VerificationOptions} [options={}] - Verification options
-     * @param {string} [options.sessionId] - Session ID (required for private keys)
-     * @param {number} [options.challengeAge] - Age challenge override
-     * @param {string} [options.verificationMode] - Verification mode override
-     * @param {string} [options.externalUserId] - External user identifier
-     * @returns {Promise<void>} Promise that resolves when verification is initiated
-     * @throws {Error} If verification cannot be started or is already in progress
-     */
-    async verify(options = {}) {
-        var _a, _b, _c, _d, _e, _f;
-        const isPublicKey = this.isPublicKey();
-        // For public keys, create session via API (SafePassage generates the sessionId)
-        let sessionId;
-        if (isPublicKey) {
-            sessionId = await this.createInternalSession(options);
-        }
-        else {
-            // Private keys should use the direct API, not the SDK
-            throw new Error('Private API keys (sk_) should use the direct API, not the SDK. ' +
-                'The SDK is designed for browser-based public key usage only.');
-        }
-        if (!sessionId) {
-            throw new Error('Failed to obtain sessionId from server');
-        }
-        // Race condition check - prevent multiple simultaneous verifications
-        if (this.isVerificationInProgress) {
-            const error = new Error(`Verification already in progress for session ${(_a = this.currentSessionId) === null || _a === void 0 ? void 0 : _a.substring(0, 8)}...`);
-            logSecurityEvent('RACE_CONDITION_PREVENTED', {
-                currentSession: ((_b = this.currentSessionId) === null || _b === void 0 ? void 0 : _b.substring(0, 8)) + '...',
-                attemptedSession: 'new-session-attempt',
-                origin: window.location.origin,
-            });
-            (_d = (_c = this.config).onError) === null || _d === void 0 ? void 0 : _d.call(_c, error);
-            throw error;
-        }
-        // Lock verification process
-        this.isVerificationInProgress = true;
-        this.currentSessionId = sessionId;
-        try {
-            // Rate limiting check
-            const rateLimitKey = `${this.config.apiKey}:${window.location.origin}`;
-            if (!verificationRateLimit.isAllowed(rateLimitKey)) {
-                const error = new Error('Too many verification attempts. Please wait before trying again.');
-                logSecurityEvent('RATE_LIMIT_EXCEEDED', {
-                    apiKey: this.config.apiKey.substring(0, 8) + '...',
-                    origin: window.location.origin,
-                    sessionId: sessionId
-                        ? sessionId.substring(0, 8) + '...'
-                        : 'undefined',
-                });
-                (_f = (_e = this.config).onError) === null || _f === void 0 ? void 0 : _f.call(_e, error);
-                throw error;
-            }
-            const verificationUrl = await this.buildVerificationUrl(options, sessionId);
-            // Log verification attempt
-            logSecurityEvent('VERIFICATION_INITIATED', {
-                environment: this.config.environment,
-                mode: this.config.mode,
-                sessionId: sessionId ? sessionId.substring(0, 8) + '...' : 'undefined',
-                origin: window.location.origin,
-            });
-            if (this.config.mode === 'new-tab') {
-                this.openNewTab(verificationUrl, sessionId);
-            }
-            else {
-                // For redirect mode, unlock immediately since we're leaving the page
-                this.unlockVerification();
-                this.redirect(verificationUrl);
-            }
-        }
-        catch (error) {
-            // Always unlock on error
-            this.unlockVerification();
-            throw error;
-        }
-    }
-    /**
-     * Build verification URL with HMAC-signed state
-     *
-     * Constructs the verification URL with signed state parameter containing
-     * all necessary configuration and security information. The state parameter
-     * includes HMAC signature for integrity protection.
-     *
-     * @param {VerificationOptions} options - Verification options
-     * @returns {Promise<string>} Complete verification URL
-     * @private
-     */
-    async buildVerificationUrl(options, sessionId) {
-        const baseUrl = getEnvironmentUrl(this.config.environment);
-        // Determine if we have explicit overrides
-        const hasExplicitChallengeAge = options.challengeAge !== undefined;
-        const hasExplicitVerificationMode = options.verificationMode !== undefined;
-        const hasOverrides = hasExplicitChallengeAge || hasExplicitVerificationMode;
-        const state = await generateState({
-            merchantId: this.config.apiKey,
-            sessionId,
-            returnUrl: this.config.returnUrl,
-            cancelUrl: this.config.cancelUrl,
-            challengeAge: options.challengeAge || this.config.defaultChallengeAge,
-            verificationMode: options.verificationMode || this.config.defaultVerificationMode,
-            hasOverrides: hasOverrides, // Flag to indicate explicit overrides
-            externalUserId: options.externalUserId,
-            timestamp: Date.now(),
-            // Phase 2: Include config for self-contained verify-ui
-            apiUrl: this.getPortalApiUrl(),
-            engineUrl: this.getEngineUrl(),
-            wsUrl: this.getWebSocketUrl(),
-            environment: this.config.environment,
-            features: {
-                testMode: false,
-                warmupPeriodMs: 500,
-                qualityThreshold: 0.6,
-            },
-            // Include handoffToken if available (for QR code desktop flow)
-            handoffToken: this.temporaryHandoffToken || undefined,
-            // Include sessionToken and verifyUrl to make UI auth deterministic
-            sessionToken: this.lastSessionToken || undefined,
-            verifyUrl: this.lastVerifyUrl || undefined,
-        }, this.config.environment);
-        // Prefer server-provided verifyUrl (contains sessionToken) and append state/mode
-        if (this.lastVerifyUrl) {
-            try {
-                const url = new URL(this.lastVerifyUrl);
-                url.searchParams.set('state', state);
-                url.searchParams.set('mode', this.config.mode);
-                // Append skip parameters if provided
-                if (options.skipIntro) {
-                    url.searchParams.set('skip_intro', 'true');
-                }
-                if (options.autoReturn) {
-                    url.searchParams.set('auto_return', 'true');
-                }
-                return url.toString();
-            }
-            catch (_a) {
-                // Fall back to client-constructed URL if parsing fails
-            }
-        }
-        // Client-constructed URL fallback (for backwards compatibility)
-        const params = new URLSearchParams({ state, sessionId, mode: this.config.mode });
-        // Append skip parameters if provided
-        if (options.skipIntro) {
-            params.set('skip_intro', 'true');
-        }
-        if (options.autoReturn) {
-            params.set('auto_return', 'true');
-        }
-        return `${baseUrl}/?${params.toString()}`;
-    }
-    /**
-     * Redirect in same tab
-     *
-     * Performs a full page redirect to the verification URL.
-     * Used for redirect mode verification.
-     *
-     * @param {string} url - Verification URL to redirect to
-     * @private
-     */
-    redirect(url) {
-        window.location.href = url;
-    }
-    /**
-     * Open in new tab with PostMessage communication and proper cleanup
-     *
-     * Opens verification URL in a new tab/window and sets up secure PostMessage
-     * communication for receiving verification results. Includes comprehensive
-     * security validation and automatic cleanup.
-     *
-     * @param {string} url - Verification URL to open
-     * @param {string} sessionId - Session ID for result correlation
-     * @private
-     */
-    openNewTab(url, sessionId) {
-        var _a, _b;
-        // Clean up any existing resources
-        this.cleanup();
-        // Clear any existing popup monitor interval
-        if (this.popupMonitorInterval) {
-            clearInterval(this.popupMonitorInterval);
-            this.popupMonitorInterval = null;
-        }
-        // Open new tab
-        this.popupWindow = window.open(url, 'safepassage-verify', 'width=600,height=700');
-        if (!this.popupWindow) {
-            (_b = (_a = this.config).onError) === null || _b === void 0 ? void 0 : _b.call(_a, new Error('Failed to open verification window. Please check popup blocker settings.'));
-            return;
-        }
-        // Set up PostMessage listener with enhanced security
-        this.messageListener = (event) => {
-            var _a, _b, _c, _d, _e, _f, _g;
-            // First: Check if this is a SafePassage message (has our message type prefix)
-            // Silently ignore non-SafePassage messages (browser extensions, other libraries)
-            const messageType = (_a = event.data) === null || _a === void 0 ? void 0 : _a.type;
-            if (!messageType || typeof messageType !== 'string' || !messageType.startsWith('safepassage:')) {
-                // Not a SafePassage message - silently ignore
-                return;
-            }
-            // Enhanced origin validation with strict allowlist (only for SafePassage messages)
-            if (!validatePostMessageOrigin(event, this.config.environment)) {
-                logSecurityEvent('POSTMESSAGE_ORIGIN_BLOCKED', {
-                    origin: event.origin,
-                    environment: this.config.environment,
-                    expectedOrigins: `SafePassage trusted origins for ${this.config.environment}`,
-                    messageType: (_b = event.data) === null || _b === void 0 ? void 0 : _b.type,
-                });
-                return;
-            }
-            // Enhanced message validation
-            const messageValidation = validateSafePassageMessage(event, sessionId);
-            if (!messageValidation.isValid) {
-                logSecurityEvent('POSTMESSAGE_VALIDATION_FAILED', {
-                    error: messageValidation.error,
-                    origin: event.origin,
-                    sessionId: sessionId.substring(0, 8) + '...',
-                    messageType: (_c = event.data) === null || _c === void 0 ? void 0 : _c.type,
-                });
-                return;
-            }
-            const result = {
-                sessionId: event.data.sessionId,
-                status: event.data.status,
-                timestamp: event.data.timestamp,
-                externalUserId: event.data.externalUserId,
-            };
-            // Log successful verification completion
-            logSecurityEvent('VERIFICATION_COMPLETED', {
-                status: result.status,
-                sessionId: sessionId.substring(0, 8) + '...',
-                origin: event.origin,
-            });
-            // Clean up resources but keep the popup open for post-verification actions
-            this.cleanup({ closePopup: false });
-            // Unlock verification after successful completion
-            this.unlockVerification();
-            // Clear monitoring interval
-            if (this.popupMonitorInterval) {
-                clearInterval(this.popupMonitorInterval);
-                this.popupMonitorInterval = null;
-            }
-            // Trigger appropriate callback
-            if (result.status === 'verified') {
-                (_e = (_d = this.config).onComplete) === null || _e === void 0 ? void 0 : _e.call(_d, result);
-            }
-            else {
-                // Status is 'failed' - trigger error callback
-                (_g = (_f = this.config).onError) === null || _g === void 0 ? void 0 : _g.call(_f, new Error(`Verification failed: ${result.status}`));
-            }
-        };
-        window.addEventListener('message', this.messageListener);
-        // Monitor popup window with proper cleanup
-        this.popupMonitorInterval = setInterval(() => {
-            var _a, _b;
-            if (this.popupWindow && this.popupWindow.closed) {
-                // Log popup closed event
-                logSecurityEvent('POPUP_CLOSED_BY_USER', {
-                    sessionId: sessionId.substring(0, 8) + '...',
-                    environment: this.config.environment,
-                });
-                // Clean up and trigger cancel callback
-                this.cleanup();
-                // Unlock verification after popup closed
-                this.unlockVerification();
-                (_b = (_a = this.config).onCancel) === null || _b === void 0 ? void 0 : _b.call(_a);
-            }
-        }, 500);
-    }
-    /**
-     * Set up automatic cleanup on page unload to prevent memory leaks
-     *
-     * Registers event listeners for page unload events to ensure proper
-     * cleanup of resources and verification state. Handles both traditional
-     * page navigation and single-page application route changes.
-     *
-     * @private
-     */
-    setupAutoCleanup() {
-        this.unloadListener = () => {
-            // Log automatic cleanup
-            logSecurityEvent('SDK_AUTO_CLEANUP', {
-                environment: this.config.environment,
-                trigger: 'page_unload',
-            });
-            // Clean up all resources and unlock verification
-            this.cleanup();
-            this.unlockVerification();
-        };
-        // Listen for page unload events
-        window.addEventListener('beforeunload', this.unloadListener);
-        window.addEventListener('pagehide', this.unloadListener);
-        // For single-page applications, also listen for route changes
-        if (window.history && window.history.pushState) {
-            const originalPushState = window.history.pushState;
-            window.history.pushState = (...args) => {
-                this.cleanup();
-                this.unlockVerification();
-                return originalPushState.apply(window.history, args);
-            };
-        }
-    }
-    /**
-     * Auto-detect environment based on current URL
-     *
-     * Analyzes the current hostname to determine the appropriate environment
-     * configuration. Used when environment is not explicitly specified.
-     * Always defaults to production unless staging is detected.
-     *
-     * @returns {'production' | 'staging'} Detected environment
-     * @private
-     */
-    detectEnvironment() {
-        const hostname = window.location.hostname;
-        if (hostname.includes('staging') || hostname.includes('stage')) {
-            return 'staging';
-        }
-        return 'production';
-    }
-    /**
-     * Get the current environment
-     * @returns {string} The current environment (production or staging)
-     */
-    getEnvironment() {
-        return this.config.environment;
-    }
-    /**
-     * Unlock verification process to allow new verifications
-     *
-     * Resets the verification lock state to allow new verification attempts.
-     * Called after successful completion, errors, or cleanup.
-     *
-     * @private
-     */
-    unlockVerification() {
-        this.isVerificationInProgress = false;
-        this.currentSessionId = null;
-        logSecurityEvent('VERIFICATION_UNLOCKED', {
-            environment: this.config.environment,
-            origin: window.location.origin,
-        });
-    }
-    /**
-     * Internal cleanup method to prevent memory leaks
-     *
-     * Cleans up popup windows, event listeners, and intervals.
-     * Does not unlock verification state - that's handled by specific callers.
-     *
-     * @private
-     */
-    cleanup(options = {}) {
-        const shouldClosePopup = options.closePopup !== false;
-        // Close popup window unless we're intentionally keeping it open
-        if (this.popupWindow) {
-            if (shouldClosePopup && !this.popupWindow.closed) {
-                this.popupWindow.close();
-            }
-            if (shouldClosePopup || this.popupWindow.closed) {
-                this.popupWindow = null;
-            }
-        }
-        // Remove message listener
-        if (this.messageListener) {
-            window.removeEventListener('message', this.messageListener);
-            this.messageListener = null;
-        }
-        // Clear monitoring interval
-        if (this.popupMonitorInterval) {
-            clearInterval(this.popupMonitorInterval);
-            this.popupMonitorInterval = null;
-        }
-        // Note: Verification unlocking is handled by specific callers
-    }
-    /**
-     * Remove auto-cleanup listeners
-     *
-     * Removes page unload event listeners that were set up for automatic cleanup.
-     *
-     * @private
-     */
-    removeAutoCleanupListeners() {
-        if (this.unloadListener) {
-            window.removeEventListener('beforeunload', this.unloadListener);
-            window.removeEventListener('pagehide', this.unloadListener);
-            this.unloadListener = null;
-        }
-    }
-    /**
-     * Public cleanup method for manual resource management
-     *
-     * Completely destroys the SDK instance, cleaning up all resources and
-     * removing all event listeners. Should be called when the SDK is no longer needed.
-     *
-     * @public
-     */
-    destroy() {
-        // Log destruction for security monitoring
-        logSecurityEvent('SDK_DESTROYED', {
-            environment: this.config.environment,
-            origin: window.location.origin,
-        });
-        // Clean up all resources
-        this.cleanup();
-        // Unlock verification
-        this.unlockVerification();
-        // Remove auto-cleanup listeners
-        this.removeAutoCleanupListeners();
-    }
-    /**
-     * Get Portal API URL based on environment
-     *
-     * Returns the appropriate portal-api URL for the current environment.
-     *
-     * @returns {string} Portal API URL
-     * @private
-     */
-    getPortalApiUrl() {
-        switch (this.config.environment) {
-            case 'staging':
-                return 'https://api.staging.safepassageapp.com';
-            case 'production':
-                return 'https://api.safepassageapp.com';
-            default:
-                return 'https://api.safepassageapp.com';
-        }
-    }
-    /**
-     * Get Engine URL based on environment
-     *
-     * Returns the appropriate verify-engine URL for the current environment.
-     * In production, engine access is proxied through portal-api.
-     *
-     * @returns {string} Engine URL
-     * @private
-     */
-    getEngineUrl() {
-        switch (this.config.environment) {
-            case 'staging':
-                return 'https://engine.staging.safepassageapp.com';
-            case 'production':
-                // Direct access to verify-engine
-                return 'https://engine.safepassageapp.com';
-            default:
-                return 'https://engine.safepassageapp.com';
-        }
-    }
-    /**
-     * Get WebSocket URL based on environment
-     *
-     * Returns the appropriate WebSocket URL for the current environment.
-     * In production, WebSocket connections are proxied through portal-api.
-     *
-     * @returns {string} WebSocket URL
-     * @private
-     */
-    getWebSocketUrl() {
-        switch (this.config.environment) {
-            case 'staging':
-                return 'wss://engine.staging.safepassageapp.com/api/websocket/stream';
-            case 'production':
-                // Direct WebSocket connection to verify-engine
-                return 'wss://engine.safepassageapp.com/api/websocket/stream';
-            default:
-                return 'wss://engine.safepassageapp.com/api/websocket/stream';
-        }
-    }
-    /**
-     * Detect if this is a public key (pk_ prefix) vs private key (sk_ prefix)
-     *
-     * Determines API key type based on prefix to handle different authentication flows.
-     *
-     * @returns {boolean} True if public key, false if private key
-     * @private
-     */
-    isPublicKey() {
-        return this.config.apiKey.startsWith('pk_');
-    }
-    /**
-     * Create session internally for public keys
-     *
-     * Creates a verification session via the portal API for public key authentication.
-     * Generates a UUID session ID and submits session creation request with
-     * verification parameters.
-     *
-     * @param {VerificationOptions} options - Verification options
-     * @returns {Promise<string>} Created session ID
-     * @throws {Error} If session creation fails
-     * @private
-     */
-    async createInternalSession(options) {
-        var _a, _b;
-        try {
-            const portalApiUrl = this.getPortalApiUrl();
-            const response = await fetch(`${portalApiUrl}/api/v1/sessions/create`, {
-                method: 'POST',
-                headers: {
-                    'Content-Type': 'application/json',
-                    Authorization: `Bearer ${this.config.apiKey}`,
-                },
-                body: JSON.stringify({
-                    merchantId: this.config.apiKey, // API expects merchantId even though it uses auth header
-                    returnUrl: this.config.returnUrl,
-                    cancelUrl: this.config.cancelUrl,
-                    challengeAge: options.challengeAge,
-                    verificationMode: options.verificationMode,
-                    merchantName: document.title || window.location.hostname,
-                    externalUserId: options.externalUserId,
-                }),
-            });
-            if (!response.ok) {
-                const errorData = await response.json().catch(() => ({}));
-                throw new Error(`Failed to create session: ${response.status} ${response.statusText}. ${errorData.message || ''}`);
-            }
-            const sessionData = await response.json();
-            // SafePassage now generates the sessionId internally
-            const sessionId = sessionData.sessionId;
-            if (!sessionId) {
-                throw new Error('Server did not return a sessionId');
-            }
-            // Capture verifyUrl from server for redirect (ensures sessionToken is present)
-            if (sessionData.verifyUrl) {
-                this.lastVerifyUrl = sessionData.verifyUrl;
-            }
-            // Capture sessionToken for state payload (ensures UI can always auth WS)
-            if (sessionData.sessionToken) {
-                this.lastSessionToken = sessionData.sessionToken;
-            }
-            // Store the handoffToken if it exists for desktop QR flow
-            if (sessionData.handoffToken) {
-                // Store it temporarily so it can be included in the state
-                this.temporaryHandoffToken = sessionData.handoffToken;
-            }
-            // Log successful session creation
-            logSecurityEvent('INTERNAL_SESSION_CREATED', {
-                sessionId: sessionId.substring(0, 8) + '...',
-                environment: this.config.environment,
-                apiKeyType: 'public',
-            });
-            return sessionId;
-        }
-        catch (error) {
-            const errorMessage = error instanceof Error ? error.message : String(error);
-            logSecurityEvent('INTERNAL_SESSION_FAILED', {
-                error: errorMessage,
-                environment: this.config.environment,
-                apiKeyType: 'public',
-            });
-            (_b = (_a = this.config).onError) === null || _b === void 0 ? void 0 : _b.call(_a, error);
-            throw new Error(`Failed to create verification session: ${errorMessage}`);
-        }
-    }
-}
-// For backwards compatibility
-export default SafePassage;

package/dist/index.d.ts

@@ -1,21 +0,0 @@
-/**
- * SafePassage SDK - Redirect-based age verification
- *
- * @example
- * ```javascript
- * // Initialize SDK
- * const sp = new SafePassage({
- *   apiKey: 'pk_xxxxx',
- *   returnUrl: 'https://merchant.com/verified',
- *   cancelUrl: 'https://merchant.com/cancelled'
- * });
- *
- * // Trigger verification
- * sp.verify({
- *   sessionId: generateUUID() // Merchant-generated UUID v4
- * });
- * ```
- */
-export { SafePassage, SafePassage as default } from './core/SafePassageSDK';
-export type { SafePassageConfig, VerificationOptions, VerificationResult, SessionValidationResponse, } from './types';
-export declare const VERSION = "3.4.8";