@explorins/pers-sdk 1.2.6 → 1.3.1

package/dist/core.cjs

@@ -1,820 +1,14 @@
 'use strict';
 
-var persShared = require('@explorins/pers-shared');
+var persSdk = require('./chunks/pers-sdk-_1sTi9x9.cjs');
+require('@explorins/pers-shared');
 
-/**
- * PERS SDK Configuration interfaces
- */
-/**
- * Default configuration values
- */
-const DEFAULT_PERS_CONFIG = {
-    environment: 'production',
-    apiVersion: 'v2',
-    timeout: 30000,
-    retries: 3
-};
-/**
- * Internal function to construct API root from environment
- * Now defaults to production and v2
- */
-function buildApiRoot(environment = 'production', version = 'v2') {
-    const baseUrls = {
-        development: 'https://explorins-loyalty.ngrok.io',
-        staging: `https://dev.api.pers.ninja/${version}`,
-        production: `https://api.pers.ninja/${version}`
-    };
-    return `${baseUrls[environment]}`;
-}
-/**
- * Merge user config with defaults
- */
-function mergeWithDefaults(config) {
-    return {
-        ...DEFAULT_PERS_CONFIG,
-        ...config,
-        environment: config.environment ?? DEFAULT_PERS_CONFIG.environment,
-        apiVersion: config.apiVersion ?? DEFAULT_PERS_CONFIG.apiVersion,
-        timeout: config.timeout ?? DEFAULT_PERS_CONFIG.timeout,
-        retries: config.retries ?? DEFAULT_PERS_CONFIG.retries
-    };
-}
 
-/**
- * Platform-Agnostic Auth Admin API Client
- *
- * Handles authentication and authorization admin operations using the PERS backend.
- * Uses @explorins/pers-shared DTOs for consistency with backend.
- *
- * Note: Special header handling (bypass-auth-interceptor) may need to be implemented
- * at the PersApiClient level or through a specialized auth client.
- */
-class AuthApi {
-    constructor(apiClient) {
-        this.apiClient = apiClient;
-        this.basePath = '/auth';
-    }
-    // ==========================================
-    // ADMIN AUTHENTICATION OPERATIONS
-    // ==========================================
-    /**
-     * ADMIN: Login tenant admin with JWT
-     * Note: JWT handling and auth bypass headers may need special implementation
-     */
-    async loginTenantAdmin(jwt) {
-        const body = {
-            authToken: jwt,
-            authType: persShared.AccountOwnerType.TENANT
-        };
-        return this.apiClient.post(`${this.basePath}/token`, body);
-    }
-    async loginUser(jwt) {
-        const body = {
-            authToken: jwt,
-            authType: persShared.AccountOwnerType.USER
-        };
-        return this.apiClient.post(`${this.basePath}/token`, body);
-    }
-    /**
-     * ADMIN: Refresh access token
-     * Note: Bypass header handling may need special implementation
-     */
-    async refreshAccessToken(refreshToken) {
-        return this.apiClient.post(`${this.basePath}/refresh`, { refreshToken });
-    }
-}
 
-/**
- * Platform-Agnostic Auth Admin Service
- *
- * Contains auth admin business logic and operations that work across platforms.
- * No framework dependencies - pure TypeScript business logic.
- *
- * Focuses only on actual backend capabilities.
- */
-class AuthService {
-    constructor(authApi, authProvider) {
-        this.authApi = authApi;
-        this.authProvider = authProvider;
-    }
-    // ==========================================
-    // ADMIN AUTHENTICATION OPERATIONS
-    // ==========================================
-    /**
-     * ADMIN: Login tenant admin with JWT
-     * Automatically stores tokens if auth provider supports token storage
-     */
-    async loginTenantAdmin(jwt) {
-        const response = await this.authApi.loginTenantAdmin(jwt);
-        // Store tokens if auth provider supports it
-        if (this.authProvider && response.accessToken) {
-            await this.storeTokens(response.accessToken, response.refreshToken);
-        }
-        return response;
-    }
-    /**
-     * ADMIN: Login user with JWT
-     * Automatically stores tokens if auth provider supports token storage
-     */
-    async loginUser(jwt) {
-        const response = await this.authApi.loginUser(jwt);
-        // Store tokens if auth provider supports it
-        if (this.authProvider && response.accessToken) {
-            await this.storeTokens(response.accessToken, response.refreshToken);
-        }
-        return response;
-    }
-    /**
-     * ADMIN: Refresh access token
-     * Automatically stores new tokens if auth provider supports token storage
-     */
-    async refreshAccessToken(refreshToken) {
-        // Use provided refresh token or get from auth provider
-        const tokenToUse = refreshToken || (this.authProvider?.getRefreshToken ? await this.authProvider.getRefreshToken() : null);
-        if (!tokenToUse) {
-            throw new Error('No refresh token available for token refresh');
-        }
-        const response = await this.authApi.refreshAccessToken(tokenToUse);
-        // Store new tokens if auth provider supports it
-        if (this.authProvider && response.accessToken) {
-            await this.storeTokens(response.accessToken, response.refreshToken);
-        }
-        return response;
-    }
-    /**
-     * Automatic token refresh using stored refresh token
-     * Convenience method for 401 error handling
-     */
-    async autoRefreshToken() {
-        return this.refreshAccessToken(); // Uses stored refresh token
-    }
-    /**
-     * Clear stored tokens if auth provider supports it
-     */
-    async clearTokens() {
-        if (this.authProvider?.clearTokens) {
-            await this.authProvider.clearTokens();
-        }
-    }
-    /**
-     * Check if we have valid tokens for authentication
-     */
-    hasValidAuth() {
-        return this.authProvider?.hasValidToken?.() ?? false;
-    }
-    // ==========================================
-    // PRIVATE HELPERS
-    // ==========================================
-    /**
-     * Store tokens using auth provider if it supports token storage
-     */
-    async storeTokens(accessToken, refreshToken) {
-        if (!this.authProvider)
-            return;
-        try {
-            // Store access token
-            if (this.authProvider.setAccessToken) {
-                await this.authProvider.setAccessToken(accessToken);
-            }
-            // Store refresh token if provided and supported
-            if (refreshToken && this.authProvider.setRefreshToken) {
-                await this.authProvider.setRefreshToken(refreshToken);
-            }
-        }
-        catch (error) {
-            console.error('Failed to store tokens in auth provider:', error);
-            // Don't throw - token storage failure shouldn't break authentication
-        }
-    }
-}
-
-/**
- * Simple, self-contained authentication provider for SDK
- *
- * Manages tokens internally without external dependencies.
- * Perfect for platform-agnostic usage.
- */
-class SimpleSdkAuthProvider {
-    constructor(projectKey) {
-        this.accessToken = null;
-        this.refreshToken = null;
-        this.projectKey = null;
-        this.authType = 'admin';
-        this.projectKey = projectKey || null;
-        // Try to load tokens from localStorage if available
-        this.loadTokensFromStorage();
-    }
-    async getToken() {
-        // Return stored access token
-        return this.accessToken;
-    }
-    async getProjectKey() {
-        return this.projectKey;
-    }
-    async onTokenExpired() {
-        console.log('SimpleSdkAuthProvider: Token expired, attempting refresh...');
-        if (!this.refreshToken) {
-            console.warn('SimpleSdkAuthProvider: No refresh token available');
-            throw new Error('No refresh token available for refresh');
-        }
-        // Note: Actual refresh logic would be handled by the SDK's AuthService
-        // This provider just manages token storage
-        console.warn('SimpleSdkAuthProvider: Token refresh should be handled by SDK AuthService');
-    }
-    // Token storage methods
-    async setAccessToken(token) {
-        this.accessToken = token;
-        this.saveTokenToStorage('pers_access_token', token);
-    }
-    async setRefreshToken(token) {
-        this.refreshToken = token;
-        this.saveTokenToStorage('pers_refresh_token', token);
-    }
-    async getRefreshToken() {
-        return this.refreshToken;
-    }
-    async clearTokens() {
-        this.accessToken = null;
-        this.refreshToken = null;
-        // Clear from storage
-        this.removeTokenFromStorage('pers_access_token');
-        this.removeTokenFromStorage('pers_refresh_token');
-    }
-    // Internal methods for token persistence
-    loadTokensFromStorage() {
-        if (typeof localStorage !== 'undefined') {
-            try {
-                this.accessToken = localStorage.getItem('pers_access_token');
-                this.refreshToken = localStorage.getItem('pers_refresh_token');
-            }
-            catch (error) {
-                console.error('Failed to load tokens from localStorage:', error);
-            }
-        }
-        else {
-            console.warn('localStorage is not available for token persistence');
-        }
-    }
-    saveTokenToStorage(key, value) {
-        if (typeof localStorage !== 'undefined') {
-            localStorage.setItem(key, value);
-        }
-    }
-    removeTokenFromStorage(key) {
-        if (typeof localStorage !== 'undefined') {
-            localStorage.removeItem(key);
-        }
-    }
-    // Utility methods for external integration
-    hasValidToken() {
-        const hasToken = !!this.accessToken;
-        return hasToken;
-    }
-    hasRefreshToken() {
-        return !!this.refreshToken;
-    }
-}
-
-// packages/pers-sdk/src/core/pers-api-client.ts
-/**
- * PERS API Client - Core platform-agnostic client for PERS backend
- */
-class PersApiClient {
-    constructor(httpClient, config) {
-        this.httpClient = httpClient;
-        this.config = config;
-        // Merge user config with defaults (production + v2)
-        this.mergedConfig = mergeWithDefaults(config);
-        // Auto-create auth provider if none provided
-        if (!this.mergedConfig.authProvider) {
-            this.mergedConfig.authProvider = new SimpleSdkAuthProvider(this.mergedConfig.apiProjectKey);
-        }
-        // Build API root from merged environment and version
-        this.apiRoot = buildApiRoot(this.mergedConfig.environment, this.mergedConfig.apiVersion);
-        // Initialize auth services for direct authentication
-        this.authApi = new AuthApi(this);
-        this.authService = new AuthService(this.authApi, this.mergedConfig.authProvider);
-    }
-    /**
-     * Get request headers including auth token and project key
-     */
-    async getHeaders() {
-        const headers = {
-            'Content-Type': 'application/json',
-        };
-        // Add authentication token
-        if (this.mergedConfig.authProvider) {
-            const token = await this.mergedConfig.authProvider.getToken();
-            if (token) {
-                headers['Authorization'] = `Bearer ${token}`;
-            }
-        }
-        // Add project key
-        if (this.mergedConfig.authProvider) {
-            const projectKey = await this.mergedConfig.authProvider.getProjectKey();
-            if (projectKey) {
-                headers['x-project-key'] = projectKey;
-            }
-        }
-        else if (this.mergedConfig.apiProjectKey) {
-            // Fallback to config project key if no auth provider
-            headers['x-project-key'] = this.mergedConfig.apiProjectKey;
-        }
-        return headers;
-    }
-    /**
-     * Make a request with proper headers, auth, and error handling
-     */
-    async request(method, endpoint, body, options) {
-        const { retryCount = 0, responseType = 'json' } = options || {};
-        const url = `${this.apiRoot}${endpoint}`;
-        // ✅ DEBUGGING: Add extensive logging for CSV endpoint
-        const isCSVEndpoint = endpoint.includes('/export/csv');
-        const requestOptions = {
-            headers: await this.getHeaders(),
-            timeout: this.mergedConfig.timeout,
-            responseType
-        };
-        try {
-            let result;
-            switch (method) {
-                case 'GET':
-                    result = await this.httpClient.get(url, requestOptions);
-                    break;
-                case 'POST':
-                    result = await this.httpClient.post(url, body, requestOptions);
-                    break;
-                case 'PUT':
-                    result = await this.httpClient.put(url, body, requestOptions);
-                    break;
-                case 'DELETE':
-                    result = await this.httpClient.delete(url, requestOptions);
-                    break;
-                default:
-                    throw new Error(`Unsupported HTTP method: ${method}`);
-            }
-            return result;
-        }
-        catch (error) {
-            if (isCSVEndpoint) {
-                console.error('❌ [PERS API CLIENT] CSV Request failed:', error);
-            }
-            // Handle 401 errors with automatic token refresh
-            const apiError = error;
-            if (apiError.status === 401 && retryCount === 0 && this.mergedConfig.authProvider?.onTokenExpired) {
-                try {
-                    await this.mergedConfig.authProvider.onTokenExpired();
-                    // Retry once with refreshed token
-                    return this.request(method, endpoint, body, { ...options, retryCount: 1 });
-                }
-                catch (refreshError) {
-                    throw new PersApiError(`Authentication refresh failed: ${refreshError}`, endpoint, method, 401);
-                }
-            }
-            throw new PersApiError(`PERS API request failed: ${apiError.message || error}`, endpoint, method, apiError.status);
-        }
-    }
-    /**
-     * Generic GET request
-     */
-    async get(endpoint, responseType) {
-        return this.request('GET', endpoint, undefined, { responseType });
-    }
-    /**
-     * Generic POST request
-     */
-    async post(endpoint, body) {
-        return this.request('POST', endpoint, body);
-    }
-    /**
-     * Generic PUT request
-     */
-    async put(endpoint, body) {
-        return this.request('PUT', endpoint, body);
-    }
-    /**
-     * Generic DELETE request
-     */
-    async delete(endpoint) {
-        return this.request('DELETE', endpoint);
-    }
-    // ==========================================
-    // AUTHENTICATION METHODS
-    // ==========================================
-    /**
-     * Login admin user with external JWT (e.g., Firebase)
-     * Automatically stores tokens in auth provider if available
-     */
-    async loginAdmin(externalJwt) {
-        return this.authService.loginTenantAdmin(externalJwt);
-    }
-    /**
-     * Login regular user with external JWT
-     * Automatically stores tokens in auth provider if available
-     */
-    async loginUser(externalJwt) {
-        return this.authService.loginUser(externalJwt);
-    }
-    /**
-     * Refresh access token using stored refresh token
-     */
-    async refreshToken() {
-        const refreshToken = await this.mergedConfig.authProvider?.getRefreshToken?.();
-        if (!refreshToken) {
-            throw new Error('No refresh token available');
-        }
-        return this.authService.refreshAccessToken(refreshToken);
-    }
-    /**
-     * Clear all stored authentication tokens
-     */
-    async clearAuth() {
-        return this.authService.clearTokens();
-    }
-    /**
-     * Check if user has valid authentication token
-     */
-    hasValidAuth() {
-        return this.mergedConfig.authProvider?.hasValidToken?.() || false;
-    }
-    /**
-     * Get current configuration (returns merged config)
-     */
-    getConfig() {
-        return this.mergedConfig;
-    }
-    /**
-     * Get original user configuration
-     */
-    getOriginalConfig() {
-        return this.config;
-    }
-}
-class PersApiError extends Error {
-    constructor(message, endpoint, method, statusCode) {
-        super(message);
-        this.endpoint = endpoint;
-        this.method = method;
-        this.statusCode = statusCode;
-        this.name = 'PersApiError';
-    }
-}
-
-/**
- * Memory-based token storage (default)
- */
-class MemoryTokenStorage {
-    constructor() {
-        this.storage = new Map();
-    }
-    async setItem(key, value) {
-        this.storage.set(key, value);
-    }
-    async getItem(key) {
-        return this.storage.get(key) || null;
-    }
-    async removeItem(key) {
-        this.storage.delete(key);
-    }
-}
-/**
- * localStorage-based token storage (browser only)
- */
-class LocalStorageTokenStorage {
-    async setItem(key, value) {
-        if (typeof localStorage !== 'undefined') {
-            localStorage.setItem(key, value);
-        }
-        else {
-            throw new Error('localStorage is not available in this environment');
-        }
-    }
-    async getItem(key) {
-        if (typeof localStorage !== 'undefined') {
-            return localStorage.getItem(key);
-        }
-        return null;
-    }
-    async removeItem(key) {
-        if (typeof localStorage !== 'undefined') {
-            localStorage.removeItem(key);
-        }
-    }
-}
-/**
- * Creates a platform-agnostic AuthProvider from simple configuration
- *
- * This factory function is completely platform-agnostic and can be used
- * across Angular, React, Vue, Node.js, or any other JavaScript environment.
- *
- * Features:
- * - Token caching with refresh support
- * - Automatic token refresh on expiration
- * - Configurable token providers
- * - Token storage (memory, localStorage, custom)
- * - Platform-independent
- *
- * @param config - Simple auth configuration
- * @returns AuthProvider implementation
- */
-function createAuthProvider(config) {
-    // Initialize token storage
-    let tokenStorage;
-    switch (config.tokenStorage) {
-        case 'localStorage':
-            tokenStorage = new LocalStorageTokenStorage();
-            break;
-        case 'custom':
-            if (!config.customTokenStorage) {
-                throw new Error('Custom token storage configuration is required when tokenStorage is "custom"');
-            }
-            tokenStorage = config.customTokenStorage;
-            break;
-        case 'memory':
-        default:
-            tokenStorage = new MemoryTokenStorage();
-            break;
-    }
-    // Token storage keys
-    const ACCESS_TOKEN_KEY = `pers_access_token_${config.authType || 'user'}`;
-    const REFRESH_TOKEN_KEY = `pers_refresh_token_${config.authType || 'user'}`;
-    // Store current token for refresh scenarios and caching
-    let currentToken = config.token || null;
-    let isRefreshing = false; // Prevent concurrent refresh attempts
-    let refreshPromise = null;
-    return {
-        authType: config.authType || 'user',
-        async getToken() {
-            // If currently refreshing, wait for it to complete
-            if (isRefreshing && refreshPromise) {
-                await refreshPromise;
-                return currentToken;
-            }
-            // Use cached current token (updated after refresh)
-            if (currentToken) {
-                return currentToken;
-            }
-            // Try to get token from storage
-            try {
-                const storedToken = await tokenStorage.getItem(ACCESS_TOKEN_KEY);
-                if (storedToken) {
-                    currentToken = storedToken;
-                    return storedToken;
-                }
-            }
-            catch (error) {
-                console.warn('Failed to retrieve token from storage:', error);
-            }
-            // Custom token provider function (always fresh)
-            if (config.tokenProvider) {
-                const token = await config.tokenProvider();
-                currentToken = token; // Cache for future calls
-                return token;
-            }
-            // No token available
-            return null;
-        },
-        async getProjectKey() {
-            return config.projectKey || null;
-        },
-        // Token storage methods
-        async setAccessToken(token) {
-            currentToken = token;
-            try {
-                await tokenStorage.setItem(ACCESS_TOKEN_KEY, token);
-            }
-            catch (error) {
-                console.error('Failed to store access token:', error);
-                throw error;
-            }
-        },
-        async setRefreshToken(token) {
-            try {
-                await tokenStorage.setItem(REFRESH_TOKEN_KEY, token);
-            }
-            catch (error) {
-                console.error('Failed to store refresh token:', error);
-                throw error;
-            }
-        },
-        async getRefreshToken() {
-            try {
-                return await tokenStorage.getItem(REFRESH_TOKEN_KEY);
-            }
-            catch (error) {
-                console.warn('Failed to retrieve refresh token from storage:', error);
-                return null;
-            }
-        },
-        async clearTokens() {
-            currentToken = null;
-            try {
-                await Promise.all([
-                    tokenStorage.removeItem(ACCESS_TOKEN_KEY),
-                    tokenStorage.removeItem(REFRESH_TOKEN_KEY)
-                ]);
-            }
-            catch (error) {
-                console.error('Failed to clear tokens from storage:', error);
-                throw error;
-            }
-        },
-        async onTokenExpired() {
-            // Prevent concurrent refresh attempts
-            if (isRefreshing) {
-                if (refreshPromise) {
-                    await refreshPromise;
-                }
-                return;
-            }
-            // No refresh logic provided
-            if (!config.onTokenExpired) {
-                console.warn('Token expired but no refresh logic provided');
-                currentToken = null;
-                try {
-                    await tokenStorage.removeItem(ACCESS_TOKEN_KEY);
-                }
-                catch (error) {
-                    console.warn('Failed to clear expired token from storage:', error);
-                }
-                return;
-            }
-            // Start refresh process
-            isRefreshing = true;
-            refreshPromise = (async () => {
-                try {
-                    // Execute refresh logic (should update token source)
-                    await config.onTokenExpired();
-                    // After refresh, get the new token
-                    if (config.tokenProvider) {
-                        const newToken = await config.tokenProvider();
-                        if (newToken && newToken !== currentToken) {
-                            currentToken = newToken;
-                            // Store the new token
-                            try {
-                                await tokenStorage.setItem(ACCESS_TOKEN_KEY, newToken);
-                            }
-                            catch (error) {
-                                console.warn('Failed to store refreshed token:', error);
-                            }
-                            // Notify about successful token refresh
-                            if (config.onTokenRefreshed) {
-                                config.onTokenRefreshed(newToken);
-                            }
-                        }
-                        else {
-                            console.warn('Token refresh completed but no new token received');
-                            currentToken = null;
-                            try {
-                                await tokenStorage.removeItem(ACCESS_TOKEN_KEY);
-                            }
-                            catch (error) {
-                                console.warn('Failed to clear token after failed refresh:', error);
-                            }
-                        }
-                    }
-                    else {
-                        // For static token configs, clear the token since we can't refresh
-                        console.warn('Token expired for static token config - clearing token');
-                        currentToken = null;
-                        try {
-                            await tokenStorage.removeItem(ACCESS_TOKEN_KEY);
-                        }
-                        catch (error) {
-                            console.warn('Failed to clear expired static token:', error);
-                        }
-                    }
-                }
-                catch (error) {
-                    console.error('Token refresh failed:', error);
-                    currentToken = null; // Clear token on refresh failure
-                    try {
-                        await tokenStorage.removeItem(ACCESS_TOKEN_KEY);
-                    }
-                    catch (storageError) {
-                        console.warn('Failed to clear token after refresh failure:', storageError);
-                    }
-                    throw error; // Re-throw to let SDK handle the error
-                }
-                finally {
-                    isRefreshing = false;
-                    refreshPromise = null;
-                }
-            })();
-            await refreshPromise;
-        }
-    };
-}
-/**
- * Platform-specific localStorage token provider for browsers
- * This is a convenience function for browser environments
- */
-/* export function createBrowserTokenProvider(tokenKey: string = 'userJwt'): () => Promise<string | null> {
-  return async () => {
-    if (typeof localStorage !== 'undefined') {
-      return localStorage.getItem(tokenKey);
-    }
-    return null;
-  };
-} */
-/**
- * Platform-specific environment variable token provider for Node.js
- * This is a convenience function for Node.js environments
- */
-/* export function createNodeTokenProvider(envVar: string = 'JWT_TOKEN'): () => Promise<string | null> {
-  return async () => {
-    if (typeof process !== 'undefined' && process.env) {
-      return process.env[envVar] || null;
-    }
-    return null;
-  };
-} */
-
-/**
- * @explorins/pers-sdk/core/auth - Consolidated Auth Module
- *
- * All authentication functionality in one place:
- * - Auth provider interfaces and implementations
- * - Auth API and service logic
- * - Token management
- */
-// Auth provider interfaces and implementations
-/**
- * Create a complete Auth SDK instance (for backward compatibility)
- * Note: This is now handled directly by PersApiClient
- *
- * @param apiClient - Configured PERS API client
- * @param authProvider - Optional auth provider. If not provided, uses SimpleSdkAuthProvider
- * @returns Auth SDK with flattened structure for better DX
- */
-function createAuthSDK(apiClient, authProvider) {
-    // Use simple internal auth provider if none provided
-    const provider = authProvider || new SimpleSdkAuthProvider();
-    const authApi = new AuthApi(apiClient);
-    const authService = new AuthService(authApi, provider);
-    return {
-        // Direct access to service methods (primary interface)
-        // Admin authentication methods
-        loginTenantAdmin: (jwt) => authService.loginTenantAdmin(jwt),
-        loginUser: (jwt) => authService.loginUser(jwt),
-        refreshAccessToken: (refreshToken) => authService.refreshAccessToken(refreshToken),
-        clearTokens: () => authService.clearTokens(),
-        // Auth provider access for external integration
-        getAuthProvider: () => provider,
-        hasValidToken: () => provider.hasValidToken?.() || false,
-        // Advanced access for edge cases
-        api: authApi,
-        service: authService
-    };
-}
-
-/**
- * PERS SDK - Minimal platform-agnostic client with built-in authentication
- * Authentication is now handled at the SDK core level for better scalability
- */
-/**
- * Minimal PERS SDK - API client with authentication built-in
- * Platform adapters provide auth providers and HTTP clients
- */
-class PersSDK {
-    constructor(httpClient, config) {
-        this.apiClient = new PersApiClient(httpClient, config);
-    }
-    /**
-     * Get the API client for direct PERS API calls
-     * This is the main interface - keep it simple!
-     */
-    api() {
-        return this.apiClient;
-    }
-    /**
-     * Quick config check
-     */
-    isProduction() {
-        return this.apiClient.getConfig().environment === 'production';
-    }
-}
-/**
- * Simple factory function
- */
-function createPersSDK(httpClient, config) {
-    return new PersSDK(httpClient, config);
-}
-
-Object.defineProperty(exports, "AccountOwnerType", {
-    enumerable: true,
-    get: function () { return persShared.AccountOwnerType; }
-});
-exports.AuthApi = AuthApi;
-exports.AuthService = AuthService;
-exports.DEFAULT_PERS_CONFIG = DEFAULT_PERS_CONFIG;
-exports.PersApiClient = PersApiClient;
-exports.PersApiError = PersApiError;
-exports.PersSDK = PersSDK;
-exports.SimpleSdkAuthProvider = SimpleSdkAuthProvider;
-exports.buildApiRoot = buildApiRoot;
-exports.createAuthProvider = createAuthProvider;
-exports.createAuthSDK = createAuthSDK;
-exports.createPersSDK = createPersSDK;
-exports.mergeWithDefaults = mergeWithDefaults;
+exports.DEFAULT_PERS_CONFIG = persSdk.DEFAULT_PERS_CONFIG;
+exports.PersApiClient = persSdk.PersApiClient;
+exports.PersSDK = persSdk.PersSDK;
+exports.buildApiRoot = persSdk.buildApiRoot;
+exports.createPersSDK = persSdk.createPersSDK;
+exports.mergeWithDefaults = persSdk.mergeWithDefaults;
 //# sourceMappingURL=core.cjs.map