playe-developer-sdk 1.0.0

package/dist/index.cjs.js

@@ -0,0 +1,759 @@
+'use strict';
+
+class HttpClient {
+    config;
+    baseHeaders;
+    constructor(config) {
+        this.config = config;
+        this.baseHeaders = {
+            'Content-Type': 'application/json',
+            'User-Agent': 'Playe-Developer-SDK/1.0.0',
+        };
+        if (config.apiKey) {
+            this.baseHeaders['Authorization'] = `Bearer ${config.apiKey}`;
+        }
+    }
+    async request(endpoint, options = {}) {
+        const url = `${this.config.apiBaseUrl}${endpoint}`;
+        const timeout = options.timeout || this.config.timeoutMs || 30000;
+        const retries = options.retries || this.config.retryAttempts || 3;
+        const requestOptions = {
+            method: options.method || 'GET',
+            headers: {
+                ...this.baseHeaders,
+                ...options.headers,
+            },
+            signal: AbortSignal.timeout(timeout),
+        };
+        if (options.body && options.method !== 'GET') {
+            requestOptions.body = JSON.stringify(options.body);
+        }
+        let lastError;
+        for (let attempt = 0; attempt <= retries; attempt++) {
+            try {
+                if (this.config.enableDebugMode) {
+                    console.log(`[Playe SDK] ${options.method || 'GET'} ${url}`, {
+                        attempt: attempt + 1,
+                        body: options.body,
+                    });
+                }
+                const response = await fetch(url, requestOptions);
+                if (!response.ok) {
+                    const errorText = await response.text();
+                    throw new Error(`HTTP ${response.status}: ${errorText}`);
+                }
+                const data = await response.json();
+                if (this.config.enableDebugMode) {
+                    console.log(`[Playe SDK] Response:`, data);
+                }
+                return data;
+            }
+            catch (error) {
+                lastError = error;
+                if (this.config.enableDebugMode) {
+                    console.warn(`[Playe SDK] Request failed (attempt ${attempt + 1}/${retries + 1}):`, error);
+                }
+                // Don't retry on client errors (4xx)
+                if (error instanceof Error && error.message.includes('HTTP 4')) {
+                    break;
+                }
+                // Wait before retry (exponential backoff)
+                if (attempt < retries) {
+                    await new Promise(resolve => setTimeout(resolve, Math.pow(2, attempt) * 1000));
+                }
+            }
+        }
+        throw lastError;
+    }
+    async get(endpoint, options) {
+        return this.request(endpoint, { ...options, method: 'GET' });
+    }
+    async post(endpoint, body, options) {
+        return this.request(endpoint, { ...options, method: 'POST', body });
+    }
+    async put(endpoint, body, options) {
+        return this.request(endpoint, { ...options, method: 'PUT', body });
+    }
+    async delete(endpoint, options) {
+        return this.request(endpoint, { ...options, method: 'DELETE' });
+    }
+    async patch(endpoint, body, options) {
+        return this.request(endpoint, { ...options, method: 'PATCH', body });
+    }
+}
+
+class PlayeSDKError extends Error {
+    originalError;
+    context;
+    timestamp;
+    constructor(message, originalError, context) {
+        super(message);
+        this.name = 'PlayeSDKError';
+        this.originalError = originalError;
+        this.context = context;
+        this.timestamp = new Date().toISOString();
+        // Maintains proper stack trace for where our error was thrown (only available on V8)
+        if (Error.captureStackTrace) {
+            Error.captureStackTrace(this, PlayeSDKError);
+        }
+    }
+    static fromError(error, context) {
+        return new PlayeSDKError(error.message, error, context);
+    }
+    toJSON() {
+        return {
+            name: this.name,
+            message: this.message,
+            context: this.context,
+            timestamp: this.timestamp,
+            stack: this.stack,
+            originalError: this.originalError ? {
+                name: this.originalError.name,
+                message: this.originalError.message,
+                stack: this.originalError.stack,
+            } : undefined,
+        };
+    }
+}
+class ValidationError extends PlayeSDKError {
+    constructor(message, context) {
+        super(message, undefined, context);
+        this.name = 'ValidationError';
+    }
+}
+class NetworkError extends PlayeSDKError {
+    constructor(message, originalError, context) {
+        super(message, originalError, context);
+        this.name = 'NetworkError';
+    }
+}
+class AuthenticationError extends PlayeSDKError {
+    constructor(message, context) {
+        super(message, undefined, context);
+        this.name = 'AuthenticationError';
+    }
+}
+class GameSessionError extends PlayeSDKError {
+    constructor(message, context) {
+        super(message, undefined, context);
+        this.name = 'GameSessionError';
+    }
+}
+
+class DeviceUtils {
+    /**
+     * Automatically detect device information from the browser
+     */
+    static getDeviceInfo() {
+        const deviceInfo = {};
+        if (typeof navigator !== 'undefined') {
+            deviceInfo.userAgent = navigator.userAgent;
+            deviceInfo.platform = navigator.platform;
+            deviceInfo.language = navigator.language;
+            deviceInfo.touchSupported = 'ontouchstart' in window || navigator.maxTouchPoints > 0;
+        }
+        if (typeof screen !== 'undefined') {
+            deviceInfo.screenResolution = `${screen.width}x${screen.height}`;
+        }
+        if (typeof Intl !== 'undefined') {
+            try {
+                deviceInfo.timezone = Intl.DateTimeFormat().resolvedOptions().timeZone;
+            }
+            catch (error) {
+                // Fallback for older browsers
+                deviceInfo.timezone = 'Unknown';
+            }
+        }
+        return deviceInfo;
+    }
+    /**
+     * Get current geolocation data
+     */
+    static async getGeolocationData() {
+        return new Promise((resolve, reject) => {
+            if (!navigator.geolocation) {
+                reject(new Error('Geolocation is not supported by this browser'));
+                return;
+            }
+            navigator.geolocation.getCurrentPosition((position) => {
+                resolve({
+                    latitude: position.coords.latitude,
+                    longitude: position.coords.longitude,
+                    accuracy: position.coords.accuracy,
+                    timestamp: new Date().toISOString(),
+                });
+            }, (error) => {
+                reject(new Error(`Geolocation error: ${error.message}`));
+            }, {
+                enableHighAccuracy: true,
+                timeout: 10000,
+                maximumAge: 300000, // 5 minutes
+            });
+        });
+    }
+    /**
+     * Generate a simple browser fingerprint
+     */
+    static generateFingerprint() {
+        const components = [];
+        if (typeof navigator !== 'undefined') {
+            components.push(navigator.userAgent);
+            components.push(navigator.language);
+            components.push(navigator.platform);
+            components.push(navigator.cookieEnabled.toString());
+        }
+        if (typeof screen !== 'undefined') {
+            components.push(`${screen.width}x${screen.height}`);
+            components.push(screen.colorDepth.toString());
+        }
+        if (typeof window !== 'undefined') {
+            components.push(window.devicePixelRatio?.toString() || '1');
+        }
+        // Add timezone
+        try {
+            components.push(Intl.DateTimeFormat().resolvedOptions().timeZone);
+        }
+        catch (error) {
+            components.push('Unknown');
+        }
+        // Simple hash function
+        const str = components.join('|');
+        let hash = 0;
+        for (let i = 0; i < str.length; i++) {
+            const char = str.charCodeAt(i);
+            hash = ((hash << 5) - hash) + char;
+            hash = hash & hash; // Convert to 32-bit integer
+        }
+        return Math.abs(hash).toString(36);
+    }
+    /**
+     * Check if the current environment is a browser
+     */
+    static isBrowser() {
+        return typeof window !== 'undefined' && typeof document !== 'undefined';
+    }
+    /**
+     * Check if the device supports specific features
+     */
+    static getFeatureSupport() {
+        return {
+            geolocation: 'geolocation' in navigator,
+            camera: 'mediaDevices' in navigator && 'getUserMedia' in navigator.mediaDevices,
+            localStorage: typeof Storage !== 'undefined',
+            webGL: (() => {
+                try {
+                    const canvas = document.createElement('canvas');
+                    return !!(canvas.getContext('webgl') || canvas.getContext('experimental-webgl'));
+                }
+                catch (e) {
+                    return false;
+                }
+            })(),
+            webWorkers: typeof Worker !== 'undefined',
+            notifications: 'Notification' in window,
+            serviceWorker: 'serviceWorker' in navigator,
+        };
+    }
+}
+
+class ValidationUtils {
+    /**
+     * Validate initialization parameters
+     */
+    static validateInitializeParams(params) {
+        if (!params.campaignId || typeof params.campaignId !== 'string') {
+            throw new ValidationError('campaignId is required and must be a string');
+        }
+        if (!params.gameId || typeof params.gameId !== 'string') {
+            throw new ValidationError('gameId is required and must be a string');
+        }
+        if (!params.playerFingerprint || typeof params.playerFingerprint !== 'string') {
+            throw new ValidationError('playerFingerprint is required and must be a string');
+        }
+        if (params.playerEmail && !this.isValidEmail(params.playerEmail)) {
+            throw new ValidationError('playerEmail must be a valid email address');
+        }
+        if (params.receiptImage && !this.isValidBase64(params.receiptImage)) {
+            throw new ValidationError('receiptImage must be a valid base64 string');
+        }
+        if (params.geolocationData) {
+            this.validateGeolocationData(params.geolocationData);
+        }
+    }
+    /**
+     * Validate progress update parameters
+     */
+    static validateProgressParams(params) {
+        if (typeof params.currentScore !== 'number' || params.currentScore < 0) {
+            throw new ValidationError('currentScore must be a non-negative number');
+        }
+        if (typeof params.elapsedTime !== 'number' || params.elapsedTime < 0) {
+            throw new ValidationError('elapsedTime must be a non-negative number');
+        }
+        if (params.clientTimestamp && !this.isValidISODate(params.clientTimestamp)) {
+            throw new ValidationError('clientTimestamp must be a valid ISO date string');
+        }
+        if (params.achievements) {
+            params.achievements.forEach((achievement, index) => {
+                if (!achievement.id || typeof achievement.id !== 'string') {
+                    throw new ValidationError(`Achievement at index ${index} must have a valid id`);
+                }
+                if (!achievement.name || typeof achievement.name !== 'string') {
+                    throw new ValidationError(`Achievement at index ${index} must have a valid name`);
+                }
+                if (!achievement.unlockedAt || !this.isValidISODate(achievement.unlockedAt)) {
+                    throw new ValidationError(`Achievement at index ${index} must have a valid unlockedAt date`);
+                }
+            });
+        }
+    }
+    /**
+     * Validate game completion parameters
+     */
+    static validateCompleteParams(params) {
+        if (typeof params.finalScore !== 'number' || params.finalScore < 0) {
+            throw new ValidationError('finalScore must be a non-negative number');
+        }
+        if (params.gameMetrics) {
+            const metrics = params.gameMetrics;
+            if (typeof metrics.totalPlayTime !== 'number' || metrics.totalPlayTime < 0) {
+                throw new ValidationError('gameMetrics.totalPlayTime must be a non-negative number');
+            }
+            if (typeof metrics.actionsPerformed !== 'number' || metrics.actionsPerformed < 0) {
+                throw new ValidationError('gameMetrics.actionsPerformed must be a non-negative number');
+            }
+            if (typeof metrics.powerUpsUsed !== 'number' || metrics.powerUpsUsed < 0) {
+                throw new ValidationError('gameMetrics.powerUpsUsed must be a non-negative number');
+            }
+            if (typeof metrics.levelsCompleted !== 'number' || metrics.levelsCompleted < 0) {
+                throw new ValidationError('gameMetrics.levelsCompleted must be a non-negative number');
+            }
+        }
+    }
+    /**
+     * Validate session ID format
+     */
+    static validateSessionId(sessionId) {
+        if (!sessionId || typeof sessionId !== 'string') {
+            throw new ValidationError('sessionId is required and must be a string');
+        }
+        if (sessionId.length < 10) {
+            throw new ValidationError('sessionId appears to be invalid (too short)');
+        }
+    }
+    /**
+     * Validate email format
+     */
+    static isValidEmail(email) {
+        const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+        return emailRegex.test(email);
+    }
+    /**
+     * Validate base64 format
+     */
+    static isValidBase64(str) {
+        try {
+            return btoa(atob(str)) === str;
+        }
+        catch (err) {
+            return false;
+        }
+    }
+    /**
+     * Validate ISO date string
+     */
+    static isValidISODate(dateString) {
+        const date = new Date(dateString);
+        return date instanceof Date && !isNaN(date.getTime()) && date.toISOString() === dateString;
+    }
+    /**
+     * Validate geolocation data
+     */
+    static validateGeolocationData(data) {
+        if (typeof data.latitude !== 'number' || data.latitude < -90 || data.latitude > 90) {
+            throw new ValidationError('geolocationData.latitude must be a number between -90 and 90');
+        }
+        if (typeof data.longitude !== 'number' || data.longitude < -180 || data.longitude > 180) {
+            throw new ValidationError('geolocationData.longitude must be a number between -180 and 180');
+        }
+        if (typeof data.accuracy !== 'number' || data.accuracy < 0) {
+            throw new ValidationError('geolocationData.accuracy must be a non-negative number');
+        }
+        if (!data.timestamp || !this.isValidISODate(data.timestamp)) {
+            throw new ValidationError('geolocationData.timestamp must be a valid ISO date string');
+        }
+    }
+    /**
+     * Sanitize user input to prevent XSS
+     */
+    static sanitizeString(input) {
+        return input
+            .replace(/[<>]/g, '')
+            .replace(/javascript:/gi, '')
+            .replace(/on\w+=/gi, '')
+            .trim();
+    }
+    /**
+     * Validate score against potential cheating patterns
+     */
+    static validateScore(score, previousScore = 0, timeElapsed = 0) {
+        // Basic sanity checks
+        if (score < 0 || !Number.isFinite(score)) {
+            return false;
+        }
+        // Check for impossible score increases
+        const scoreDiff = score - previousScore;
+        if (timeElapsed > 0 && scoreDiff > 0) {
+            const scoreRate = scoreDiff / timeElapsed; // points per second
+            // This is a basic example - you'd want more sophisticated checks
+            if (scoreRate > 1000) { // More than 1000 points per second seems suspicious
+                return false;
+            }
+        }
+        return true;
+    }
+}
+
+class PlayeDeveloperSDK {
+    httpClient;
+    config;
+    currentSession = null;
+    heartbeatInterval = null;
+    _isDemo = false;
+    constructor(config) {
+        this.validateConfig(config);
+        this.config = { ...this.getDefaultConfig(), ...config };
+        this.httpClient = new HttpClient(this.config);
+        if (this.config.enableDebugMode) {
+            console.log('[Playe SDK] Initialized with config:', {
+                apiBaseUrl: this.config.apiBaseUrl,
+                enableDebugMode: this.config.enableDebugMode,
+                retryAttempts: this.config.retryAttempts,
+                timeoutMs: this.config.timeoutMs,
+            });
+        }
+    }
+    // Core session management
+    async initializeGameSession(params) {
+        try {
+            ValidationUtils.validateInitializeParams(params);
+            // Auto-detect device info if not provided
+            if (!params.deviceInfo) {
+                params.deviceInfo = DeviceUtils.getDeviceInfo();
+            }
+            const response = await this.httpClient.post('/api/game-sessions/initialize', params);
+            if (this.config.enableDebugMode) {
+                console.log('[Playe SDK] Game session initialized:', response.sessionId);
+            }
+            return response;
+        }
+        catch (error) {
+            throw this.handleError(error, 'Failed to initialize game session');
+        }
+    }
+    async startGameSession(sessionId, config) {
+        try {
+            ValidationUtils.validateSessionId(sessionId);
+            const response = await this.httpClient.post(`/api/game-sessions/${sessionId}/start`, {
+                config,
+                startTime: new Date().toISOString(),
+            });
+            // Start automatic heartbeat
+            this.startHeartbeat(sessionId);
+            if (this.config.enableDebugMode) {
+                console.log('[Playe SDK] Game session started:', sessionId);
+            }
+            return response;
+        }
+        catch (error) {
+            throw this.handleError(error, 'Failed to start game session');
+        }
+    }
+    async updateGameProgress(sessionId, progressData) {
+        try {
+            ValidationUtils.validateSessionId(sessionId);
+            ValidationUtils.validateProgressParams(progressData);
+            // Add client timestamp if not provided
+            if (!progressData.clientTimestamp) {
+                progressData.clientTimestamp = new Date().toISOString();
+            }
+            const response = await this.httpClient.post(`/api/game-sessions/${sessionId}/progress`, progressData);
+            if (this.config.enableDebugMode) {
+                console.log('[Playe SDK] Progress updated:', {
+                    sessionId,
+                    score: progressData.currentScore,
+                    rank: response.currentRank,
+                });
+            }
+            return response;
+        }
+        catch (error) {
+            throw this.handleError(error, 'Failed to update game progress');
+        }
+    }
+    async completeGame(sessionId, completionData) {
+        try {
+            ValidationUtils.validateSessionId(sessionId);
+            ValidationUtils.validateCompleteParams(completionData);
+            const response = await this.httpClient.post(`/api/game-sessions/${sessionId}/complete`, {
+                ...completionData,
+                completionTime: new Date().toISOString(),
+            });
+            // Stop heartbeat
+            this.stopHeartbeat();
+            if (this.config.enableDebugMode) {
+                console.log('[Playe SDK] Game completed:', {
+                    sessionId,
+                    isWinner: response.isWinner,
+                    finalRank: response.finalRank,
+                });
+            }
+            return response;
+        }
+        catch (error) {
+            throw this.handleError(error, 'Failed to complete game');
+        }
+    }
+    async abandonGame(sessionId, reason, lastKnownScore) {
+        try {
+            ValidationUtils.validateSessionId(sessionId);
+            const response = await this.httpClient.post(`/api/game-sessions/${sessionId}/abandon`, {
+                reason,
+                lastKnownScore,
+                abandonedAt: new Date().toISOString(),
+            });
+            // Stop heartbeat
+            this.stopHeartbeat();
+            if (this.config.enableDebugMode) {
+                console.log('[Playe SDK] Game abandoned:', sessionId);
+            }
+            return response;
+        }
+        catch (error) {
+            throw this.handleError(error, 'Failed to abandon game');
+        }
+    }
+    // Campaign information
+    async getCampaignStatus(campaignId, playerId) {
+        try {
+            const params = playerId ? `?playerId=${encodeURIComponent(playerId)}` : '';
+            return await this.httpClient.get(`/api/campaigns/${campaignId}/status${params}`);
+        }
+        catch (error) {
+            throw this.handleError(error, 'Failed to get campaign status');
+        }
+    }
+    async getLeaderboard(campaignId, limit, playerId) {
+        try {
+            const params = new URLSearchParams();
+            if (limit)
+                params.append('limit', limit.toString());
+            if (playerId)
+                params.append('playerId', playerId);
+            const queryString = params.toString() ? `?${params.toString()}` : '';
+            return await this.httpClient.get(`/api/campaigns/${campaignId}/leaderboard${queryString}`);
+        }
+        catch (error) {
+            throw this.handleError(error, 'Failed to get leaderboard');
+        }
+    }
+    async getPlayerAttempts(campaignId, playerId) {
+        try {
+            return await this.httpClient.get(`/api/campaigns/${campaignId}/players/${playerId}/attempts`);
+        }
+        catch (error) {
+            throw this.handleError(error, 'Failed to get player attempts');
+        }
+    }
+    // Validation and anti-cheat
+    async validateGameSession(sessionId, validationData) {
+        try {
+            ValidationUtils.validateSessionId(sessionId);
+            return await this.httpClient.post(`/api/game-sessions/${sessionId}/validate`, {
+                validationData,
+                clientTimestamp: new Date().toISOString(),
+            });
+        }
+        catch (error) {
+            throw this.handleError(error, 'Failed to validate game session');
+        }
+    }
+    async sendHeartbeat(sessionId, currentScore) {
+        try {
+            ValidationUtils.validateSessionId(sessionId);
+            return await this.httpClient.post(`/api/game-sessions/${sessionId}/heartbeat`, {
+                currentScore,
+                clientTimestamp: new Date().toISOString(),
+            });
+        }
+        catch (error) {
+            throw this.handleError(error, 'Failed to send heartbeat');
+        }
+    }
+    // Developer tools
+    async createTestGameSession(testConfig) {
+        try {
+            this._isDemo = true;
+            return await this.httpClient.post('/api/test/game-sessions', {
+                testConfig,
+                createdAt: new Date().toISOString(),
+            });
+        }
+        catch (error) {
+            throw this.handleError(error, 'Failed to create test game session');
+        }
+    }
+    // Legacy compatibility methods
+    async getGameById(id) {
+        try {
+            return await this.httpClient.get(`/api/legacy/games/${id}`);
+        }
+        catch (error) {
+            if (error instanceof Error && error.message.includes('404')) {
+                return null;
+            }
+            throw this.handleError(error, 'Failed to get game by ID');
+        }
+    }
+    async getGameSession() {
+        if (this.currentSession) {
+            return this.currentSession;
+        }
+        throw new GameSessionError('No active game session');
+    }
+    async updateGameSession(gameSession) {
+        try {
+            const response = await this.httpClient.put(`/api/legacy/game-sessions/${gameSession.id}`, gameSession);
+            this.currentSession = response;
+            return response;
+        }
+        catch (error) {
+            throw this.handleError(error, 'Failed to update game session');
+        }
+    }
+    // Utility methods
+    test(text) {
+        const message = text || 'Playe Developer SDK is working!';
+        console.log(`[Playe SDK Test] ${message}`);
+        if (this.config.enableDebugMode) {
+            console.log('[Playe SDK Test] Config:', this.config);
+            console.log('[Playe SDK Test] Device Info:', DeviceUtils.getDeviceInfo());
+            console.log('[Playe SDK Test] Feature Support:', DeviceUtils.getFeatureSupport());
+        }
+    }
+    isDemo() {
+        return this._isDemo;
+    }
+    gameLoadingStart() {
+        if (this.config.enableDebugMode) {
+            console.log('[Playe SDK] Game loading started');
+        }
+        // Emit custom event for tracking
+        if (DeviceUtils.isBrowser()) {
+            window.dispatchEvent(new CustomEvent('playe:game-loading-start'));
+        }
+    }
+    gameLoadingFinished() {
+        if (this.config.enableDebugMode) {
+            console.log('[Playe SDK] Game loading finished');
+        }
+        // Emit custom event for tracking
+        if (DeviceUtils.isBrowser()) {
+            window.dispatchEvent(new CustomEvent('playe:game-loading-finished'));
+        }
+    }
+    gamePlayStop() {
+        if (this.config.enableDebugMode) {
+            console.log('[Playe SDK] Game play stopped');
+        }
+        this.stopHeartbeat();
+        // Emit custom event for tracking
+        if (DeviceUtils.isBrowser()) {
+            window.dispatchEvent(new CustomEvent('playe:game-play-stop'));
+        }
+    }
+    // Private helper methods
+    validateConfig(config) {
+        if (!config.apiBaseUrl) {
+            throw new ValidationError('apiBaseUrl is required in SDK configuration');
+        }
+        try {
+            new URL(config.apiBaseUrl);
+        }
+        catch {
+            throw new ValidationError('apiBaseUrl must be a valid URL');
+        }
+    }
+    getDefaultConfig() {
+        return {
+            enableDebugMode: false,
+            retryAttempts: 3,
+            timeoutMs: 30000,
+            enableOfflineMode: false,
+        };
+    }
+    startHeartbeat(sessionId) {
+        if (this.heartbeatInterval) {
+            clearInterval(this.heartbeatInterval);
+        }
+        this.heartbeatInterval = window.setInterval(async () => {
+            try {
+                await this.sendHeartbeat(sessionId);
+            }
+            catch (error) {
+                if (this.config.enableDebugMode) {
+                    console.warn('[Playe SDK] Heartbeat failed:', error);
+                }
+            }
+        }, 30000); // Send heartbeat every 30 seconds
+    }
+    stopHeartbeat() {
+        if (this.heartbeatInterval) {
+            clearInterval(this.heartbeatInterval);
+            this.heartbeatInterval = null;
+        }
+    }
+    handleError(error, context) {
+        if (error instanceof PlayeSDKError) {
+            return error;
+        }
+        if (error instanceof Error) {
+            // Check for specific error types
+            if (error.message.includes('401') || error.message.includes('403')) {
+                return new AuthenticationError(`Authentication failed: ${error.message}`, context);
+            }
+            if (error.message.includes('network') || error.message.includes('fetch')) {
+                return new NetworkError(`Network error: ${error.message}`, error, context);
+            }
+            return PlayeSDKError.fromError(error, context);
+        }
+        return new PlayeSDKError(`Unknown error: ${String(error)}`, undefined, context);
+    }
+    // Cleanup method
+    destroy() {
+        this.stopHeartbeat();
+        this.currentSession = null;
+        if (this.config.enableDebugMode) {
+            console.log('[Playe SDK] SDK destroyed');
+        }
+    }
+}
+
+// Main SDK exports
+function createPlayeSDK(config) {
+    return new PlayeDeveloperSDK(config);
+}
+// Version
+const VERSION = '1.0.0';
+
+exports.AuthenticationError = AuthenticationError;
+exports.DeviceUtils = DeviceUtils;
+exports.GameSessionError = GameSessionError;
+exports.NetworkError = NetworkError;
+exports.PlayeDeveloperSDK = PlayeDeveloperSDK;
+exports.PlayeSDKError = PlayeSDKError;
+exports.VERSION = VERSION;
+exports.ValidationError = ValidationError;
+exports.ValidationUtils = ValidationUtils;
+exports.createPlayeSDK = createPlayeSDK;
+//# sourceMappingURL=index.cjs.js.map