@finatic/client 0.0.131

package/dist/index.js

@@ -0,0 +1,4815 @@
+'use strict';
+
+var uuid = require('uuid');
+
+/**
+ * API-related types for Finatic Connect SDK
+ */
+var SessionState;
+(function (SessionState) {
+    SessionState["PENDING"] = "PENDING";
+    SessionState["AUTHENTICATING"] = "AUTHENTICATING";
+    SessionState["ACTIVE"] = "ACTIVE";
+    SessionState["COMPLETED"] = "COMPLETED";
+    SessionState["EXPIRED"] = "EXPIRED";
+})(SessionState || (SessionState = {}));
+
+/**
+ * Core types for Finatic Connect SDK
+ */
+class PaginatedResult {
+    constructor(data, paginationInfo, navigationCallback) {
+        this.data = data;
+        this.metadata = {
+            hasMore: paginationInfo.has_more,
+            nextOffset: paginationInfo.next_offset,
+            currentOffset: paginationInfo.current_offset,
+            limit: paginationInfo.limit,
+            currentPage: Math.floor(paginationInfo.current_offset / paginationInfo.limit) + 1,
+            hasNext: paginationInfo.has_more,
+            hasPrevious: paginationInfo.current_offset > 0,
+        };
+        this.navigationCallback = navigationCallback;
+    }
+    get hasNext() {
+        return this.metadata.hasNext;
+    }
+    get hasPrevious() {
+        return this.metadata.hasPrevious;
+    }
+    get currentPage() {
+        return this.metadata.currentPage;
+    }
+    /**
+     * Navigate to the next page
+     * @returns Promise<PaginatedResult<T> | null> - Next page result or null if no next page
+     */
+    async nextPage() {
+        if (!this.hasNext || !this.navigationCallback) {
+            return null;
+        }
+        try {
+            return await this.navigationCallback(this.metadata.nextOffset, this.metadata.limit);
+        }
+        catch (error) {
+            console.error('Error navigating to next page:', error);
+            return null;
+        }
+    }
+    /**
+     * Navigate to the previous page
+     * @returns Promise<PaginatedResult<T> | null> - Previous page result or null if no previous page
+     */
+    async previousPage() {
+        if (!this.hasPrevious || !this.navigationCallback) {
+            return null;
+        }
+        const previousOffset = Math.max(0, this.metadata.currentOffset - this.metadata.limit);
+        try {
+            return await this.navigationCallback(previousOffset, this.metadata.limit);
+        }
+        catch (error) {
+            console.error('Error navigating to previous page:', error);
+            return null;
+        }
+    }
+    /**
+     * Navigate to a specific page
+     * @param pageNumber - The page number to navigate to (1-based)
+     * @returns Promise<PaginatedResult<T> | null> - Page result or null if page doesn't exist
+     */
+    async goToPage(pageNumber) {
+        if (pageNumber < 1 || !this.navigationCallback) {
+            return null;
+        }
+        const targetOffset = (pageNumber - 1) * this.metadata.limit;
+        try {
+            return await this.navigationCallback(targetOffset, this.metadata.limit);
+        }
+        catch (error) {
+            console.error('Error navigating to page:', pageNumber, error);
+            return null;
+        }
+    }
+    /**
+     * Get the first page
+     * @returns Promise<PaginatedResult<T> | null> - First page result or null if error
+     */
+    async firstPage() {
+        return this.goToPage(1);
+    }
+    /**
+     * Get the last page (this is a best effort - we don't know the total count)
+     * @returns Promise<PaginatedResult<T> | null> - Last page result or null if error
+     */
+    async lastPage() {
+        if (!this.navigationCallback) {
+            return null;
+        }
+        const findLast = async (page) => {
+            const next = await page.nextPage();
+            if (next) {
+                return findLast(next);
+            }
+            return page;
+        };
+        return findLast(this);
+    }
+    /**
+     * Get pagination info as a string
+     * @returns string - Human readable pagination info
+     */
+    getPaginationInfo() {
+        return `Page ${this.currentPage} (${this.metadata.currentOffset + 1}-${this.metadata.currentOffset + this.metadata.limit}) - ${this.hasNext ? 'Has more' : 'Last page'}`;
+    }
+}
+
+class BaseError extends Error {
+    constructor(message, code = 'UNKNOWN_ERROR') {
+        super(message);
+        this.code = code;
+        this.name = this.constructor.name;
+    }
+}
+class ApiError extends BaseError {
+    constructor(status, message, details) {
+        super(message, `API_ERROR_${status}`);
+        this.status = status;
+        this.details = details;
+        this.name = 'ApiError';
+    }
+}
+class SessionError extends ApiError {
+    constructor(message, details) {
+        super(400, message, details);
+        this.name = 'SessionError';
+    }
+}
+class AuthenticationError extends ApiError {
+    constructor(message, details) {
+        super(401, message, details);
+        this.name = 'AuthenticationError';
+    }
+}
+class AuthorizationError extends ApiError {
+    constructor(message, details) {
+        super(403, message, details);
+        this.name = 'AuthorizationError';
+    }
+}
+class RateLimitError extends ApiError {
+    constructor(message, details) {
+        super(429, message, details);
+        this.name = 'RateLimitError';
+    }
+}
+class TokenError extends BaseError {
+    constructor(message) {
+        super(message, 'TOKEN_ERROR');
+        this.name = 'TokenError';
+    }
+}
+class ValidationError extends BaseError {
+    constructor(message) {
+        super(message, 'VALIDATION_ERROR');
+        this.name = 'ValidationError';
+    }
+}
+class NetworkError extends BaseError {
+    constructor(message) {
+        super(message, 'NETWORK_ERROR');
+        this.name = 'NetworkError';
+    }
+}
+class SecurityError extends BaseError {
+    constructor(message) {
+        super(message, 'SECURITY_ERROR');
+        this.name = 'SecurityError';
+    }
+}
+class CompanyAccessError extends ApiError {
+    constructor(message, details) {
+        super(403, message, details);
+        this.name = 'CompanyAccessError';
+    }
+}
+class OrderError extends ApiError {
+    constructor(message, details) {
+        super(500, message, details);
+        this.name = 'OrderError';
+    }
+}
+class OrderValidationError extends ApiError {
+    constructor(message, details) {
+        super(400, message, details);
+        this.name = 'OrderValidationError';
+    }
+}
+
+class ApiClient {
+    constructor(baseUrl, deviceInfo) {
+        this.currentSessionState = null;
+        this.currentSessionId = null;
+        this.tradingContext = {};
+        // Token management
+        this.tokenInfo = null;
+        this.refreshPromise = null;
+        this.REFRESH_BUFFER_MINUTES = 5; // Refresh token 5 minutes before expiry
+        // Session and company context
+        this.companyId = null;
+        this.csrfToken = null;
+        this.baseUrl = baseUrl;
+        this.deviceInfo = deviceInfo;
+        // Ensure baseUrl doesn't end with a slash
+        this.baseUrl = baseUrl.replace(/\/$/, '');
+        // Append /api/v1 if not already present
+        if (!this.baseUrl.includes('/api/v1')) {
+            this.baseUrl = `${this.baseUrl}/api/v1`;
+        }
+    }
+    /**
+     * Set session context (session ID, company ID, CSRF token)
+     */
+    setSessionContext(sessionId, companyId, csrfToken) {
+        this.currentSessionId = sessionId;
+        this.companyId = companyId;
+        this.csrfToken = csrfToken || null;
+    }
+    /**
+     * Get the current session ID
+     */
+    getCurrentSessionId() {
+        return this.currentSessionId;
+    }
+    /**
+     * Get the current company ID
+     */
+    getCurrentCompanyId() {
+        return this.companyId;
+    }
+    /**
+     * Get the current CSRF token
+     */
+    getCurrentCsrfToken() {
+        return this.csrfToken;
+    }
+    /**
+     * Store tokens after successful authentication
+     */
+    setTokens(accessToken, refreshToken, expiresAt, userId) {
+        this.tokenInfo = {
+            accessToken,
+            refreshToken,
+            expiresAt,
+            userId,
+        };
+    }
+    /**
+     * Get the current access token, refreshing if necessary
+     */
+    async getValidAccessToken() {
+        if (!this.tokenInfo) {
+            throw new AuthenticationError('No tokens available. Please authenticate first.');
+        }
+        // Check if token is expired or about to expire
+        if (this.isTokenExpired()) {
+            await this.refreshTokens();
+        }
+        return this.tokenInfo.accessToken;
+    }
+    /**
+     * Check if the current token is expired or about to expire
+     */
+    isTokenExpired() {
+        if (!this.tokenInfo)
+            return true;
+        const expiryTime = new Date(this.tokenInfo.expiresAt).getTime();
+        const currentTime = Date.now();
+        const bufferTime = this.REFRESH_BUFFER_MINUTES * 60 * 1000; // 5 minutes in milliseconds
+        return currentTime >= expiryTime - bufferTime;
+    }
+    /**
+     * Refresh the access token using the refresh token
+     */
+    async refreshTokens() {
+        if (!this.tokenInfo) {
+            throw new AuthenticationError('No refresh token available.');
+        }
+        // If a refresh is already in progress, wait for it
+        if (this.refreshPromise) {
+            await this.refreshPromise;
+            return;
+        }
+        // Start a new refresh
+        this.refreshPromise = this.performTokenRefresh();
+        try {
+            await this.refreshPromise;
+        }
+        finally {
+            this.refreshPromise = null;
+        }
+    }
+    /**
+     * Perform the actual token refresh request
+     */
+    async performTokenRefresh() {
+        if (!this.tokenInfo) {
+            throw new AuthenticationError('No refresh token available.');
+        }
+        try {
+            const response = await this.request('/company/auth/refresh', {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                },
+                body: {
+                    refresh_token: this.tokenInfo.refreshToken,
+                },
+            });
+            // Update stored tokens
+            this.tokenInfo = {
+                accessToken: response.response_data.access_token,
+                refreshToken: response.response_data.refresh_token,
+                expiresAt: response.response_data.expires_at,
+                userId: this.tokenInfo.userId,
+            };
+            return this.tokenInfo;
+        }
+        catch (error) {
+            // Clear tokens on refresh failure
+            this.tokenInfo = null;
+            throw new AuthenticationError('Token refresh failed. Please re-authenticate.', error);
+        }
+    }
+    /**
+     * Clear stored tokens (useful for logout)
+     */
+    clearTokens() {
+        this.tokenInfo = null;
+        this.refreshPromise = null;
+    }
+    /**
+     * Get current token info (for debugging/testing)
+     */
+    getTokenInfo() {
+        return this.tokenInfo ? { ...this.tokenInfo } : null;
+    }
+    /**
+     * Make a request to the API.
+     */
+    async request(path, options) {
+        // Ensure path starts with a slash
+        const normalizedPath = path.startsWith('/') ? path : `/${path}`;
+        const url = new URL(`${this.baseUrl}${normalizedPath}`);
+        if (options.params) {
+            Object.entries(options.params).forEach(([key, value]) => {
+                url.searchParams.append(key, value);
+            });
+        }
+        const response = await fetch(url.toString(), {
+            method: options.method,
+            headers: options.headers,
+            body: options.body ? JSON.stringify(options.body) : undefined,
+        });
+        if (!response.ok) {
+            const error = await response.json();
+            throw this.handleError(response.status, error);
+        }
+        const data = await response.json();
+        // Check if the response has a success field and it's false
+        if (data && typeof data === 'object' && 'success' in data && data.success === false) {
+            // For order endpoints, provide more context
+            const isOrderEndpoint = path.includes('/brokers/orders');
+            if (isOrderEndpoint) {
+                // Add context that this is an order-related error
+                data._isOrderError = true;
+            }
+            throw this.handleError(data.status_code || 500, data);
+        }
+        // Check if the response has a status_code field indicating an error (4xx or 5xx)
+        if (data && typeof data === 'object' && 'status_code' in data && data.status_code >= 400) {
+            throw this.handleError(data.status_code, data);
+        }
+        // Check if the response has errors field with content
+        if (data &&
+            typeof data === 'object' &&
+            'errors' in data &&
+            data.errors &&
+            Array.isArray(data.errors) &&
+            data.errors.length > 0) {
+            throw this.handleError(data.status_code || 500, data);
+        }
+        return data;
+    }
+    /**
+     * Handle API errors. This method can be overridden by language-specific implementations.
+     */
+    handleError(status, error) {
+        // Extract message from the error object with multiple fallback options
+        let message = 'API request failed';
+        if (error && typeof error === 'object') {
+            // Try different possible message fields
+            message =
+                error.message ||
+                    error.detail?.message ||
+                    error.error?.message ||
+                    error.errors?.[0]?.message ||
+                    (typeof error.errors === 'string' ? error.errors : null) ||
+                    'API request failed';
+        }
+        // Check if this is an order-related error (either from order endpoints or order validation)
+        const isOrderError = error._isOrderError ||
+            message.includes('ORDER_FAILED') ||
+            message.includes('AUTH_ERROR') ||
+            message.includes('not found or not available for trading') ||
+            message.includes('Symbol') ||
+            (error.errors &&
+                Array.isArray(error.errors) &&
+                error.errors.some((e) => e.category === 'INVALID_ORDER' ||
+                    e.message?.includes('Symbol') ||
+                    e.message?.includes('not available for trading')));
+        if (isOrderError) {
+            // Check if this is a validation error (400 status with specific validation messages)
+            const isValidationError = status === 400 &&
+                (message.includes('not found or not available for trading') ||
+                    message.includes('Symbol') ||
+                    (error.errors &&
+                        Array.isArray(error.errors) &&
+                        error.errors.some((e) => e.category === 'INVALID_ORDER' ||
+                            e.message?.includes('Symbol') ||
+                            e.message?.includes('not available for trading'))));
+            if (isValidationError) {
+                return new OrderValidationError(message, error);
+            }
+            // For order placement errors, provide more specific error messages
+            if (message.includes('ORDER_FAILED') || message.includes('AUTH_ERROR')) {
+                // Extract the specific error from the nested structure
+                const orderErrorMatch = message.match(/\[([^\]]+)\]/g);
+                if (orderErrorMatch && orderErrorMatch.length > 0) {
+                    // Take the last error in the chain (most specific)
+                    const specificError = orderErrorMatch[orderErrorMatch.length - 1].replace(/[[\]]/g, '');
+                    message = `Order failed: ${specificError}`;
+                }
+            }
+            // Use OrderError for order-related failures
+            return new OrderError(message, error);
+        }
+        switch (status) {
+            case 400:
+                return new SessionError(message, error);
+            case 401:
+                return new AuthenticationError(message || 'Unauthorized: Invalid or missing session token', error);
+            case 403:
+                if (error.detail?.code === 'NO_COMPANY_ACCESS') {
+                    return new CompanyAccessError(error.detail.message || 'No broker connections found for this company', error.detail);
+                }
+                return new AuthorizationError(message || 'Forbidden: No access to the requested data', error);
+            case 404:
+                return new ApiError(status, message || 'Not found: The requested data does not exist', error);
+            case 429:
+                return new RateLimitError(message || 'Rate limit exceeded', error);
+            case 500:
+                return new ApiError(status, message || 'Internal server error', error);
+            default:
+                return new ApiError(status, message || 'API request failed', error);
+        }
+    }
+    // Session Management
+    async startSession(token, userId) {
+        const response = await this.request('/auth/session/start', {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'One-Time-Token': token,
+                'X-Device-Info': JSON.stringify({
+                    ip_address: this.deviceInfo?.ip_address || '',
+                    user_agent: this.deviceInfo?.user_agent || '',
+                    fingerprint: this.deviceInfo?.fingerprint || '',
+                }),
+            },
+            body: {
+                user_id: userId,
+            },
+        });
+        // Store session ID and set state to ACTIVE
+        this.currentSessionId = response.data.session_id;
+        this.currentSessionState = SessionState.ACTIVE;
+        return response;
+    }
+    // OTP Flow
+    async requestOtp(sessionId, email) {
+        return this.request('/auth/otp/request', {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'X-Session-ID': sessionId,
+                'X-Device-Info': JSON.stringify({
+                    ip_address: this.deviceInfo?.ip_address || '',
+                    user_agent: this.deviceInfo?.user_agent || '',
+                    fingerprint: this.deviceInfo?.fingerprint || '',
+                }),
+            },
+            body: {
+                email,
+            },
+        });
+    }
+    async verifyOtp(sessionId, otp) {
+        const response = await this.request('/auth/otp/verify', {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'X-Session-ID': sessionId,
+                'X-Device-Info': JSON.stringify({
+                    ip_address: this.deviceInfo?.ip_address || '',
+                    user_agent: this.deviceInfo?.user_agent || '',
+                    fingerprint: this.deviceInfo?.fingerprint || '',
+                }),
+            },
+            body: {
+                otp,
+            },
+        });
+        // Store tokens after successful OTP verification
+        if (response.success && response.data) {
+            const expiresAt = new Date(Date.now() + response.data.expires_in * 1000).toISOString();
+            this.setTokens(response.data.access_token, response.data.refresh_token, expiresAt, response.data.user_id);
+        }
+        return response;
+    }
+    // Direct Authentication
+    async authenticateDirectly(sessionId, userId) {
+        // Ensure session is active before authenticating
+        if (this.currentSessionState !== SessionState.ACTIVE) {
+            throw new SessionError('Session must be in ACTIVE state to authenticate');
+        }
+        const response = await this.request('/auth/session/authenticate', {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'Session-ID': sessionId,
+                'X-Session-ID': sessionId,
+                'X-Device-Info': JSON.stringify({
+                    ip_address: this.deviceInfo?.ip_address || '',
+                    user_agent: this.deviceInfo?.user_agent || '',
+                    fingerprint: this.deviceInfo?.fingerprint || '',
+                }),
+            },
+            body: {
+                session_id: sessionId,
+                user_id: userId,
+            },
+        });
+        // Store tokens after successful direct authentication
+        if (response.success && response.data) {
+            // For direct auth, we don't get expires_in, so we'll set a default 1-hour expiry
+            const expiresAt = new Date(Date.now() + 60 * 60 * 1000).toISOString(); // 1 hour
+            this.setTokens(response.data.access_token, response.data.refresh_token, expiresAt, userId);
+        }
+        return response;
+    }
+    // Portal Management
+    /**
+     * Get the portal URL for an active session
+     * @param sessionId The session identifier
+     * @returns Portal URL response
+     * @throws SessionError if session is not in ACTIVE state
+     */
+    async getPortalUrl(sessionId) {
+        if (this.currentSessionState !== SessionState.ACTIVE) {
+            throw new SessionError('Session must be in ACTIVE state to get portal URL');
+        }
+        return this.request('/auth/session/portal', {
+            method: 'GET',
+            headers: {
+                'Content-Type': 'application/json',
+                'Session-ID': sessionId,
+                'X-Session-ID': sessionId,
+                'X-Device-Info': JSON.stringify({
+                    ip_address: this.deviceInfo?.ip_address || '',
+                    user_agent: this.deviceInfo?.user_agent || '',
+                    fingerprint: this.deviceInfo?.fingerprint || '',
+                }),
+            },
+        });
+    }
+    async validatePortalSession(sessionId, signature) {
+        return this.request('/portal/validate', {
+            method: 'GET',
+            headers: {
+                'Content-Type': 'application/json',
+                'X-Session-ID': sessionId,
+                'X-Device-Info': JSON.stringify({
+                    ip_address: this.deviceInfo?.ip_address || '',
+                    user_agent: this.deviceInfo?.user_agent || '',
+                    fingerprint: this.deviceInfo?.fingerprint || '',
+                }),
+            },
+            params: {
+                signature,
+            },
+        });
+    }
+    async completePortalSession(sessionId) {
+        return this.request(`/portal/${sessionId}/complete`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+            },
+        });
+    }
+    // Portfolio Management
+    async getHoldings(accessToken) {
+        return this.request('/portfolio/holdings', {
+            method: 'GET',
+            headers: {
+                'Content-Type': 'application/json',
+                Authorization: `Bearer ${accessToken}`,
+            },
+        });
+    }
+    async getOrders(accessToken) {
+        return this.request('/orders/', {
+            method: 'GET',
+            headers: {
+                'Content-Type': 'application/json',
+                Authorization: `Bearer ${accessToken}`,
+            },
+        });
+    }
+    async getPortfolio(accessToken) {
+        const response = await this.request('/portfolio/', {
+            method: 'GET',
+            headers: {
+                Authorization: `Bearer ${accessToken}`,
+                'Content-Type': 'application/json',
+            },
+        });
+        return response;
+    }
+    async placeOrder(accessToken, order) {
+        await this.request('/orders/', {
+            method: 'POST',
+            headers: {
+                Authorization: `Bearer ${accessToken}`,
+                'Content-Type': 'application/json',
+            },
+            body: order,
+        });
+    }
+    // New methods with automatic token management
+    async getHoldingsAuto() {
+        const accessToken = await this.getValidAccessToken();
+        return this.getHoldings(accessToken);
+    }
+    async getOrdersAuto() {
+        const accessToken = await this.getValidAccessToken();
+        return this.getOrders(accessToken);
+    }
+    async getPortfolioAuto() {
+        const accessToken = await this.getValidAccessToken();
+        return this.getPortfolio(accessToken);
+    }
+    async placeOrderAuto(order) {
+        const accessToken = await this.getValidAccessToken();
+        return this.placeOrder(accessToken, order);
+    }
+    // Enhanced Trading Methods with Session Management
+    async placeBrokerOrder(accessToken, params, extras = {}) {
+        // Merge context with provided parameters
+        const fullParams = {
+            broker: (params.broker || this.tradingContext.broker) ||
+                (() => {
+                    throw new Error('Broker not set. Call setBroker() or pass broker parameter.');
+                })(),
+            accountNumber: params.accountNumber ||
+                this.tradingContext.accountNumber ||
+                (() => {
+                    throw new Error('Account not set. Call setAccount() or pass accountNumber parameter.');
+                })(),
+            symbol: params.symbol,
+            orderQty: params.orderQty,
+            action: params.action,
+            orderType: params.orderType,
+            assetType: params.assetType,
+            timeInForce: params.timeInForce || 'day',
+            price: params.price,
+            stopPrice: params.stopPrice,
+        };
+        // Build request body with snake_case parameter names
+        const requestBody = this.buildOrderRequestBody(fullParams, extras);
+        return this.request('/brokers/orders', {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                Authorization: `Bearer ${accessToken}`,
+                'Session-ID': this.currentSessionId || '',
+                'X-Session-ID': this.currentSessionId || '',
+                'X-Device-Info': JSON.stringify(this.deviceInfo),
+            },
+            body: requestBody,
+        });
+    }
+    async cancelBrokerOrder(orderId, broker, extras = {}) {
+        const targetBroker = broker ||
+            this.tradingContext.broker ||
+            (() => {
+                throw new Error('Broker not set. Call setBroker() or pass broker parameter.');
+            })();
+        // Build optional body for extras if provided
+        const body = Object.keys(extras).length > 0 ? { order: extras } : undefined;
+        return this.request(`/brokers/orders/${targetBroker}/${orderId}`, {
+            method: 'DELETE',
+            headers: {
+                'Content-Type': 'application/json',
+                'Session-ID': this.currentSessionId || '',
+                'X-Session-ID': this.currentSessionId || '',
+                'X-Device-Info': JSON.stringify(this.deviceInfo),
+            },
+            body,
+        });
+    }
+    async modifyBrokerOrder(orderId, params, broker, extras = {}) {
+        const targetBroker = broker ||
+            this.tradingContext.broker ||
+            (() => {
+                throw new Error('Broker not set. Call setBroker() or pass broker parameter.');
+            })();
+        // Build request body with snake_case parameter names and include broker
+        const requestBody = this.buildModifyRequestBody(params, extras, targetBroker);
+        return this.request(`/brokers/orders/${orderId}`, {
+            method: 'PATCH',
+            headers: {
+                'Content-Type': 'application/json',
+                'Session-ID': this.currentSessionId || '',
+                'X-Session-ID': this.currentSessionId || '',
+                'X-Device-Info': JSON.stringify(this.deviceInfo),
+            },
+            body: requestBody,
+        });
+    }
+    // Context management methods
+    setBroker(broker) {
+        this.tradingContext.broker = broker;
+        // Clear account when broker changes
+        this.tradingContext.accountNumber = undefined;
+        this.tradingContext.accountId = undefined;
+    }
+    setAccount(accountNumber, accountId) {
+        this.tradingContext.accountNumber = accountNumber;
+        this.tradingContext.accountId = accountId;
+    }
+    getTradingContext() {
+        return { ...this.tradingContext };
+    }
+    clearTradingContext() {
+        this.tradingContext = {};
+    }
+    // Stock convenience methods
+    async placeStockMarketOrder(accessToken, symbol, orderQty, action, broker, accountNumber, extras = {}) {
+        return this.placeBrokerOrder(accessToken, {
+            broker,
+            accountNumber,
+            symbol,
+            orderQty,
+            action,
+            orderType: 'Market',
+            assetType: 'Stock',
+            timeInForce: 'day',
+        }, extras);
+    }
+    async placeStockLimitOrder(accessToken, symbol, orderQty, action, price, timeInForce = 'gtc', broker, accountNumber, extras = {}) {
+        return this.placeBrokerOrder(accessToken, {
+            broker,
+            accountNumber,
+            symbol,
+            orderQty,
+            action,
+            orderType: 'Limit',
+            assetType: 'Stock',
+            timeInForce,
+            price,
+        }, extras);
+    }
+    async placeStockStopOrder(accessToken, symbol, orderQty, action, stopPrice, timeInForce = 'day', broker, accountNumber, extras = {}) {
+        return this.placeBrokerOrder(accessToken, {
+            broker,
+            accountNumber,
+            symbol,
+            orderQty,
+            action,
+            orderType: 'Stop',
+            assetType: 'Stock',
+            timeInForce,
+            stopPrice,
+        }, extras);
+    }
+    // Crypto convenience methods
+    async placeCryptoMarketOrder(accessToken, symbol, orderQty, action, options = {}, broker, accountNumber, extras = {}) {
+        const orderParams = {
+            broker,
+            accountNumber,
+            symbol,
+            orderQty: options.quantity || orderQty,
+            action,
+            orderType: 'Market',
+            assetType: 'Crypto',
+            timeInForce: 'gtc', // Crypto typically uses GTC
+        };
+        // Add notional if provided
+        if (options.notional) {
+            orderParams.notional = options.notional;
+        }
+        return this.placeBrokerOrder(accessToken, orderParams, extras);
+    }
+    async placeCryptoLimitOrder(accessToken, symbol, orderQty, action, price, timeInForce = 'gtc', options = {}, broker, accountNumber, extras = {}) {
+        const orderParams = {
+            broker,
+            accountNumber,
+            symbol,
+            orderQty: options.quantity || orderQty,
+            action,
+            orderType: 'Limit',
+            assetType: 'Crypto',
+            timeInForce,
+            price,
+        };
+        // Add notional if provided
+        if (options.notional) {
+            orderParams.notional = options.notional;
+        }
+        return this.placeBrokerOrder(accessToken, orderParams, extras);
+    }
+    // Options convenience methods
+    async placeOptionsMarketOrder(accessToken, symbol, orderQty, action, options, broker, accountNumber, extras = {}) {
+        const orderParams = {
+            broker,
+            accountNumber,
+            symbol,
+            orderQty,
+            action,
+            orderType: 'Market',
+            assetType: 'Option',
+            timeInForce: 'day',
+        };
+        // Add options-specific parameters to extras
+        const targetBroker = broker || this.tradingContext.broker;
+        const optionsExtras = {
+            ...extras,
+            ...(targetBroker && {
+                [targetBroker]: {
+                    ...extras[targetBroker],
+                    strikePrice: options.strikePrice,
+                    expirationDate: options.expirationDate,
+                    optionType: options.optionType,
+                    contractSize: options.contractSize || 100,
+                },
+            }),
+        };
+        return this.placeBrokerOrder(accessToken, orderParams, optionsExtras);
+    }
+    async placeOptionsLimitOrder(accessToken, symbol, orderQty, action, price, options, timeInForce = 'gtc', broker, accountNumber, extras = {}) {
+        const orderParams = {
+            broker,
+            accountNumber,
+            symbol,
+            orderQty,
+            action,
+            orderType: 'Limit',
+            assetType: 'Option',
+            timeInForce,
+            price,
+        };
+        // Add options-specific parameters to extras
+        const targetBroker = broker || this.tradingContext.broker;
+        const optionsExtras = {
+            ...extras,
+            ...(targetBroker && {
+                [targetBroker]: {
+                    ...extras[targetBroker],
+                    strikePrice: options.strikePrice,
+                    expirationDate: options.expirationDate,
+                    optionType: options.optionType,
+                    contractSize: options.contractSize || 100,
+                },
+            }),
+        };
+        return this.placeBrokerOrder(accessToken, orderParams, optionsExtras);
+    }
+    // Futures convenience methods
+    async placeFuturesMarketOrder(accessToken, symbol, orderQty, action, broker, accountNumber, extras = {}) {
+        return this.placeBrokerOrder(accessToken, {
+            broker,
+            accountNumber,
+            symbol,
+            orderQty,
+            action,
+            orderType: 'Market',
+            assetType: 'Futures',
+            timeInForce: 'day',
+        }, extras);
+    }
+    async placeFuturesLimitOrder(accessToken, symbol, orderQty, action, price, timeInForce = 'gtc', broker, accountNumber, extras = {}) {
+        return this.placeBrokerOrder(accessToken, {
+            broker,
+            accountNumber,
+            symbol,
+            orderQty,
+            action,
+            orderType: 'Limit',
+            assetType: 'Futures',
+            timeInForce,
+            price,
+        }, extras);
+    }
+    buildOrderRequestBody(params, extras = {}) {
+        const baseOrder = {
+            order_type: params.orderType,
+            asset_type: params.assetType,
+            action: params.action,
+            time_in_force: params.timeInForce.toLowerCase(),
+            account_number: params.accountNumber,
+            symbol: params.symbol,
+            order_qty: params.orderQty,
+        };
+        if (params.price !== undefined)
+            baseOrder.price = params.price;
+        if (params.stopPrice !== undefined)
+            baseOrder.stop_price = params.stopPrice;
+        // Apply broker-specific defaults
+        const brokerExtras = this.applyBrokerDefaults(params.broker, extras[params.broker] || {});
+        return {
+            broker: params.broker,
+            ...baseOrder,
+            ...brokerExtras,
+        };
+    }
+    buildModifyRequestBody(params, extras, broker) {
+        const requestBody = {
+            broker: broker,
+        };
+        if (params.orderType !== undefined)
+            requestBody.order_type = params.orderType;
+        if (params.assetType !== undefined)
+            requestBody.asset_type = params.assetType;
+        if (params.action !== undefined)
+            requestBody.action = params.action;
+        if (params.timeInForce !== undefined)
+            requestBody.time_in_force = params.timeInForce.toLowerCase();
+        if (params.accountNumber !== undefined)
+            requestBody.account_number = params.accountNumber;
+        if (params.symbol !== undefined)
+            requestBody.symbol = params.symbol;
+        if (params.orderQty !== undefined)
+            requestBody.order_qty = params.orderQty;
+        if (params.price !== undefined)
+            requestBody.price = params.price;
+        if (params.stopPrice !== undefined)
+            requestBody.stop_price = params.stopPrice;
+        // Apply broker-specific defaults
+        const brokerExtras = this.applyBrokerDefaults(broker, extras[broker] || {});
+        return {
+            ...requestBody,
+            ...brokerExtras,
+        };
+    }
+    applyBrokerDefaults(broker, extras) {
+        switch (broker) {
+            case 'robinhood':
+                return {
+                    extendedHours: extras.extendedHours ?? true,
+                    marketHours: extras.marketHours ?? 'regular_hours',
+                    trailType: extras.trailType ?? 'percentage',
+                    ...extras,
+                };
+            case 'ninja_trader':
+                return {
+                    accountSpec: extras.accountSpec ?? '',
+                    isAutomated: extras.isAutomated ?? true,
+                    ...extras,
+                };
+            case 'tasty_trade':
+                return {
+                    automatedSource: extras.automatedSource ?? true,
+                    ...extras,
+                };
+            default:
+                return extras;
+        }
+    }
+    async revokeToken(accessToken) {
+        return this.request('/auth/token/revoke', {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                Authorization: `Bearer ${accessToken}`,
+            },
+        });
+    }
+    async getUserToken(userId) {
+        return this.request('/auth/token', {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+            },
+            body: { userId },
+        });
+    }
+    getCurrentSessionState() {
+        return this.currentSessionState;
+    }
+    // Broker Data Management
+    async getBrokerList(accessToken) {
+        return this.request('/brokers/', {
+            method: 'GET',
+            headers: {
+                'Content-Type': 'application/json',
+                Authorization: `Bearer ${accessToken}`,
+                'Session-ID': this.currentSessionId || '',
+                'X-Session-ID': this.currentSessionId || '',
+                'X-Device-Info': JSON.stringify({
+                    ip_address: this.deviceInfo?.ip_address || '',
+                    user_agent: this.deviceInfo?.user_agent || '',
+                    fingerprint: this.deviceInfo?.fingerprint || '',
+                }),
+            },
+        });
+    }
+    async getBrokerAccounts(accessToken, options) {
+        const params = {};
+        if (options?.broker_name)
+            params.broker_name = options.broker_name;
+        if (options?.account_id)
+            params.account_id = options.account_id;
+        return this.request('/brokers/data/accounts', {
+            method: 'GET',
+            headers: {
+                'Content-Type': 'application/json',
+                Authorization: `Bearer ${accessToken}`,
+                'Session-ID': this.currentSessionId || '',
+                'X-Session-ID': this.currentSessionId || '',
+                'X-Device-Info': JSON.stringify({
+                    ip_address: this.deviceInfo?.ip_address || '',
+                    user_agent: this.deviceInfo?.user_agent || '',
+                    fingerprint: this.deviceInfo?.fingerprint || '',
+                }),
+            },
+            params,
+        });
+    }
+    async getBrokerOrders(accessToken, options) {
+        const params = {};
+        if (options?.broker_name)
+            params.broker_name = options.broker_name;
+        if (options?.account_id)
+            params.account_id = options.account_id;
+        if (options?.symbol)
+            params.symbol = options.symbol;
+        return this.request('/brokers/data/orders', {
+            method: 'GET',
+            headers: {
+                'Content-Type': 'application/json',
+                Authorization: `Bearer ${accessToken}`,
+                'Session-ID': this.currentSessionId || '',
+                'X-Session-ID': this.currentSessionId || '',
+                'X-Device-Info': JSON.stringify({
+                    ip_address: this.deviceInfo?.ip_address || '',
+                    user_agent: this.deviceInfo?.user_agent || '',
+                    fingerprint: this.deviceInfo?.fingerprint || '',
+                }),
+            },
+            params,
+        });
+    }
+    async getBrokerPositions(accessToken, options) {
+        const queryParams = {};
+        if (options?.broker_name)
+            queryParams.broker_name = options.broker_name;
+        if (options?.account_id)
+            queryParams.account_id = options.account_id;
+        if (options?.symbol)
+            queryParams.symbol = options.symbol;
+        return this.request('/brokers/data/positions', {
+            method: 'GET',
+            headers: {
+                Authorization: `Bearer ${accessToken}`,
+                'Content-Type': 'application/json',
+                'Session-ID': this.currentSessionId || '',
+                'X-Session-ID': this.currentSessionId || '',
+                'X-Device-Info': JSON.stringify({
+                    ip_address: this.deviceInfo?.ip_address || '',
+                    user_agent: this.deviceInfo?.user_agent || '',
+                    fingerprint: this.deviceInfo?.fingerprint || '',
+                }),
+            },
+            params: queryParams,
+        });
+    }
+    async getBrokerConnections(accessToken) {
+        return this.request('/brokers/connections', {
+            method: 'GET',
+            headers: {
+                Authorization: `Bearer ${accessToken}`,
+                'Content-Type': 'application/json',
+            },
+        });
+    }
+    // Automatic token management versions of broker methods
+    async getBrokerListAuto() {
+        const accessToken = await this.getValidAccessToken();
+        return this.getBrokerList(accessToken);
+    }
+    async getBrokerAccountsAuto(options) {
+        const accessToken = await this.getValidAccessToken();
+        return this.getBrokerAccounts(accessToken, options);
+    }
+    async getBrokerOrdersAuto(options) {
+        const accessToken = await this.getValidAccessToken();
+        return this.getBrokerOrders(accessToken, options);
+    }
+    async getBrokerPositionsAuto(options) {
+        const accessToken = await this.getValidAccessToken();
+        return this.getBrokerPositions(accessToken, options);
+    }
+    async getBrokerConnectionsAuto() {
+        const accessToken = await this.getValidAccessToken();
+        return this.getBrokerConnections(accessToken);
+    }
+    // Automatic token management versions of trading methods
+    async placeBrokerOrderAuto(params, extras = {}) {
+        const accessToken = await this.getValidAccessToken();
+        return this.placeBrokerOrder(accessToken, params, extras);
+    }
+    async placeStockMarketOrderAuto(symbol, orderQty, action, broker, accountNumber, extras = {}) {
+        const accessToken = await this.getValidAccessToken();
+        return this.placeStockMarketOrder(accessToken, symbol, orderQty, action, broker, accountNumber, extras);
+    }
+    async placeStockLimitOrderAuto(symbol, orderQty, action, price, timeInForce = 'gtc', broker, accountNumber, extras = {}) {
+        const accessToken = await this.getValidAccessToken();
+        return this.placeStockLimitOrder(accessToken, symbol, orderQty, action, price, timeInForce, broker, accountNumber, extras);
+    }
+    async placeStockStopOrderAuto(symbol, orderQty, action, stopPrice, timeInForce = 'day', broker, accountNumber, extras = {}) {
+        const accessToken = await this.getValidAccessToken();
+        return this.placeStockStopOrder(accessToken, symbol, orderQty, action, stopPrice, timeInForce, broker, accountNumber, extras);
+    }
+    // Page-based pagination methods
+    async getBrokerOrdersPage(page = 1, perPage = 100, filters) {
+        const accessToken = await this.getValidAccessToken();
+        const offset = (page - 1) * perPage;
+        const params = {
+            limit: perPage.toString(),
+            offset: offset.toString(),
+        };
+        // Add filter parameters
+        if (filters) {
+            if (filters.broker_id)
+                params.broker_id = filters.broker_id;
+            if (filters.connection_id)
+                params.connection_id = filters.connection_id;
+            if (filters.account_id)
+                params.account_id = filters.account_id;
+            if (filters.symbol)
+                params.symbol = filters.symbol;
+            if (filters.status)
+                params.status = filters.status;
+            if (filters.side)
+                params.side = filters.side;
+            if (filters.asset_type)
+                params.asset_type = filters.asset_type;
+            if (filters.created_after)
+                params.created_after = filters.created_after;
+            if (filters.created_before)
+                params.created_before = filters.created_before;
+        }
+        const response = await this.request('/brokers/data/orders', {
+            method: 'GET',
+            headers: {
+                'Content-Type': 'application/json',
+                Authorization: `Bearer ${accessToken}`,
+                'X-Company-ID': this.companyId || '',
+                'X-Session-ID': this.currentSessionId || '',
+                'X-CSRF-Token': this.csrfToken || '',
+                'X-Device-Info': JSON.stringify({
+                    ip_address: this.deviceInfo?.ip_address || '',
+                    user_agent: this.deviceInfo?.user_agent || '',
+                    fingerprint: this.deviceInfo?.fingerprint || '',
+                }),
+            },
+            params,
+        });
+        return new PaginatedResult(response.response_data, response.pagination || {
+            has_more: false,
+            next_offset: offset,
+            current_offset: offset,
+            limit: perPage,
+        });
+    }
+    async getBrokerAccountsPage(page = 1, perPage = 100, filters) {
+        const accessToken = await this.getValidAccessToken();
+        const offset = (page - 1) * perPage;
+        const params = {
+            limit: perPage.toString(),
+            offset: offset.toString(),
+        };
+        // Add filter parameters
+        if (filters) {
+            if (filters.broker_id)
+                params.broker_id = filters.broker_id;
+            if (filters.connection_id)
+                params.connection_id = filters.connection_id;
+            if (filters.account_type)
+                params.account_type = filters.account_type;
+            if (filters.status)
+                params.status = filters.status;
+            if (filters.currency)
+                params.currency = filters.currency;
+        }
+        const response = await this.request('/brokers/data/accounts', {
+            method: 'GET',
+            headers: {
+                'Content-Type': 'application/json',
+                Authorization: `Bearer ${accessToken}`,
+                'X-Company-ID': this.companyId || '',
+                'X-Session-ID': this.currentSessionId || '',
+                'X-CSRF-Token': this.csrfToken || '',
+                'X-Device-Info': JSON.stringify({
+                    ip_address: this.deviceInfo?.ip_address || '',
+                    user_agent: this.deviceInfo?.user_agent || '',
+                    fingerprint: this.deviceInfo?.fingerprint || '',
+                }),
+            },
+            params,
+        });
+        return new PaginatedResult(response.response_data, response.pagination || {
+            has_more: false,
+            next_offset: offset,
+            current_offset: offset,
+            limit: perPage,
+        });
+    }
+    async getBrokerPositionsPage(page = 1, perPage = 100, filters) {
+        const accessToken = await this.getValidAccessToken();
+        const offset = (page - 1) * perPage;
+        const params = {
+            limit: perPage.toString(),
+            offset: offset.toString(),
+        };
+        // Add filter parameters
+        if (filters) {
+            if (filters.broker_id)
+                params.broker_id = filters.broker_id;
+            if (filters.account_id)
+                params.account_id = filters.account_id;
+            if (filters.symbol)
+                params.symbol = filters.symbol;
+            if (filters.position_status)
+                params.position_status = filters.position_status;
+            if (filters.side)
+                params.side = filters.side;
+        }
+        const response = await this.request('/brokers/data/positions', {
+            method: 'GET',
+            headers: {
+                'Content-Type': 'application/json',
+                Authorization: `Bearer ${accessToken}`,
+                'X-Company-ID': this.companyId || '',
+                'X-Session-ID': this.currentSessionId || '',
+                'X-CSRF-Token': this.csrfToken || '',
+                'X-Device-Info': JSON.stringify({
+                    ip_address: this.deviceInfo?.ip_address || '',
+                    user_agent: this.deviceInfo?.user_agent || '',
+                    fingerprint: this.deviceInfo?.fingerprint || '',
+                }),
+            },
+            params,
+        });
+        return new PaginatedResult(response.response_data, response.pagination || {
+            has_more: false,
+            next_offset: offset,
+            current_offset: offset,
+            limit: perPage,
+        });
+    }
+    // Navigation methods
+    async getNextPage(previousResult, fetchFunction) {
+        if (!previousResult.hasNext) {
+            return null;
+        }
+        return fetchFunction(previousResult.metadata.nextOffset, previousResult.metadata.limit);
+    }
+    /**
+     * Check if this is a mock client
+     * @returns false for real API client
+     */
+    isMockClient() {
+        return false;
+    }
+}
+
+class EventEmitter {
+    constructor() {
+        this.events = new Map();
+    }
+    on(event, callback) {
+        if (!this.events.has(event)) {
+            this.events.set(event, new Set());
+        }
+        this.events.get(event).add(callback);
+    }
+    off(event, callback) {
+        if (this.events.has(event)) {
+            this.events.get(event).delete(callback);
+        }
+    }
+    once(event, callback) {
+        const onceCallback = (...args) => {
+            callback(...args);
+            this.off(event, onceCallback);
+        };
+        this.on(event, onceCallback);
+    }
+    emit(event, ...args) {
+        if (this.events.has(event)) {
+            this.events.get(event).forEach(callback => {
+                try {
+                    callback(...args);
+                }
+                catch (error) {
+                    console.error(`Error in event handler for ${event}:`, error);
+                }
+            });
+        }
+    }
+    removeAllListeners(event) {
+        if (event) {
+            this.events.delete(event);
+        }
+        else {
+            this.events.clear();
+        }
+    }
+    listenerCount(event) {
+        return this.events.get(event)?.size || 0;
+    }
+    listeners(event) {
+        return Array.from(this.events.get(event) || []);
+    }
+}
+
+class PortalUI {
+    constructor(portalUrl) {
+        this.iframe = null;
+        this.container = null;
+        this.messageHandler = null;
+        this.sessionId = null;
+        this.portalOrigin = null;
+        this.userToken = null;
+        this.originalBodyStyle = null;
+        this.createContainer();
+    }
+    createContainer() {
+        console.debug('[PortalUI] Creating container and iframe');
+        this.container = document.createElement('div');
+        this.container.style.cssText = `
+            position: fixed;
+            top: 0;
+            left: 0;
+            width: 100%;
+            height: 100%;
+            background: rgba(0, 0, 0, 0.5);
+            display: none;
+            z-index: 9999;
+        `;
+        this.iframe = document.createElement('iframe');
+        // Let the portal handle its own styling - only set essential attributes
+        this.iframe.style.cssText = `
+            position: absolute;
+            top: 50%;
+            left: 50%;
+            transform: translate(-50%, -50%);
+            width: 90%;
+            max-width: 500px;
+            height: 90%;
+            max-height: 600px;
+            border: none;
+            border-radius: 24px;
+        `;
+        // Set security headers
+        this.iframe.setAttribute('sandbox', 'allow-scripts allow-forms allow-popups allow-same-origin');
+        this.iframe.setAttribute('referrerpolicy', 'strict-origin-when-cross-origin');
+        this.iframe.setAttribute('allow', 'accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture');
+        // Add CSP meta tag to allow Google Fonts and other required resources
+        const meta = document.createElement('meta');
+        meta.setAttribute('http-equiv', 'Content-Security-Policy');
+        meta.setAttribute('content', `
+            default-src 'self' https:;
+            style-src 'self' 'unsafe-inline' https: https://fonts.googleapis.com https://fonts.gstatic.com https://cdn.jsdelivr.net;
+            font-src 'self' https://fonts.gstatic.com;
+            img-src 'self' data: https:;
+            script-src 'self' 'unsafe-inline' 'unsafe-eval' https:;
+            connect-src 'self' https:;
+            frame-src 'self' https:;
+        `
+            .replace(/\s+/g, ' ')
+            .trim());
+        this.iframe.contentDocument?.head.appendChild(meta);
+        this.container.appendChild(this.iframe);
+        document.body.appendChild(this.container);
+        console.debug('[PortalUI] Container and iframe created successfully');
+    }
+    /**
+     * Lock background scrolling by setting overflow: hidden on body
+     */
+    lockScroll() {
+        if (typeof document !== 'undefined' && document.body) {
+            // Store original body style to restore later
+            this.originalBodyStyle = document.body.style.cssText;
+            // Add overflow: hidden to prevent scrolling
+            document.body.style.overflow = 'hidden';
+            document.body.style.position = 'fixed';
+            document.body.style.width = '100%';
+            document.body.style.top = `-${window.scrollY}px`;
+            console.debug('[PortalUI] Background scroll locked');
+        }
+    }
+    /**
+     * Unlock background scrolling by restoring original body style
+     */
+    unlockScroll() {
+        if (typeof document !== 'undefined' && document.body && this.originalBodyStyle !== null) {
+            // Restore original body style
+            document.body.style.cssText = this.originalBodyStyle;
+            // Restore scroll position
+            const scrollY = document.body.style.top;
+            document.body.style.position = '';
+            document.body.style.top = '';
+            window.scrollTo(0, parseInt(scrollY || '0') * -1);
+            this.originalBodyStyle = null;
+            console.debug('[PortalUI] Background scroll unlocked');
+        }
+    }
+    show(url, sessionId, options = {}) {
+        if (!this.iframe || !this.container) {
+            this.createContainer();
+        }
+        // Set portalOrigin to the actual portal URL's origin
+        try {
+            this.portalOrigin = new URL(url).origin;
+        }
+        catch (e) {
+            this.portalOrigin = null;
+        }
+        this.sessionId = sessionId;
+        this.options = options;
+        this.container.style.display = 'block';
+        this.iframe.src = url;
+        // Lock background scrolling
+        this.lockScroll();
+        // Set up message handler
+        this.messageHandler = this.handleMessage.bind(this);
+        window.addEventListener('message', this.messageHandler);
+    }
+    hide() {
+        if (this.container) {
+            this.container.style.display = 'none';
+        }
+        if (this.iframe) {
+            this.iframe.src = '';
+        }
+        if (this.messageHandler) {
+            window.removeEventListener('message', this.messageHandler);
+            this.messageHandler = null;
+        }
+        this.sessionId = null;
+        // Unlock background scrolling
+        this.unlockScroll();
+    }
+    handleMessage(event) {
+        // Verify origin matches the portal URL
+        if (!this.portalOrigin || event.origin !== this.portalOrigin) {
+            console.warn('[PortalUI] Received message from unauthorized origin:', event.origin, 'Expected:', this.portalOrigin);
+            return;
+        }
+        const { type, userId, access_token, refresh_token, error, height, data } = event.data;
+        console.log('[PortalUI] Received message:', event.data);
+        switch (type) {
+            case 'portal-success': {
+                // Handle both direct userId and data.userId formats
+                const successUserId = userId || (data && data.userId);
+                const successAccessToken = access_token || (data && data.access_token);
+                const successRefreshToken = refresh_token || (data && data.refresh_token);
+                this.handlePortalSuccess(successUserId, successAccessToken, successRefreshToken);
+                break;
+            }
+            case 'portal-error': {
+                // Handle both direct error and data.message formats
+                const errorMessage = error || (data && data.message);
+                this.handlePortalError(errorMessage);
+                break;
+            }
+            case 'portal-close':
+                this.handlePortalClose();
+                break;
+            case 'event':
+                this.handleGenericEvent(data);
+                break;
+            case 'resize':
+                this.handleResize(height);
+                break;
+            // Legacy support for old message types
+            case 'success':
+                this.handleSuccess(userId, access_token, refresh_token);
+                break;
+            case 'error':
+                this.handleError(error);
+                break;
+            case 'close':
+                this.handleClose();
+                break;
+            default:
+                console.warn('[PortalUI] Received unhandled message type:', type);
+        }
+    }
+    handlePortalSuccess(userId, accessToken, refreshToken) {
+        if (!userId) {
+            console.error('[PortalUI] Missing userId in portal-success message');
+            return;
+        }
+        console.log('[PortalUI] Portal success - User connected:', userId);
+        // If tokens are provided, store them internally
+        if (accessToken && refreshToken) {
+            const userToken = {
+                accessToken: accessToken,
+                refreshToken: refreshToken,
+                expiresIn: 3600, // Default to 1 hour
+                user_id: userId,
+                tokenType: 'Bearer',
+                scope: 'api:access',
+            };
+            this.userToken = userToken;
+            console.log('[PortalUI] Portal authentication successful');
+        }
+        else {
+            console.warn('[PortalUI] No tokens received from portal');
+        }
+        // Pass userId to parent (SDK will handle tokens internally)
+        this.options?.onSuccess?.(userId);
+    }
+    handlePortalError(error) {
+        console.error('[PortalUI] Portal error:', error);
+        this.options?.onError?.(new Error(error || 'Unknown portal error'));
+    }
+    handlePortalClose() {
+        console.log('[PortalUI] Portal closed by user');
+        this.options?.onClose?.();
+        this.hide();
+    }
+    handleGenericEvent(data) {
+        if (!data || !data.type) {
+            console.warn('[PortalUI] Invalid event data:', data);
+            return;
+        }
+        console.log('[PortalUI] Generic event received:', data.type, data.data);
+        // Emit the event to be handled by the SDK
+        // This will be implemented in FinaticConnect
+        if (this.options?.onEvent) {
+            this.options.onEvent(data.type, data.data);
+        }
+    }
+    handleSuccess(userId, access_token, refresh_token) {
+        if (!userId || !access_token || !refresh_token) {
+            console.error('[PortalUI] Missing required fields in success message');
+            return;
+        }
+        // Convert portal tokens to UserToken format
+        const userToken = {
+            accessToken: access_token,
+            refreshToken: refresh_token,
+            expiresIn: 3600, // Default to 1 hour
+            user_id: userId,
+            tokenType: 'Bearer',
+            scope: 'api:access',
+        };
+        // Store tokens internally
+        this.userToken = userToken;
+        // Pass userId to parent
+        this.options?.onSuccess?.(userId);
+    }
+    handleError(error) {
+        console.error('[PortalUI] Received error:', error);
+        this.options?.onError?.(new Error(error || 'Unknown error'));
+    }
+    handleClose() {
+        console.log('[PortalUI] Received close message');
+        this.options?.onClose?.();
+        this.hide();
+    }
+    handleResize(height) {
+        if (height && this.iframe) {
+            console.log('[PortalUI] Received resize message:', height);
+            this.iframe.style.height = `${height}px`;
+        }
+    }
+    getTokens() {
+        return this.userToken;
+    }
+}
+
+/**
+ * Mock data provider for Finatic API endpoints
+ */
+class MockDataProvider {
+    constructor(config = {}) {
+        this.sessionData = new Map();
+        this.userTokens = new Map();
+        this.config = {
+            delay: config.delay || this.getRandomDelay(50, 200),
+            scenario: config.scenario || 'success',
+            customData: config.customData || {},
+        };
+    }
+    /**
+     * Get a random delay between min and max milliseconds
+     */
+    getRandomDelay(min, max) {
+        return Math.floor(Math.random() * (max - min + 1)) + min;
+    }
+    /**
+     * Simulate network delay
+     */
+    async simulateDelay() {
+        const delay = this.config.delay || this.getRandomDelay(50, 200);
+        await new Promise(resolve => setTimeout(resolve, delay));
+    }
+    /**
+     * Generate a realistic session ID
+     */
+    generateSessionId() {
+        return `session_${uuid.v4().replace(/-/g, '')}`;
+    }
+    /**
+     * Generate a realistic user ID
+     */
+    generateUserId() {
+        return `user_${uuid.v4().replace(/-/g, '').substring(0, 8)}`;
+    }
+    /**
+     * Generate a realistic company ID
+     */
+    generateCompanyId() {
+        return `company_${uuid.v4().replace(/-/g, '').substring(0, 8)}`;
+    }
+    /**
+     * Generate mock tokens
+     */
+    generateTokens(userId) {
+        const accessToken = `mock_access_${uuid.v4().replace(/-/g, '')}`;
+        const refreshToken = `mock_refresh_${uuid.v4().replace(/-/g, '')}`;
+        return {
+            accessToken,
+            refreshToken,
+            expiresIn: 3600, // 1 hour
+            user_id: userId,
+            tokenType: 'Bearer',
+            scope: 'read write',
+        };
+    }
+    // Authentication & Session Management Mocks
+    async mockStartSession(token, userId) {
+        await this.simulateDelay();
+        const sessionId = this.generateSessionId();
+        const companyId = this.generateCompanyId();
+        const actualUserId = userId || this.generateUserId();
+        const sessionData = {
+            session_id: sessionId,
+            state: SessionState.ACTIVE,
+            company_id: companyId,
+            status: 'active',
+            expires_at: new Date(Date.now() + 30 * 60 * 1000).toISOString(), // 30 minutes
+            user_id: actualUserId,
+            auto_login: false,
+        };
+        this.sessionData.set(sessionId, sessionData);
+        return {
+            data: sessionData,
+            message: 'Session started successfully',
+        };
+    }
+    async mockRequestOtp(sessionId, email) {
+        await this.simulateDelay();
+        return {
+            success: true,
+            message: 'OTP sent successfully',
+            data: true,
+        };
+    }
+    async mockVerifyOtp(sessionId, otp) {
+        await this.simulateDelay();
+        const userId = this.generateUserId();
+        const tokens = this.generateTokens(userId);
+        this.userTokens.set(userId, tokens);
+        return {
+            success: true,
+            message: 'OTP verified successfully',
+            data: {
+                access_token: tokens.accessToken,
+                refresh_token: tokens.refreshToken,
+                user_id: userId,
+                expires_in: tokens.expiresIn,
+                scope: tokens.scope,
+                token_type: tokens.tokenType,
+            },
+        };
+    }
+    async mockAuthenticateDirectly(sessionId, userId) {
+        await this.simulateDelay();
+        const tokens = this.generateTokens(userId);
+        this.userTokens.set(userId, tokens);
+        return {
+            success: true,
+            message: 'Authentication successful',
+            data: {
+                access_token: tokens.accessToken,
+                refresh_token: tokens.refreshToken,
+            },
+        };
+    }
+    async mockGetPortalUrl(sessionId) {
+        await this.simulateDelay();
+        const scenario = this.getScenario();
+        if (scenario === 'error') {
+            return {
+                success: false,
+                message: 'Failed to retrieve portal URL (mock error)',
+                data: { portal_url: '' },
+            };
+        }
+        if (scenario === 'network_error') {
+            throw new Error('Network error (mock)');
+        }
+        if (scenario === 'rate_limit') {
+            return {
+                success: false,
+                message: 'Rate limit exceeded (mock)',
+                data: { portal_url: '' },
+            };
+        }
+        if (scenario === 'auth_failure') {
+            return {
+                success: false,
+                message: 'Authentication failed (mock)',
+                data: { portal_url: '' },
+            };
+        }
+        // Default: success
+        return {
+            success: true,
+            message: 'Portal URL retrieved successfully',
+            data: {
+                portal_url: 'http://localhost:3000/mock-portal',
+            },
+        };
+    }
+    async mockValidatePortalSession(sessionId, signature) {
+        await this.simulateDelay();
+        return {
+            valid: true,
+            company_id: this.generateCompanyId(),
+            status: 'active',
+        };
+    }
+    async mockCompletePortalSession(sessionId) {
+        await this.simulateDelay();
+        return {
+            success: true,
+            message: 'Portal session completed successfully',
+            data: {
+                portal_url: `https://portal.finatic.dev/complete/${sessionId}`,
+            },
+        };
+    }
+    async mockRefreshToken(refreshToken) {
+        await this.simulateDelay();
+        const newAccessToken = `mock_access_${uuid.v4().replace(/-/g, '')}`;
+        const newRefreshToken = `mock_refresh_${uuid.v4().replace(/-/g, '')}`;
+        return {
+            success: true,
+            response_data: {
+                access_token: newAccessToken,
+                refresh_token: newRefreshToken,
+                expires_at: new Date(Date.now() + 3600 * 1000).toISOString(),
+                company_id: this.generateCompanyId(),
+                company_name: 'Mock Company',
+                email_verified: true,
+            },
+            message: 'Token refreshed successfully',
+        };
+    }
+    // Broker Management Mocks
+    async mockGetBrokerList() {
+        await this.simulateDelay();
+        const brokers = [
+            {
+                id: 'robinhood',
+                name: 'robinhood',
+                display_name: 'Robinhood',
+                description: 'Commission-free stock and options trading',
+                website: 'https://robinhood.com',
+                features: ['stocks', 'options', 'crypto', 'fractional_shares'],
+                auth_type: 'oauth',
+                logo_path: '/logos/robinhood.png',
+                is_active: true,
+            },
+            {
+                id: 'tasty_trade',
+                name: 'tasty_trade',
+                display_name: 'TastyTrade',
+                description: 'Options and futures trading platform',
+                website: 'https://tastytrade.com',
+                features: ['options', 'futures', 'stocks'],
+                auth_type: 'oauth',
+                logo_path: '/logos/tastytrade.png',
+                is_active: true,
+            },
+            {
+                id: 'ninja_trader',
+                name: 'ninja_trader',
+                display_name: 'NinjaTrader',
+                description: 'Advanced futures and forex trading platform',
+                website: 'https://ninjatrader.com',
+                features: ['futures', 'forex', 'options'],
+                auth_type: 'api_key',
+                logo_path: '/logos/ninjatrader.png',
+                is_active: true,
+            },
+        ];
+        return {
+            _id: uuid.v4(),
+            response_data: brokers,
+            message: 'Broker list retrieved successfully',
+            status_code: 200,
+            warnings: null,
+            errors: null,
+        };
+    }
+    async mockGetBrokerAccounts() {
+        await this.simulateDelay();
+        const accounts = [
+            {
+                id: uuid.v4(),
+                user_broker_connection_id: uuid.v4(),
+                broker_provided_account_id: '123456789',
+                account_name: 'Individual Account',
+                account_type: 'individual',
+                currency: 'USD',
+                cash_balance: 15000.5,
+                buying_power: 45000.0,
+                status: 'active',
+                created_at: new Date().toISOString(),
+                updated_at: new Date().toISOString(),
+                last_synced_at: new Date().toISOString(),
+            },
+            {
+                id: uuid.v4(),
+                user_broker_connection_id: uuid.v4(),
+                broker_provided_account_id: '987654321',
+                account_name: 'IRA Account',
+                account_type: 'ira',
+                currency: 'USD',
+                cash_balance: 25000.75,
+                buying_power: 75000.0,
+                status: 'active',
+                created_at: new Date().toISOString(),
+                updated_at: new Date().toISOString(),
+                last_synced_at: new Date().toISOString(),
+            },
+        ];
+        return {
+            _id: uuid.v4(),
+            response_data: accounts,
+            message: 'Broker accounts retrieved successfully',
+            status_code: 200,
+            warnings: null,
+            errors: null,
+        };
+    }
+    async mockGetBrokerConnections() {
+        await this.simulateDelay();
+        const connections = [
+            {
+                id: uuid.v4(),
+                broker_id: 'robinhood',
+                user_id: this.generateUserId(),
+                company_id: this.generateCompanyId(),
+                status: 'connected',
+                connected_at: new Date(Date.now() - 7 * 24 * 60 * 60 * 1000).toISOString(), // 7 days ago
+                last_synced_at: new Date().toISOString(),
+                permissions: {
+                    read: true,
+                    write: true,
+                },
+                metadata: {
+                    nickname: 'My Robinhood',
+                },
+                needs_reauth: false,
+            },
+            {
+                id: uuid.v4(),
+                broker_id: 'tasty_trade',
+                user_id: this.generateUserId(),
+                company_id: this.generateCompanyId(),
+                status: 'connected',
+                connected_at: new Date(Date.now() - 3 * 24 * 60 * 60 * 1000).toISOString(), // 3 days ago
+                last_synced_at: new Date().toISOString(),
+                permissions: {
+                    read: true,
+                    write: false,
+                },
+                metadata: {
+                    nickname: 'Tasty Options',
+                },
+                needs_reauth: false,
+            },
+        ];
+        return {
+            _id: uuid.v4(),
+            response_data: connections,
+            message: 'Broker connections retrieved successfully',
+            status_code: 200,
+            warnings: null,
+            errors: null,
+        };
+    }
+    // Portfolio & Trading Mocks
+    async mockGetHoldings() {
+        await this.simulateDelay();
+        const holdings = [
+            {
+                symbol: 'AAPL',
+                quantity: 100,
+                averagePrice: 150.25,
+                currentPrice: 175.5,
+                marketValue: 17550.0,
+                unrealizedPnL: 2525.0,
+                realizedPnL: 0,
+                costBasis: 15025.0,
+                currency: 'USD',
+            },
+            {
+                symbol: 'TSLA',
+                quantity: 50,
+                averagePrice: 200.0,
+                currentPrice: 220.75,
+                marketValue: 11037.5,
+                unrealizedPnL: 1037.5,
+                realizedPnL: 0,
+                costBasis: 10000.0,
+                currency: 'USD',
+            },
+            {
+                symbol: 'MSFT',
+                quantity: 75,
+                averagePrice: 300.0,
+                currentPrice: 325.25,
+                marketValue: 24393.75,
+                unrealizedPnL: 1893.75,
+                realizedPnL: 0,
+                costBasis: 22500.0,
+                currency: 'USD',
+            },
+        ];
+        return { data: holdings };
+    }
+    async mockGetPortfolio() {
+        await this.simulateDelay();
+        const portfolio = {
+            id: uuid.v4(),
+            name: 'Main Portfolio',
+            type: 'individual',
+            status: 'active',
+            cash: 15000.5,
+            buyingPower: 45000.0,
+            equity: 52981.25,
+            longMarketValue: 37981.25,
+            shortMarketValue: 0,
+            initialMargin: 0,
+            maintenanceMargin: 0,
+            lastEquity: 52000.0,
+            positions: [
+                {
+                    symbol: 'AAPL',
+                    quantity: 100,
+                    averagePrice: 150.25,
+                    currentPrice: 175.5,
+                    marketValue: 17550.0,
+                    unrealizedPnL: 2525.0,
+                    realizedPnL: 0,
+                    costBasis: 15025.0,
+                    currency: 'USD',
+                },
+                {
+                    symbol: 'TSLA',
+                    quantity: 50,
+                    averagePrice: 200.0,
+                    currentPrice: 220.75,
+                    marketValue: 11037.5,
+                    unrealizedPnL: 1037.5,
+                    realizedPnL: 0,
+                    costBasis: 10000.0,
+                    currency: 'USD',
+                },
+                {
+                    symbol: 'MSFT',
+                    quantity: 75,
+                    averagePrice: 300.0,
+                    currentPrice: 325.25,
+                    marketValue: 24393.75,
+                    unrealizedPnL: 1893.75,
+                    realizedPnL: 0,
+                    costBasis: 22500.0,
+                    currency: 'USD',
+                },
+            ],
+            performance: {
+                totalReturn: 0.089,
+                dailyReturn: 0.002,
+                weeklyReturn: 0.015,
+                monthlyReturn: 0.045,
+                yearlyReturn: 0.089,
+                maxDrawdown: -0.05,
+                sharpeRatio: 1.2,
+                beta: 0.95,
+                alpha: 0.02,
+            },
+        };
+        return { data: portfolio };
+    }
+    async mockGetOrders(filter) {
+        await this.simulateDelay();
+        const mockOrders = [
+            {
+                symbol: 'AAPL',
+                side: 'buy',
+                quantity: 100,
+                type_: 'market',
+                timeInForce: 'day',
+            },
+            {
+                symbol: 'TSLA',
+                side: 'sell',
+                quantity: 50,
+                type_: 'limit',
+                price: 250.0,
+                timeInForce: 'day',
+            },
+        ];
+        // Apply filters if provided
+        let filteredOrders = mockOrders;
+        if (filter) {
+            filteredOrders = this.applyOrderFilters(mockOrders, filter);
+        }
+        return { data: filteredOrders };
+    }
+    async mockGetBrokerOrders(filter) {
+        await this.simulateDelay();
+        // Determine how many orders to generate based on limit parameter
+        const limit = filter?.limit || 100;
+        const maxLimit = Math.min(limit, 1000); // Cap at 1000
+        const count = Math.max(1, maxLimit); // At least 1
+        // Generate diverse mock orders based on requested count
+        const mockOrders = this.generateMockOrders(count);
+        // Apply filters if provided
+        let filteredOrders = mockOrders;
+        if (filter) {
+            filteredOrders = this.applyBrokerOrderFilters(mockOrders, filter);
+        }
+        return {
+            data: filteredOrders,
+        };
+    }
+    async mockGetBrokerPositions(filter) {
+        await this.simulateDelay();
+        // Determine how many positions to generate based on limit parameter
+        const limit = filter?.limit || 100;
+        const maxLimit = Math.min(limit, 1000); // Cap at 1000
+        const count = Math.max(1, maxLimit); // At least 1
+        // Generate diverse mock positions based on requested count
+        const mockPositions = this.generateMockPositions(count);
+        // Apply filters if provided
+        let filteredPositions = mockPositions;
+        if (filter) {
+            filteredPositions = this.applyBrokerPositionFilters(mockPositions, filter);
+        }
+        return {
+            data: filteredPositions,
+        };
+    }
+    async mockGetBrokerDataAccounts(filter) {
+        await this.simulateDelay();
+        // Determine how many accounts to generate based on limit parameter
+        const limit = filter?.limit || 100;
+        const maxLimit = Math.min(limit, 1000); // Cap at 1000
+        const count = Math.max(1, maxLimit); // At least 1
+        // Generate diverse mock accounts based on requested count
+        const mockAccounts = this.generateMockAccounts(count);
+        // Apply filters if provided
+        let filteredAccounts = mockAccounts;
+        if (filter) {
+            filteredAccounts = this.applyBrokerAccountFilters(mockAccounts, filter);
+        }
+        return {
+            data: filteredAccounts,
+        };
+    }
+    async mockPlaceOrder(order) {
+        await this.simulateDelay();
+        return {
+            success: true,
+            response_data: {
+                orderId: uuid.v4(),
+                status: 'submitted',
+                broker: 'robinhood',
+                accountNumber: '123456789',
+            },
+            message: 'Order placed successfully',
+            status_code: 200,
+        };
+    }
+    // Utility methods
+    /**
+     * Get stored session data
+     */
+    getSessionData(sessionId) {
+        return this.sessionData.get(sessionId);
+    }
+    /**
+     * Get stored user token
+     */
+    getUserToken(userId) {
+        return this.userTokens.get(userId);
+    }
+    /**
+     * Clear all stored data
+     */
+    clearData() {
+        this.sessionData.clear();
+        this.userTokens.clear();
+    }
+    /**
+     * Update configuration
+     */
+    updateConfig(config) {
+        this.config = { ...this.config, ...config };
+    }
+    setScenario(scenario) {
+        this.config.scenario = scenario;
+    }
+    getScenario() {
+        return this.config.scenario || 'success';
+    }
+    // Helper methods to apply filters
+    applyOrderFilters(orders, filter) {
+        return orders.filter(order => {
+            if (filter.symbol && order.symbol !== filter.symbol)
+                return false;
+            if (filter.side && order.side !== filter.side)
+                return false;
+            return true;
+        });
+    }
+    applyBrokerOrderFilters(orders, filter) {
+        return orders.filter(order => {
+            if (filter.broker_id && order.broker_id !== filter.broker_id)
+                return false;
+            if (filter.connection_id && order.connection_id !== filter.connection_id)
+                return false;
+            if (filter.account_id && order.account_id !== filter.account_id)
+                return false;
+            if (filter.symbol && order.symbol !== filter.symbol)
+                return false;
+            if (filter.status && order.status !== filter.status)
+                return false;
+            if (filter.side && order.side !== filter.side)
+                return false;
+            if (filter.asset_type && order.asset_type !== filter.asset_type)
+                return false;
+            if (filter.created_after && new Date(order.created_at) < new Date(filter.created_after))
+                return false;
+            if (filter.created_before && new Date(order.created_at) > new Date(filter.created_before))
+                return false;
+            return true;
+        });
+    }
+    applyBrokerPositionFilters(positions, filter) {
+        return positions.filter(position => {
+            if (filter.broker_id && position.broker_id !== filter.broker_id)
+                return false;
+            if (filter.connection_id && position.connection_id !== filter.connection_id)
+                return false;
+            if (filter.account_id && position.account_id !== filter.account_id)
+                return false;
+            if (filter.symbol && position.symbol !== filter.symbol)
+                return false;
+            if (filter.side && position.side !== filter.side)
+                return false;
+            if (filter.asset_type && position.asset_type !== filter.asset_type)
+                return false;
+            if (filter.position_status && position.position_status !== filter.position_status)
+                return false;
+            if (filter.updated_after && new Date(position.updated_at) < new Date(filter.updated_after))
+                return false;
+            if (filter.updated_before && new Date(position.updated_at) > new Date(filter.updated_before))
+                return false;
+            return true;
+        });
+    }
+    applyBrokerAccountFilters(accounts, filter) {
+        return accounts.filter(account => {
+            if (filter.broker_id && account.broker_id !== filter.broker_id)
+                return false;
+            if (filter.connection_id && account.connection_id !== filter.connection_id)
+                return false;
+            if (filter.account_type && account.account_type !== filter.account_type)
+                return false;
+            if (filter.status && account.status !== filter.status)
+                return false;
+            if (filter.currency && account.currency !== filter.currency)
+                return false;
+            return true;
+        });
+    }
+    /**
+     * Generate mock orders with diverse data
+     */
+    generateMockOrders(count) {
+        const orders = [];
+        const symbols = [
+            'AAPL',
+            'TSLA',
+            'MSFT',
+            'GOOGL',
+            'AMZN',
+            'META',
+            'NVDA',
+            'NFLX',
+            'SPY',
+            'QQQ',
+            'IWM',
+            'VTI',
+            'BTC',
+            'ETH',
+            'ADA',
+        ];
+        const brokers = ['robinhood', 'alpaca', 'tasty_trade', 'ninja_trader'];
+        const orderTypes = ['market', 'limit', 'stop', 'stop_limit'];
+        const sides = ['buy', 'sell'];
+        const statuses = ['filled', 'pending', 'cancelled', 'rejected', 'partially_filled'];
+        const assetTypes = ['stock', 'option', 'crypto', 'future'];
+        for (let i = 0; i < count; i++) {
+            const symbol = symbols[Math.floor(Math.random() * symbols.length)];
+            const broker = brokers[Math.floor(Math.random() * brokers.length)];
+            const orderType = orderTypes[Math.floor(Math.random() * orderTypes.length)];
+            const side = sides[Math.floor(Math.random() * sides.length)];
+            const status = statuses[Math.floor(Math.random() * statuses.length)];
+            const assetType = assetTypes[Math.floor(Math.random() * assetTypes.length)];
+            const quantity = Math.floor(Math.random() * 1000) + 1;
+            const price = Math.random() * 500 + 10;
+            const isFilled = status === 'filled' || status === 'partially_filled';
+            const filledQuantity = isFilled ? Math.floor(quantity * (0.5 + Math.random() * 0.5)) : 0;
+            const filledAvgPrice = isFilled ? price * (0.95 + Math.random() * 0.1) : 0;
+            orders.push({
+                id: uuid.v4(),
+                broker_id: broker,
+                connection_id: uuid.v4(),
+                account_id: `account_${Math.floor(Math.random() * 1000000)}`,
+                order_id: `order_${String(i + 1).padStart(6, '0')}`,
+                symbol,
+                order_type: orderType,
+                side,
+                quantity,
+                price,
+                status,
+                asset_type: assetType,
+                created_at: new Date(Date.now() - Math.random() * 30 * 24 * 60 * 60 * 1000).toISOString(), // Random date within last 30 days
+                updated_at: new Date().toISOString(),
+                filled_at: isFilled ? new Date().toISOString() : undefined,
+                filled_quantity: filledQuantity,
+                filled_avg_price: filledAvgPrice,
+            });
+        }
+        return orders;
+    }
+    /**
+     * Generate mock positions with diverse data
+     */
+    generateMockPositions(count) {
+        const positions = [];
+        const symbols = [
+            'AAPL',
+            'TSLA',
+            'MSFT',
+            'GOOGL',
+            'AMZN',
+            'META',
+            'NVDA',
+            'NFLX',
+            'SPY',
+            'QQQ',
+            'IWM',
+            'VTI',
+            'BTC',
+            'ETH',
+            'ADA',
+        ];
+        const brokers = ['robinhood', 'alpaca', 'tasty_trade', 'ninja_trader'];
+        const sides = ['long', 'short'];
+        const assetTypes = ['stock', 'option', 'crypto', 'future'];
+        const positionStatuses = ['open', 'closed'];
+        for (let i = 0; i < count; i++) {
+            const symbol = symbols[Math.floor(Math.random() * symbols.length)];
+            const broker = brokers[Math.floor(Math.random() * brokers.length)];
+            const side = sides[Math.floor(Math.random() * sides.length)];
+            const assetType = assetTypes[Math.floor(Math.random() * assetTypes.length)];
+            const positionStatus = positionStatuses[Math.floor(Math.random() * positionStatuses.length)];
+            const quantity = Math.floor(Math.random() * 1000) + 1;
+            const averagePrice = Math.random() * 500 + 10;
+            const currentPrice = averagePrice * (0.8 + Math.random() * 0.4); // ±20% variation
+            const marketValue = quantity * currentPrice;
+            const costBasis = quantity * averagePrice;
+            const unrealizedGainLoss = marketValue - costBasis;
+            const unrealizedGainLossPercent = (unrealizedGainLoss / costBasis) * 100;
+            positions.push({
+                id: uuid.v4(),
+                broker_id: broker,
+                connection_id: uuid.v4(),
+                account_id: `account_${Math.floor(Math.random() * 1000000)}`,
+                symbol,
+                asset_type: assetType,
+                side,
+                quantity,
+                average_price: averagePrice,
+                market_value: marketValue,
+                cost_basis: costBasis,
+                unrealized_gain_loss: unrealizedGainLoss,
+                unrealized_gain_loss_percent: unrealizedGainLossPercent,
+                current_price: currentPrice,
+                last_price: currentPrice,
+                last_price_updated_at: new Date().toISOString(),
+                position_status: positionStatus,
+                created_at: new Date(Date.now() - Math.random() * 30 * 24 * 60 * 60 * 1000).toISOString(), // Random date within last 30 days
+                updated_at: new Date().toISOString(),
+            });
+        }
+        return positions;
+    }
+    /**
+     * Generate mock accounts with diverse data
+     */
+    generateMockAccounts(count) {
+        const accounts = [];
+        const brokers = ['robinhood', 'alpaca', 'tasty_trade', 'ninja_trader'];
+        const accountTypes = ['margin', 'cash', 'crypto_wallet', 'live', 'sim'];
+        const statuses = ['active', 'inactive'];
+        const currencies = ['USD', 'EUR', 'GBP', 'CAD'];
+        const accountNames = [
+            'Individual Account',
+            'Paper Trading',
+            'Retirement Account',
+            'Crypto Wallet',
+            'Margin Account',
+            'Cash Account',
+            'Trading Account',
+            'Investment Account',
+        ];
+        for (let i = 0; i < count; i++) {
+            const broker = brokers[Math.floor(Math.random() * brokers.length)];
+            const accountType = accountTypes[Math.floor(Math.random() * accountTypes.length)];
+            const status = statuses[Math.floor(Math.random() * statuses.length)];
+            const currency = currencies[Math.floor(Math.random() * currencies.length)];
+            const accountName = accountNames[Math.floor(Math.random() * accountNames.length)];
+            const cashBalance = Math.random() * 100000 + 1000;
+            const buyingPower = cashBalance * (1 + Math.random() * 2); // 1-3x cash balance
+            const equity = buyingPower * (0.8 + Math.random() * 0.4); // ±20% variation
+            accounts.push({
+                id: uuid.v4(),
+                broker_id: broker,
+                connection_id: uuid.v4(),
+                account_id: `account_${Math.floor(Math.random() * 1000000)}`,
+                account_name: `${accountName} ${i + 1}`,
+                account_type: accountType,
+                status,
+                currency,
+                cash_balance: cashBalance,
+                buying_power: buyingPower,
+                equity,
+                created_at: new Date(Date.now() - Math.random() * 365 * 24 * 60 * 60 * 1000).toISOString(), // Random date within last year
+                updated_at: new Date().toISOString(),
+                last_synced_at: new Date().toISOString(),
+            });
+        }
+        return accounts;
+    }
+}
+
+/**
+ * Mock API Client that implements the same interface as the real ApiClient
+ * but returns mock data instead of making HTTP requests
+ */
+class MockApiClient {
+    constructor(baseUrl, deviceInfo, mockConfig) {
+        this.currentSessionState = null;
+        this.currentSessionId = null;
+        this.tradingContext = {};
+        // Token management
+        this.tokenInfo = null;
+        this.refreshPromise = null;
+        this.REFRESH_BUFFER_MINUTES = 5;
+        // Session and company context
+        this.companyId = null;
+        this.csrfToken = null;
+        this.baseUrl = baseUrl;
+        this.deviceInfo = deviceInfo;
+        this.mockApiOnly = mockConfig?.mockApiOnly || false;
+        this.mockDataProvider = new MockDataProvider(mockConfig);
+        // Log that mocks are being used
+        if (this.mockApiOnly) {
+            console.log('🔧 Finatic SDK: Using MOCK API Client (API only - real portal)');
+        }
+        else {
+            console.log('🔧 Finatic SDK: Using MOCK API Client');
+        }
+    }
+    /**
+     * Store tokens after successful authentication
+     */
+    setTokens(accessToken, refreshToken, expiresAt, userId) {
+        this.tokenInfo = {
+            accessToken,
+            refreshToken,
+            expiresAt,
+            userId,
+        };
+    }
+    /**
+     * Get the current access token, refreshing if necessary
+     */
+    async getValidAccessToken() {
+        if (!this.tokenInfo) {
+            throw new AuthenticationError('No tokens available. Please authenticate first.');
+        }
+        // Check if token is expired or about to expire
+        if (this.isTokenExpired()) {
+            await this.refreshTokens();
+        }
+        return this.tokenInfo.accessToken;
+    }
+    /**
+     * Check if the current token is expired or about to expire
+     */
+    isTokenExpired() {
+        if (!this.tokenInfo)
+            return true;
+        const expiryTime = new Date(this.tokenInfo.expiresAt).getTime();
+        const currentTime = Date.now();
+        const bufferTime = this.REFRESH_BUFFER_MINUTES * 60 * 1000;
+        return currentTime >= expiryTime - bufferTime;
+    }
+    /**
+     * Refresh the access token using the refresh token
+     */
+    async refreshTokens() {
+        if (!this.tokenInfo) {
+            throw new AuthenticationError('No refresh token available.');
+        }
+        // If a refresh is already in progress, wait for it
+        if (this.refreshPromise) {
+            await this.refreshPromise;
+            return;
+        }
+        // Start a new refresh
+        this.refreshPromise = this.performTokenRefresh();
+        try {
+            await this.refreshPromise;
+        }
+        finally {
+            this.refreshPromise = null;
+        }
+    }
+    /**
+     * Perform the actual token refresh request
+     */
+    async performTokenRefresh() {
+        if (!this.tokenInfo) {
+            throw new AuthenticationError('No refresh token available.');
+        }
+        try {
+            const response = await this.mockDataProvider.mockRefreshToken(this.tokenInfo.refreshToken);
+            // Update stored tokens
+            this.tokenInfo = {
+                accessToken: response.response_data.access_token,
+                refreshToken: response.response_data.refresh_token,
+                expiresAt: response.response_data.expires_at,
+                userId: this.tokenInfo.userId,
+            };
+            return this.tokenInfo;
+        }
+        catch (error) {
+            // Clear tokens on refresh failure
+            this.tokenInfo = null;
+            throw new AuthenticationError('Token refresh failed. Please re-authenticate.', error);
+        }
+    }
+    /**
+     * Clear stored tokens (useful for logout)
+     */
+    clearTokens() {
+        this.tokenInfo = null;
+        this.refreshPromise = null;
+    }
+    /**
+     * Get current token info (for debugging/testing)
+     */
+    getTokenInfo() {
+        return this.tokenInfo ? { ...this.tokenInfo } : null;
+    }
+    /**
+     * Set session context (session ID, company ID, CSRF token)
+     */
+    setSessionContext(sessionId, companyId, csrfToken) {
+        this.currentSessionId = sessionId;
+        this.companyId = companyId;
+        this.csrfToken = csrfToken || null;
+    }
+    /**
+     * Get the current session ID
+     */
+    getCurrentSessionId() {
+        return this.currentSessionId;
+    }
+    /**
+     * Get the current company ID
+     */
+    getCurrentCompanyId() {
+        return this.companyId;
+    }
+    /**
+     * Get the current CSRF token
+     */
+    getCurrentCsrfToken() {
+        return this.csrfToken;
+    }
+    // Session Management
+    async startSession(token, userId) {
+        const response = await this.mockDataProvider.mockStartSession(token, userId);
+        // Store session ID and set state to ACTIVE
+        this.currentSessionId = response.data.session_id;
+        this.currentSessionState = SessionState.ACTIVE;
+        return response;
+    }
+    // OTP Flow
+    async requestOtp(sessionId, email) {
+        return this.mockDataProvider.mockRequestOtp(sessionId, email);
+    }
+    async verifyOtp(sessionId, otp) {
+        const response = await this.mockDataProvider.mockVerifyOtp(sessionId, otp);
+        // Store tokens after successful OTP verification
+        if (response.success && response.data) {
+            const expiresAt = new Date(Date.now() + response.data.expires_in * 1000).toISOString();
+            this.setTokens(response.data.access_token, response.data.refresh_token, expiresAt, response.data.user_id);
+        }
+        return response;
+    }
+    // Direct Authentication
+    async authenticateDirectly(sessionId, userId) {
+        // Ensure session is active before authenticating
+        if (this.currentSessionState !== SessionState.ACTIVE) {
+            throw new SessionError('Session must be in ACTIVE state to authenticate');
+        }
+        const response = await this.mockDataProvider.mockAuthenticateDirectly(sessionId, userId);
+        // Store tokens after successful direct authentication
+        if (response.success && response.data) {
+            // For direct auth, we don't get expires_in, so we'll set a default 1-hour expiry
+            const expiresAt = new Date(Date.now() + 60 * 60 * 1000).toISOString(); // 1 hour
+            this.setTokens(response.data.access_token, response.data.refresh_token, expiresAt, userId);
+        }
+        return response;
+    }
+    // Portal Management
+    async getPortalUrl(sessionId) {
+        if (this.currentSessionState !== SessionState.ACTIVE) {
+            throw new SessionError('Session must be in ACTIVE state to get portal URL');
+        }
+        // If in mockApiOnly mode, return the real portal URL
+        if (this.mockApiOnly) {
+            return {
+                success: true,
+                message: 'Portal URL retrieved successfully',
+                data: {
+                    portal_url: 'http://localhost:5173/companies',
+                },
+            };
+        }
+        return this.mockDataProvider.mockGetPortalUrl(sessionId);
+    }
+    async validatePortalSession(sessionId, signature) {
+        return this.mockDataProvider.mockValidatePortalSession(sessionId, signature);
+    }
+    async completePortalSession(sessionId) {
+        return this.mockDataProvider.mockCompletePortalSession(sessionId);
+    }
+    // Portfolio Management
+    async getHoldings(accessToken) {
+        return this.mockDataProvider.mockGetHoldings();
+    }
+    async getOrders(accessToken, filter) {
+        return this.mockDataProvider.mockGetOrders(filter);
+    }
+    async getPortfolio(accessToken) {
+        return this.mockDataProvider.mockGetPortfolio();
+    }
+    async placeOrder(accessToken, order) {
+        await this.mockDataProvider.mockPlaceOrder(order);
+    }
+    // New methods with automatic token management
+    async getHoldingsAuto() {
+        const accessToken = await this.getValidAccessToken();
+        return this.getHoldings(accessToken);
+    }
+    async getOrdersAuto() {
+        const accessToken = await this.getValidAccessToken();
+        return this.getOrders(accessToken);
+    }
+    async getPortfolioAuto() {
+        const accessToken = await this.getValidAccessToken();
+        return this.getPortfolio(accessToken);
+    }
+    async placeOrderAuto(order) {
+        const accessToken = await this.getValidAccessToken();
+        return this.placeOrder(accessToken, order);
+    }
+    // Enhanced Trading Methods with Session Management
+    async placeBrokerOrder(accessToken, params, extras = {}) {
+        // Merge context with provided parameters
+        const fullParams = {
+            broker: (params.broker || this.tradingContext.broker) ||
+                (() => {
+                    throw new Error('Broker not set. Call setBroker() or pass broker parameter.');
+                })(),
+            accountNumber: params.accountNumber ||
+                this.tradingContext.accountNumber ||
+                (() => {
+                    throw new Error('Account not set. Call setAccount() or pass accountNumber parameter.');
+                })(),
+            symbol: params.symbol,
+            orderQty: params.orderQty,
+            action: params.action,
+            orderType: params.orderType,
+            assetType: params.assetType,
+            timeInForce: params.timeInForce || 'day',
+            price: params.price,
+            stopPrice: params.stopPrice,
+        };
+        // Convert timeInForce to the Order interface format
+        const timeInForce = fullParams.timeInForce === 'gtd' ? 'gtc' : fullParams.timeInForce;
+        return this.mockDataProvider.mockPlaceOrder({
+            symbol: fullParams.symbol,
+            side: fullParams.action.toLowerCase(),
+            quantity: fullParams.orderQty,
+            type_: fullParams.orderType.toLowerCase(),
+            timeInForce: timeInForce,
+            price: fullParams.price,
+            stopPrice: fullParams.stopPrice,
+        });
+    }
+    async cancelBrokerOrder(orderId, broker, extras = {}) {
+        return {
+            success: true,
+            response_data: {
+                orderId,
+                status: 'cancelled',
+                broker: broker || this.tradingContext.broker || 'robinhood',
+                accountNumber: this.tradingContext.accountNumber || '123456789',
+            },
+            message: 'Order cancelled successfully',
+            status_code: 200,
+        };
+    }
+    async modifyBrokerOrder(orderId, params, broker, extras = {}) {
+        return {
+            success: true,
+            response_data: {
+                orderId,
+                status: 'modified',
+                broker: broker || this.tradingContext.broker || 'robinhood',
+                accountNumber: this.tradingContext.accountNumber || '123456789',
+            },
+            message: 'Order modified successfully',
+            status_code: 200,
+        };
+    }
+    // Context management methods
+    setBroker(broker) {
+        this.tradingContext.broker = broker;
+        // Clear account when broker changes
+        this.tradingContext.accountNumber = undefined;
+        this.tradingContext.accountId = undefined;
+    }
+    setAccount(accountNumber, accountId) {
+        this.tradingContext.accountNumber = accountNumber;
+        this.tradingContext.accountId = accountId;
+    }
+    getTradingContext() {
+        return { ...this.tradingContext };
+    }
+    clearTradingContext() {
+        this.tradingContext = {};
+    }
+    // Stock convenience methods
+    async placeStockMarketOrder(accessToken, symbol, orderQty, action, broker, accountNumber, extras = {}) {
+        return this.placeBrokerOrder(accessToken, {
+            broker,
+            accountNumber,
+            symbol,
+            orderQty,
+            action,
+            orderType: 'Market',
+            assetType: 'Stock',
+            timeInForce: 'day',
+        }, extras);
+    }
+    async placeStockLimitOrder(accessToken, symbol, orderQty, action, price, timeInForce = 'gtc', broker, accountNumber, extras = {}) {
+        return this.placeBrokerOrder(accessToken, {
+            broker,
+            accountNumber,
+            symbol,
+            orderQty,
+            action,
+            orderType: 'Limit',
+            assetType: 'Stock',
+            timeInForce,
+            price,
+        }, extras);
+    }
+    async placeStockStopOrder(accessToken, symbol, orderQty, action, stopPrice, timeInForce = 'day', broker, accountNumber, extras = {}) {
+        return this.placeBrokerOrder(accessToken, {
+            broker,
+            accountNumber,
+            symbol,
+            orderQty,
+            action,
+            orderType: 'Stop',
+            assetType: 'Stock',
+            timeInForce,
+            stopPrice,
+        }, extras);
+    }
+    // Crypto convenience methods
+    async placeCryptoMarketOrder(accessToken, symbol, orderQty, action, options = {}, broker, accountNumber, extras = {}) {
+        const orderParams = {
+            broker,
+            accountNumber,
+            symbol,
+            orderQty: options.quantity || orderQty,
+            action,
+            orderType: 'Market',
+            assetType: 'Crypto',
+            timeInForce: 'gtc', // Crypto typically uses GTC
+        };
+        return this.placeBrokerOrder(accessToken, orderParams, extras);
+    }
+    async placeCryptoLimitOrder(accessToken, symbol, orderQty, action, price, timeInForce = 'gtc', options = {}, broker, accountNumber, extras = {}) {
+        const orderParams = {
+            broker,
+            accountNumber,
+            symbol,
+            orderQty: options.quantity || orderQty,
+            action,
+            orderType: 'Limit',
+            assetType: 'Crypto',
+            timeInForce,
+            price,
+        };
+        return this.placeBrokerOrder(accessToken, orderParams, extras);
+    }
+    // Options convenience methods
+    async placeOptionsMarketOrder(accessToken, symbol, orderQty, action, options, broker, accountNumber, extras = {}) {
+        const orderParams = {
+            broker,
+            accountNumber,
+            symbol,
+            orderQty,
+            action,
+            orderType: 'Market',
+            assetType: 'Option',
+            timeInForce: 'day',
+        };
+        return this.placeBrokerOrder(accessToken, orderParams, extras);
+    }
+    async placeOptionsLimitOrder(accessToken, symbol, orderQty, action, price, options, timeInForce = 'gtc', broker, accountNumber, extras = {}) {
+        const orderParams = {
+            broker,
+            accountNumber,
+            symbol,
+            orderQty,
+            action,
+            orderType: 'Limit',
+            assetType: 'Option',
+            timeInForce,
+            price,
+        };
+        return this.placeBrokerOrder(accessToken, orderParams, extras);
+    }
+    // Futures convenience methods
+    async placeFuturesMarketOrder(accessToken, symbol, orderQty, action, broker, accountNumber, extras = {}) {
+        return this.placeBrokerOrder(accessToken, {
+            broker,
+            accountNumber,
+            symbol,
+            orderQty,
+            action,
+            orderType: 'Market',
+            assetType: 'Futures',
+            timeInForce: 'day',
+        }, extras);
+    }
+    async placeFuturesLimitOrder(accessToken, symbol, orderQty, action, price, timeInForce = 'gtc', broker, accountNumber, extras = {}) {
+        return this.placeBrokerOrder(accessToken, {
+            broker,
+            accountNumber,
+            symbol,
+            orderQty,
+            action,
+            orderType: 'Limit',
+            assetType: 'Futures',
+            timeInForce,
+            price,
+        }, extras);
+    }
+    async revokeToken(accessToken) {
+        // Clear tokens on revoke
+        this.clearTokens();
+    }
+    async getUserToken(userId) {
+        const token = this.mockDataProvider.getUserToken(userId);
+        if (!token) {
+            throw new AuthenticationError('User token not found');
+        }
+        return token;
+    }
+    getCurrentSessionState() {
+        return this.currentSessionState;
+    }
+    // Broker Data Management
+    async getBrokerList(accessToken) {
+        return this.mockDataProvider.mockGetBrokerList();
+    }
+    async getBrokerAccounts(accessToken, options) {
+        return this.mockDataProvider.mockGetBrokerAccounts();
+    }
+    async getBrokerOrders(accessToken, options) {
+        // Return empty orders for now - keeping original interface
+        return {
+            _id: uuid.v4(),
+            response_data: [],
+            message: 'Broker orders retrieved successfully',
+            status_code: 200,
+            warnings: null,
+            errors: null,
+        };
+    }
+    async getBrokerPositions(accessToken, options) {
+        // Return empty positions for now - keeping original interface
+        return {
+            _id: uuid.v4(),
+            response_data: [],
+            message: 'Broker positions retrieved successfully',
+            status_code: 200,
+            warnings: null,
+            errors: null,
+        };
+    }
+    // New broker data methods with filtering support
+    async getBrokerOrdersWithFilter(filter) {
+        return this.mockDataProvider.mockGetBrokerOrders(filter);
+    }
+    async getBrokerPositionsWithFilter(filter) {
+        return this.mockDataProvider.mockGetBrokerPositions(filter);
+    }
+    async getBrokerDataAccountsWithFilter(filter) {
+        return this.mockDataProvider.mockGetBrokerDataAccounts(filter);
+    }
+    // Page-based pagination methods
+    async getBrokerOrdersPage(page = 1, perPage = 100, filters) {
+        const mockOrders = await this.mockDataProvider.mockGetBrokerOrders(filters);
+        const orders = mockOrders.data;
+        // Simulate pagination
+        const startIndex = (page - 1) * perPage;
+        const endIndex = startIndex + perPage;
+        const paginatedOrders = orders.slice(startIndex, endIndex);
+        const hasMore = endIndex < orders.length;
+        const nextOffset = hasMore ? endIndex : startIndex;
+        // Create navigation callback for mock pagination
+        const navigationCallback = async (newOffset, newLimit) => {
+            const newStartIndex = newOffset;
+            const newEndIndex = newStartIndex + newLimit;
+            const newPaginatedOrders = orders.slice(newStartIndex, newEndIndex);
+            const newHasMore = newEndIndex < orders.length;
+            const newNextOffset = newHasMore ? newEndIndex : newStartIndex;
+            return new PaginatedResult(newPaginatedOrders, {
+                has_more: newHasMore,
+                next_offset: newNextOffset,
+                current_offset: newStartIndex,
+                limit: newLimit,
+            }, navigationCallback);
+        };
+        return new PaginatedResult(paginatedOrders, {
+            has_more: hasMore,
+            next_offset: nextOffset,
+            current_offset: startIndex,
+            limit: perPage,
+        }, navigationCallback);
+    }
+    async getBrokerAccountsPage(page = 1, perPage = 100, filters) {
+        const mockAccounts = await this.mockDataProvider.mockGetBrokerDataAccounts(filters);
+        const accounts = mockAccounts.data;
+        // Simulate pagination
+        const startIndex = (page - 1) * perPage;
+        const endIndex = startIndex + perPage;
+        const paginatedAccounts = accounts.slice(startIndex, endIndex);
+        const hasMore = endIndex < accounts.length;
+        const nextOffset = hasMore ? endIndex : startIndex;
+        // Create navigation callback for mock pagination
+        const navigationCallback = async (newOffset, newLimit) => {
+            const newStartIndex = newOffset;
+            const newEndIndex = newStartIndex + newLimit;
+            const newPaginatedAccounts = accounts.slice(newStartIndex, newEndIndex);
+            const newHasMore = newEndIndex < accounts.length;
+            const newNextOffset = newHasMore ? newEndIndex : newStartIndex;
+            return new PaginatedResult(newPaginatedAccounts, {
+                has_more: newHasMore,
+                next_offset: newNextOffset,
+                current_offset: newStartIndex,
+                limit: newLimit,
+            }, navigationCallback);
+        };
+        return new PaginatedResult(paginatedAccounts, {
+            has_more: hasMore,
+            next_offset: nextOffset,
+            current_offset: startIndex,
+            limit: perPage,
+        }, navigationCallback);
+    }
+    async getBrokerPositionsPage(page = 1, perPage = 100, filters) {
+        const mockPositions = await this.mockDataProvider.mockGetBrokerPositions(filters);
+        const positions = mockPositions.data;
+        // Simulate pagination
+        const startIndex = (page - 1) * perPage;
+        const endIndex = startIndex + perPage;
+        const paginatedPositions = positions.slice(startIndex, endIndex);
+        const hasMore = endIndex < positions.length;
+        const nextOffset = hasMore ? endIndex : startIndex;
+        // Create navigation callback for mock pagination
+        const navigationCallback = async (newOffset, newLimit) => {
+            const newStartIndex = newOffset;
+            const newEndIndex = newStartIndex + newLimit;
+            const newPaginatedPositions = positions.slice(newStartIndex, newEndIndex);
+            const newHasMore = newEndIndex < positions.length;
+            const newNextOffset = newHasMore ? newEndIndex : newStartIndex;
+            return new PaginatedResult(newPaginatedPositions, {
+                has_more: newHasMore,
+                next_offset: newNextOffset,
+                current_offset: newStartIndex,
+                limit: newLimit,
+            }, navigationCallback);
+        };
+        return new PaginatedResult(paginatedPositions, {
+            has_more: hasMore,
+            next_offset: nextOffset,
+            current_offset: startIndex,
+            limit: perPage,
+        }, navigationCallback);
+    }
+    async getBrokerConnections(accessToken) {
+        return this.mockDataProvider.mockGetBrokerConnections();
+    }
+    // Automatic token management versions of broker methods
+    async getBrokerListAuto() {
+        const accessToken = await this.getValidAccessToken();
+        return this.getBrokerList(accessToken);
+    }
+    async getBrokerAccountsAuto(options) {
+        const accessToken = await this.getValidAccessToken();
+        return this.getBrokerAccounts(accessToken, options);
+    }
+    async getBrokerOrdersAuto(options) {
+        const accessToken = await this.getValidAccessToken();
+        return this.getBrokerOrders(accessToken, options);
+    }
+    async getBrokerPositionsAuto(options) {
+        const accessToken = await this.getValidAccessToken();
+        return this.getBrokerPositions(accessToken, options);
+    }
+    async getBrokerConnectionsAuto() {
+        const accessToken = await this.getValidAccessToken();
+        return this.getBrokerConnections(accessToken);
+    }
+    // Automatic token management versions of trading methods
+    async placeBrokerOrderAuto(params, extras = {}) {
+        const accessToken = await this.getValidAccessToken();
+        return this.placeBrokerOrder(accessToken, params, extras);
+    }
+    async placeStockMarketOrderAuto(symbol, orderQty, action, broker, accountNumber, extras = {}) {
+        const accessToken = await this.getValidAccessToken();
+        return this.placeStockMarketOrder(accessToken, symbol, orderQty, action, broker, accountNumber, extras);
+    }
+    async placeStockLimitOrderAuto(symbol, orderQty, action, price, timeInForce = 'gtc', broker, accountNumber, extras = {}) {
+        const accessToken = await this.getValidAccessToken();
+        return this.placeStockLimitOrder(accessToken, symbol, orderQty, action, price, timeInForce, broker, accountNumber, extras);
+    }
+    async placeStockStopOrderAuto(symbol, orderQty, action, stopPrice, timeInForce = 'day', broker, accountNumber, extras = {}) {
+        const accessToken = await this.getValidAccessToken();
+        return this.placeStockStopOrder(accessToken, symbol, orderQty, action, stopPrice, timeInForce, broker, accountNumber, extras);
+    }
+    // Utility methods for mock system
+    getMockDataProvider() {
+        return this.mockDataProvider;
+    }
+    clearMockData() {
+        this.mockDataProvider.clearData();
+    }
+    /**
+     * Check if this is a mock client
+     * @returns true if this is a mock client
+     */
+    isMockClient() {
+        return true;
+    }
+}
+
+/**
+ * Utility functions for mock system environment detection
+ */
+/**
+ * Check if mocks should be used based on environment variables
+ * Supports both browser and Node.js environments
+ */
+function shouldUseMocks() {
+    // Check Node.js environment
+    if (typeof process !== 'undefined' && process?.env) {
+        return (process.env.FINATIC_USE_MOCKS === 'true' ||
+            process.env.NEXT_PUBLIC_FINATIC_USE_MOCKS === 'true');
+    }
+    // Check browser environment
+    if (typeof window !== 'undefined') {
+        // Check global variable
+        if (window.FINATIC_USE_MOCKS === 'true') {
+            return true;
+        }
+        // Check Next.js public environment variables
+        if (window.NEXT_PUBLIC_FINATIC_USE_MOCKS === 'true') {
+            return true;
+        }
+        // Check localStorage
+        try {
+            return localStorage.getItem('FINATIC_USE_MOCKS') === 'true';
+        }
+        catch (error) {
+            // localStorage might not be available
+            return false;
+        }
+    }
+    return false;
+}
+/**
+ * Check if only API should be mocked (but portal should use real URL)
+ */
+function shouldMockApiOnly() {
+    // Check Node.js environment
+    if (typeof process !== 'undefined' && process?.env) {
+        return (process.env.FINATIC_MOCK_API_ONLY === 'true' ||
+            process.env.NEXT_PUBLIC_FINATIC_MOCK_API_ONLY === 'true');
+    }
+    // Check browser environment
+    if (typeof window !== 'undefined') {
+        // Check global variable
+        if (window.FINATIC_MOCK_API_ONLY === 'true') {
+            return true;
+        }
+        // Check Next.js public environment variables
+        if (window.NEXT_PUBLIC_FINATIC_MOCK_API_ONLY === 'true') {
+            return true;
+        }
+        // Check localStorage
+        try {
+            return localStorage.getItem('FINATIC_MOCK_API_ONLY') === 'true';
+        }
+        catch (error) {
+            // localStorage might not be available
+            return false;
+        }
+    }
+    return false;
+}
+/**
+ * Get mock configuration from environment
+ */
+function getMockConfig() {
+    const enabled = shouldUseMocks();
+    const mockApiOnly = shouldMockApiOnly();
+    let delay;
+    // Check for custom delay in Node.js
+    if (typeof process !== 'undefined' && process?.env?.FINATIC_MOCK_DELAY) {
+        delay = parseInt(process.env.FINATIC_MOCK_DELAY, 10);
+    }
+    // Check for custom delay in browser
+    if (typeof window !== 'undefined') {
+        try {
+            const storedDelay = localStorage.getItem('FINATIC_MOCK_DELAY');
+            if (storedDelay) {
+                delay = parseInt(storedDelay, 10);
+            }
+        }
+        catch (error) {
+            // localStorage might not be available
+        }
+    }
+    return { enabled, delay, mockApiOnly };
+}
+
+/**
+ * Factory class for creating API clients (real or mock)
+ */
+class MockFactory {
+    /**
+     * Create an API client based on environment configuration
+     * @param baseUrl - The base URL for the API
+     * @param deviceInfo - Optional device information
+     * @param mockConfig - Optional mock configuration (only used if mocks are enabled)
+     * @returns ApiClient or MockApiClient instance
+     */
+    static createApiClient(baseUrl, deviceInfo, mockConfig) {
+        const useMocks = shouldUseMocks();
+        const mockApiOnly = shouldMockApiOnly();
+        if (useMocks || mockApiOnly) {
+            // Merge environment config with provided config
+            const envConfig = getMockConfig();
+            const finalConfig = {
+                delay: mockConfig?.delay || envConfig.delay,
+                scenario: mockConfig?.scenario || 'success',
+                customData: mockConfig?.customData || {},
+                mockApiOnly: mockApiOnly, // Pass this flag to the mock client
+            };
+            return new MockApiClient(baseUrl, deviceInfo, finalConfig);
+        }
+        else {
+            return new ApiClient(baseUrl, deviceInfo);
+        }
+    }
+    /**
+     * Force create a mock API client regardless of environment settings
+     * @param baseUrl - The base URL for the API
+     * @param deviceInfo - Optional device information
+     * @param mockConfig - Optional mock configuration
+     * @returns MockApiClient instance
+     */
+    static createMockApiClient(baseUrl, deviceInfo, mockConfig) {
+        return new MockApiClient(baseUrl, deviceInfo, mockConfig);
+    }
+    /**
+     * Force create a real API client regardless of environment settings
+     * @param baseUrl - The base URL for the API
+     * @param deviceInfo - Optional device information
+     * @returns ApiClient instance
+     */
+    static createRealApiClient(baseUrl, deviceInfo) {
+        return new ApiClient(baseUrl, deviceInfo);
+    }
+    /**
+     * Check if mocks are currently enabled
+     * @returns boolean indicating if mocks are enabled
+     */
+    static isMockMode() {
+        return shouldUseMocks();
+    }
+    /**
+     * Get current mock configuration
+     * @returns Mock configuration object
+     */
+    static getMockConfig() {
+        return getMockConfig();
+    }
+}
+
+// Dark theme (default Finatic theme)
+const darkTheme = {
+    mode: 'dark',
+    colors: {
+        background: {
+            primary: '#000000',
+            secondary: '#1a1a1a',
+            tertiary: '#2a2a2a',
+            accent: 'rgba(0, 255, 255, 0.1)',
+            glass: 'rgba(255, 255, 255, 0.05)',
+        },
+        status: {
+            connected: '#00FFFF',
+            disconnected: '#EF4444',
+            warning: '#F59E0B',
+            pending: '#8B5CF6',
+            error: '#EF4444',
+            success: '#00FFFF',
+        },
+        text: {
+            primary: '#FFFFFF',
+            secondary: '#CBD5E1',
+            muted: '#94A3B8',
+            inverse: '#000000',
+        },
+        border: {
+            primary: 'rgba(0, 255, 255, 0.2)',
+            secondary: 'rgba(255, 255, 255, 0.1)',
+            hover: 'rgba(0, 255, 255, 0.4)',
+            focus: 'rgba(0, 255, 255, 0.6)',
+            accent: '#00FFFF',
+        },
+        input: {
+            background: '#1a1a1a',
+            border: 'rgba(0, 255, 255, 0.2)',
+            borderFocus: '#00FFFF',
+            text: '#FFFFFF',
+            placeholder: '#94A3B8',
+        },
+        button: {
+            primary: {
+                background: '#00FFFF',
+                text: '#000000',
+                hover: '#00E6E6',
+                active: '#00CCCC',
+            },
+            secondary: {
+                background: 'transparent',
+                text: '#00FFFF',
+                border: '#00FFFF',
+                hover: 'rgba(0, 255, 255, 0.1)',
+                active: 'rgba(0, 255, 255, 0.2)',
+            },
+        },
+    },
+    branding: {
+        primaryColor: '#00FFFF',
+    },
+};
+// Light theme with cyan accents
+const lightTheme = {
+    mode: 'light',
+    colors: {
+        background: {
+            primary: '#FFFFFF',
+            secondary: '#F8FAFC',
+            tertiary: '#F1F5F9',
+            accent: 'rgba(0, 255, 255, 0.1)',
+            glass: 'rgba(0, 0, 0, 0.05)',
+        },
+        status: {
+            connected: '#00FFFF',
+            disconnected: '#EF4444',
+            warning: '#F59E0B',
+            pending: '#8B5CF6',
+            error: '#EF4444',
+            success: '#00FFFF',
+        },
+        text: {
+            primary: '#1E293B',
+            secondary: '#64748B',
+            muted: '#94A3B8',
+            inverse: '#FFFFFF',
+        },
+        border: {
+            primary: 'rgba(0, 255, 255, 0.2)',
+            secondary: 'rgba(0, 0, 0, 0.1)',
+            hover: 'rgba(0, 255, 255, 0.4)',
+            focus: 'rgba(0, 255, 255, 0.6)',
+            accent: '#00FFFF',
+        },
+        input: {
+            background: '#FFFFFF',
+            border: 'rgba(0, 255, 255, 0.2)',
+            borderFocus: '#00FFFF',
+            text: '#1E293B',
+            placeholder: '#94A3B8',
+        },
+        button: {
+            primary: {
+                background: '#00FFFF',
+                text: '#000000',
+                hover: '#00E6E6',
+                active: '#00CCCC',
+            },
+            secondary: {
+                background: 'transparent',
+                text: '#00FFFF',
+                border: '#00FFFF',
+                hover: 'rgba(0, 255, 255, 0.1)',
+                active: 'rgba(0, 255, 255, 0.2)',
+            },
+        },
+    },
+    branding: {
+        primaryColor: '#00FFFF',
+    },
+};
+// Corporate blue theme
+const corporateBlueTheme = {
+    mode: 'dark',
+    colors: {
+        background: {
+            primary: '#1E293B',
+            secondary: '#334155',
+            tertiary: '#475569',
+            accent: 'rgba(59, 130, 246, 0.1)',
+            glass: 'rgba(255, 255, 255, 0.05)',
+        },
+        status: {
+            connected: '#3B82F6',
+            disconnected: '#EF4444',
+            warning: '#F59E0B',
+            pending: '#8B5CF6',
+            error: '#EF4444',
+            success: '#10B981',
+        },
+        text: {
+            primary: '#F8FAFC',
+            secondary: '#CBD5E1',
+            muted: '#94A3B8',
+            inverse: '#1E293B',
+        },
+        border: {
+            primary: 'rgba(59, 130, 246, 0.2)',
+            secondary: 'rgba(255, 255, 255, 0.1)',
+            hover: 'rgba(59, 130, 246, 0.4)',
+            focus: 'rgba(59, 130, 246, 0.6)',
+            accent: '#3B82F6',
+        },
+        input: {
+            background: '#334155',
+            border: 'rgba(59, 130, 246, 0.2)',
+            borderFocus: '#3B82F6',
+            text: '#F8FAFC',
+            placeholder: '#94A3B8',
+        },
+        button: {
+            primary: {
+                background: '#3B82F6',
+                text: '#FFFFFF',
+                hover: '#2563EB',
+                active: '#1D4ED8',
+            },
+            secondary: {
+                background: 'transparent',
+                text: '#3B82F6',
+                border: '#3B82F6',
+                hover: 'rgba(59, 130, 246, 0.1)',
+                active: 'rgba(59, 130, 246, 0.2)',
+            },
+        },
+    },
+    branding: {
+        primaryColor: '#3B82F6',
+    },
+};
+// Purple theme
+const purpleTheme = {
+    mode: 'dark',
+    colors: {
+        background: {
+            primary: '#1a1a1a',
+            secondary: '#2a2a2a',
+            tertiary: '#3a3a3a',
+            accent: 'rgba(168, 85, 247, 0.1)',
+            glass: 'rgba(255, 255, 255, 0.05)',
+        },
+        status: {
+            connected: '#A855F7',
+            disconnected: '#EF4444',
+            warning: '#F59E0B',
+            pending: '#8B5CF6',
+            error: '#EF4444',
+            success: '#10B981',
+        },
+        text: {
+            primary: '#F8FAFC',
+            secondary: '#CBD5E1',
+            muted: '#94A3B8',
+            inverse: '#1a1a1a',
+        },
+        border: {
+            primary: 'rgba(168, 85, 247, 0.2)',
+            secondary: 'rgba(255, 255, 255, 0.1)',
+            hover: 'rgba(168, 85, 247, 0.4)',
+            focus: 'rgba(168, 85, 247, 0.6)',
+            accent: '#A855F7',
+        },
+        input: {
+            background: '#334155',
+            border: 'rgba(168, 85, 247, 0.2)',
+            borderFocus: '#A855F7',
+            text: '#F8FAFC',
+            placeholder: '#94A3B8',
+        },
+        button: {
+            primary: {
+                background: '#A855F7',
+                text: '#FFFFFF',
+                hover: '#9333EA',
+                active: '#7C3AED',
+            },
+            secondary: {
+                background: 'transparent',
+                text: '#A855F7',
+                border: '#A855F7',
+                hover: 'rgba(168, 85, 247, 0.1)',
+                active: 'rgba(168, 85, 247, 0.2)',
+            },
+        },
+    },
+    branding: {
+        primaryColor: '#A855F7',
+    },
+};
+// Green theme
+const greenTheme = {
+    mode: 'dark',
+    colors: {
+        background: {
+            primary: '#1a1a1a',
+            secondary: '#2a2a2a',
+            tertiary: '#3a3a3a',
+            accent: 'rgba(34, 197, 94, 0.1)',
+            glass: 'rgba(255, 255, 255, 0.05)',
+        },
+        status: {
+            connected: '#22C55E',
+            disconnected: '#EF4444',
+            warning: '#F59E0B',
+            pending: '#8B5CF6',
+            error: '#EF4444',
+            success: '#22C55E',
+        },
+        text: {
+            primary: '#F8FAFC',
+            secondary: '#CBD5E1',
+            muted: '#94A3B8',
+            inverse: '#1a1a1a',
+        },
+        border: {
+            primary: 'rgba(34, 197, 94, 0.2)',
+            secondary: 'rgba(255, 255, 255, 0.1)',
+            hover: 'rgba(34, 197, 94, 0.4)',
+            focus: 'rgba(34, 197, 94, 0.6)',
+            accent: '#22C55E',
+        },
+        input: {
+            background: '#334155',
+            border: 'rgba(34, 197, 94, 0.2)',
+            borderFocus: '#22C55E',
+            text: '#F8FAFC',
+            placeholder: '#94A3B8',
+        },
+        button: {
+            primary: {
+                background: '#22C55E',
+                text: '#FFFFFF',
+                hover: '#16A34A',
+                active: '#15803D',
+            },
+            secondary: {
+                background: 'transparent',
+                text: '#22C55E',
+                border: '#22C55E',
+                hover: 'rgba(34, 197, 94, 0.1)',
+                active: 'rgba(34, 197, 94, 0.2)',
+            },
+        },
+    },
+    branding: {
+        primaryColor: '#22C55E',
+    },
+};
+// Orange theme
+const orangeTheme = {
+    mode: 'dark',
+    colors: {
+        background: {
+            primary: '#1a1a1a',
+            secondary: '#2a2a2a',
+            tertiary: '#3a3a3a',
+            accent: 'rgba(249, 115, 22, 0.1)',
+            glass: 'rgba(255, 255, 255, 0.05)',
+        },
+        status: {
+            connected: '#F97316',
+            disconnected: '#EF4444',
+            warning: '#F59E0B',
+            pending: '#8B5CF6',
+            error: '#EF4444',
+            success: '#10B981',
+        },
+        text: {
+            primary: '#F8FAFC',
+            secondary: '#CBD5E1',
+            muted: '#94A3B8',
+            inverse: '#1a1a1a',
+        },
+        border: {
+            primary: 'rgba(249, 115, 22, 0.2)',
+            secondary: 'rgba(255, 255, 255, 0.1)',
+            hover: 'rgba(249, 115, 22, 0.4)',
+            focus: 'rgba(249, 115, 22, 0.6)',
+            accent: '#F97316',
+        },
+        input: {
+            background: '#334155',
+            border: 'rgba(249, 115, 22, 0.2)',
+            borderFocus: '#F97316',
+            text: '#F8FAFC',
+            placeholder: '#94A3B8',
+        },
+        button: {
+            primary: {
+                background: '#F97316',
+                text: '#FFFFFF',
+                hover: '#EA580C',
+                active: '#DC2626',
+            },
+            secondary: {
+                background: 'transparent',
+                text: '#F97316',
+                border: '#F97316',
+                hover: 'rgba(249, 115, 22, 0.1)',
+                active: 'rgba(249, 115, 22, 0.2)',
+            },
+        },
+    },
+    branding: {
+        primaryColor: '#F97316',
+    },
+};
+// Theme preset mapping
+const portalThemePresets = {
+    dark: darkTheme,
+    light: lightTheme,
+    corporateBlue: corporateBlueTheme,
+    purple: purpleTheme,
+    green: greenTheme,
+    orange: orangeTheme,
+};
+
+/**
+ * Generate a portal URL with theme parameters
+ * @param baseUrl The base portal URL
+ * @param theme The theme configuration
+ * @returns The portal URL with theme parameters
+ */
+function generatePortalThemeURL(baseUrl, theme) {
+    if (!theme) {
+        return baseUrl;
+    }
+    try {
+        const url = new URL(baseUrl);
+        if (theme.preset) {
+            // Use preset theme
+            url.searchParams.set('theme', theme.preset);
+        }
+        else if (theme.custom) {
+            // Use custom theme
+            const encodedTheme = btoa(JSON.stringify(theme.custom));
+            url.searchParams.set('theme', 'custom');
+            url.searchParams.set('themeObject', encodedTheme);
+        }
+        return url.toString();
+    }
+    catch (error) {
+        console.error('Failed to generate theme URL:', error);
+        return baseUrl;
+    }
+}
+/**
+ * Generate a portal URL with theme parameters, appending to existing query params
+ * @param baseUrl The base portal URL (may already have query parameters)
+ * @param theme The theme configuration
+ * @returns The portal URL with theme parameters appended
+ */
+function appendThemeToURL(baseUrl, theme) {
+    if (!theme) {
+        return baseUrl;
+    }
+    try {
+        const url = new URL(baseUrl);
+        if (theme.preset) {
+            // Use preset theme
+            url.searchParams.set('theme', theme.preset);
+        }
+        else if (theme.custom) {
+            // Use custom theme
+            const encodedTheme = btoa(JSON.stringify(theme.custom));
+            url.searchParams.set('theme', 'custom');
+            url.searchParams.set('themeObject', encodedTheme);
+        }
+        return url.toString();
+    }
+    catch (error) {
+        console.error('Failed to append theme to URL:', error);
+        return baseUrl;
+    }
+}
+/**
+ * Get a theme configuration by preset name
+ * @param preset The preset theme name
+ * @returns The theme configuration or undefined if not found
+ */
+function getThemePreset(preset) {
+    return portalThemePresets[preset];
+}
+/**
+ * Validate a custom theme configuration
+ * @param theme The theme configuration to validate
+ * @returns True if valid, false otherwise
+ */
+function validateCustomTheme(theme) {
+    try {
+        // Check required properties
+        if (!theme.mode || !['dark', 'light', 'auto'].includes(theme.mode)) {
+            return false;
+        }
+        if (!theme.colors) {
+            return false;
+        }
+        // Check required color sections
+        const requiredSections = ['background', 'status', 'text', 'border', 'input', 'button'];
+        for (const section of requiredSections) {
+            if (!theme.colors[section]) {
+                return false;
+            }
+        }
+        return true;
+    }
+    catch (error) {
+        console.error('Theme validation error:', error);
+        return false;
+    }
+}
+/**
+ * Create a custom theme from a preset with modifications
+ * @param preset The base preset theme
+ * @param modifications Partial theme modifications
+ * @returns The modified theme configuration
+ */
+function createCustomThemeFromPreset(preset, modifications) {
+    const baseTheme = getThemePreset(preset);
+    if (!baseTheme) {
+        console.error(`Preset theme '${preset}' not found`);
+        return null;
+    }
+    return {
+        ...baseTheme,
+        ...modifications,
+    };
+}
+
+class FinaticConnect extends EventEmitter {
+    constructor(options, deviceInfo) {
+        super();
+        this.userToken = null;
+        this.sessionId = null;
+        this.BROKER_LIST_CACHE_KEY = 'finatic_broker_list_cache';
+        this.BROKER_LIST_CACHE_VERSION = '1.0';
+        this.BROKER_LIST_CACHE_DURATION = 1000 * 60 * 60 * 24; // 24 hours in milliseconds
+        this.currentSessionState = null;
+        this.options = options;
+        this.baseUrl = options.baseUrl || 'http://localhost:8000';
+        this.apiClient = MockFactory.createApiClient(this.baseUrl, deviceInfo);
+        this.portalUI = new PortalUI(this.baseUrl);
+        this.deviceInfo = deviceInfo;
+        // Extract company ID from token
+        try {
+            // Validate token exists
+            if (!options.token) {
+                throw new Error('Token is required but not provided');
+            }
+            // Check if token is in JWT format (contains dots)
+            if (options.token.includes('.')) {
+                const tokenParts = options.token.split('.');
+                if (tokenParts.length === 3) {
+                    const payload = JSON.parse(atob(tokenParts[1]));
+                    this.companyId = payload.company_id;
+                }
+                else {
+                    throw new Error('Invalid JWT token format');
+                }
+            }
+            else {
+                // Handle UUID format token
+                // For UUID tokens, we'll get the company_id from the session start response
+                this.companyId = ''; // Will be set after session start
+            }
+        }
+        catch (error) {
+            if (error instanceof Error) {
+                throw new Error('Failed to parse token: ' + error.message);
+            }
+            else {
+                throw new Error('Failed to parse token: Unknown error');
+            }
+        }
+        // Set up event listeners for callbacks
+        if (this.options.onSuccess) {
+            this.on('success', this.options.onSuccess);
+        }
+        if (this.options.onError) {
+            this.on('error', this.options.onError);
+        }
+        if (this.options.onClose) {
+            this.on('close', this.options.onClose);
+        }
+        // Register automatic session cleanup
+        this.registerSessionCleanup();
+    }
+    handleTokens(tokens) {
+        if (!tokens.access_token || !tokens.refresh_token) {
+            return;
+        }
+        // Keep existing user_id or use empty string as fallback
+        const userId = this.userToken?.user_id || '';
+        this.userToken = {
+            accessToken: tokens.access_token,
+            refreshToken: tokens.refresh_token,
+            expiresIn: 3600, // Default to 1 hour if not provided
+            user_id: userId,
+            tokenType: 'Bearer',
+            scope: 'api:access',
+        };
+        // Store tokens in ApiClient for automatic refresh
+        const expiresAt = new Date(Date.now() + 3600 * 1000).toISOString(); // 1 hour from now
+        this.apiClient.setTokens(tokens.access_token, tokens.refresh_token, expiresAt, userId);
+    }
+    /**
+     * Check if the user is authenticated
+     * @returns True if the user has a valid access token
+     */
+    isAuthenticated() {
+        return this.isAuthed();
+    }
+    /**
+     * Check if the user is fully authenticated (has userId, access token, and refresh token)
+     * @returns True if the user is fully authenticated and ready for API calls
+     */
+    isAuthed() {
+        return !!(this.userToken?.accessToken &&
+            this.userToken?.refreshToken &&
+            this.userToken?.user_id);
+    }
+    /**
+     * Get user's orders with pagination and optional filtering
+     * @param params - Query parameters including page, perPage, and filters
+     * @returns Promise with paginated result that supports navigation
+     */
+    async getOrders(params) {
+        if (!this.isAuthenticated()) {
+            throw new AuthenticationError('User is not authenticated');
+        }
+        const page = params?.page || 1;
+        const perPage = params?.perPage || 100;
+        const filter = params?.filter;
+        return this.getOrdersPage(page, perPage, filter);
+    }
+    /**
+     * Get user's positions with pagination and optional filtering
+     * @param params - Query parameters including page, perPage, and filters
+     * @returns Promise with paginated result that supports navigation
+     */
+    async getPositions(params) {
+        if (!this.isAuthenticated()) {
+            throw new AuthenticationError('User is not authenticated');
+        }
+        const page = params?.page || 1;
+        const perPage = params?.perPage || 100;
+        const filter = params?.filter;
+        return this.getPositionsPage(page, perPage, filter);
+    }
+    /**
+     * Get user's accounts with pagination and optional filtering
+     * @param params - Query parameters including page, perPage, and filters
+     * @returns Promise with paginated result that supports navigation
+     */
+    async getAccounts(params) {
+        if (!this.isAuthenticated()) {
+            throw new AuthenticationError('User is not authenticated');
+        }
+        const page = params?.page || 1;
+        const perPage = params?.perPage || 100;
+        const filter = params?.filter;
+        return this.getAccountsPage(page, perPage, filter);
+    }
+    /**
+     * Revoke the current user's access
+     */
+    async revokeToken() {
+        if (!this.userToken) {
+            return;
+        }
+        try {
+            await this.apiClient.revokeToken(this.userToken.accessToken);
+            this.userToken = null;
+        }
+        catch (error) {
+            this.emit('error', error);
+            throw error;
+        }
+    }
+    /**
+     * Initialize the Finatic Connect SDK
+     * @param token - The portal token from your backend
+     * @param userId - Optional: The user ID if you have it from a previous session
+     * @param options - Optional configuration including baseUrl
+     * @returns FinaticConnect instance
+     */
+    static async init(token, userId, options) {
+        if (!FinaticConnect.instance) {
+            const connectOptions = {
+                token,
+                baseUrl: options?.baseUrl || 'http://localhost:8000',
+                onSuccess: undefined,
+                onError: undefined,
+                onClose: undefined,
+            };
+            // Generate device info
+            const deviceInfo = {
+                ip_address: '', // Will be set by the server
+                user_agent: navigator.userAgent,
+                fingerprint: btoa([
+                    navigator.userAgent,
+                    navigator.language,
+                    new Date().getTimezoneOffset(),
+                    screen.width,
+                    screen.height,
+                    navigator.hardwareConcurrency,
+                    // @ts-expect-error - deviceMemory is not in the Navigator type but exists in modern browsers
+                    navigator.deviceMemory || 'unknown',
+                ].join('|')),
+            };
+            FinaticConnect.instance = new FinaticConnect(connectOptions, deviceInfo);
+            // Start session and get session data
+            const normalizedUserId = userId || undefined; // Convert null to undefined
+            const startResponse = await FinaticConnect.instance.apiClient.startSession(token, normalizedUserId);
+            FinaticConnect.instance.sessionId = startResponse.data.session_id;
+            FinaticConnect.instance.companyId = startResponse.data.company_id || '';
+            // Set session context in API client
+            if (FinaticConnect.instance.apiClient &&
+                typeof FinaticConnect.instance.apiClient.setSessionContext === 'function') {
+                FinaticConnect.instance.apiClient.setSessionContext(FinaticConnect.instance.sessionId, FinaticConnect.instance.companyId, startResponse.data.csrf_token // If available in response
+                );
+            }
+            // If userId is provided, authenticate directly
+            if (normalizedUserId) {
+                try {
+                    const authResponse = await FinaticConnect.instance.apiClient.authenticateDirectly(startResponse.data.session_id, normalizedUserId);
+                    // Convert API response to UserToken format
+                    const userToken = {
+                        accessToken: authResponse.data.access_token,
+                        refreshToken: authResponse.data.refresh_token,
+                        expiresIn: 3600, // Default to 1 hour
+                        user_id: normalizedUserId,
+                        tokenType: 'Bearer',
+                        scope: 'api:access',
+                    };
+                    // Set the tokens in both FinaticConnect and ApiClient
+                    FinaticConnect.instance.userToken = userToken;
+                    // Set tokens in ApiClient for automatic token management
+                    const expiresAt = new Date(Date.now() + 3600 * 1000).toISOString(); // 1 hour from now
+                    FinaticConnect.instance.apiClient.setTokens(authResponse.data.access_token, authResponse.data.refresh_token, expiresAt, normalizedUserId);
+                    // Emit success event
+                    FinaticConnect.instance.emit('success', normalizedUserId);
+                }
+                catch (error) {
+                    FinaticConnect.instance.emit('error', error);
+                    throw error;
+                }
+            }
+        }
+        return FinaticConnect.instance;
+    }
+    /**
+     * Initialize the SDK with a user ID
+     * @param userId - The user ID from a previous session
+     */
+    async setUserId(userId) {
+        await this.initializeWithUser(userId);
+    }
+    async initializeWithUser(userId) {
+        try {
+            this.userToken = await this.apiClient.getUserToken(userId);
+            // Set tokens in ApiClient for automatic token management
+            if (this.userToken) {
+                const expiresAt = new Date(Date.now() + 3600 * 1000).toISOString(); // 1 hour from now
+                this.apiClient.setTokens(this.userToken.accessToken, this.userToken.refreshToken, expiresAt, userId);
+            }
+            this.emit('success', userId);
+        }
+        catch (error) {
+            this.emit('error', error);
+        }
+    }
+    /**
+     * Handle company access error by opening the portal
+     * @param error The company access error
+     * @param options Optional configuration for the portal
+     */
+    async handleCompanyAccessError(error, options) {
+        // Emit a specific event for company access errors
+        this.emit('companyAccessError', error);
+        // Open the portal to allow the user to connect a broker
+        await this.openPortal(options);
+    }
+    /**
+     * Open the portal for user authentication
+     * @param options Optional configuration for the portal
+     */
+    async openPortal(options) {
+        try {
+            if (!this.sessionId) {
+                throw new SessionError('Session not initialized');
+            }
+            // Ensure session is active
+            const sessionState = this.apiClient.getCurrentSessionState();
+            if (sessionState !== SessionState.ACTIVE) {
+                // If not active, try to start a new session
+                const startResponse = await this.apiClient.startSession(this.options.token);
+                this.sessionId = startResponse.data.session_id;
+                this.companyId = startResponse.data.company_id || '';
+                // Set session context in API client
+                if (this.apiClient && typeof this.apiClient.setSessionContext === 'function') {
+                    this.apiClient.setSessionContext(this.sessionId, this.companyId, startResponse.data.csrf_token // If available in response
+                    );
+                }
+                // Wait for session to become active
+                const maxAttempts = 5;
+                let attempts = 0;
+                while (attempts < maxAttempts) {
+                    const sessionResponse = await this.apiClient.validatePortalSession(this.sessionId, '');
+                    if (sessionResponse.status === 'active') {
+                        break;
+                    }
+                    await new Promise(resolve => setTimeout(resolve, 1000)); // Wait 1 second between attempts
+                    attempts++;
+                }
+                if (attempts === maxAttempts) {
+                    throw new SessionError('Session failed to become active');
+                }
+            }
+            // Get portal URL
+            const portalResponse = await this.apiClient.getPortalUrl(this.sessionId);
+            if (!portalResponse.data.portal_url) {
+                throw new Error('Failed to get portal URL');
+            }
+            // Apply theme to portal URL if provided
+            const themedPortalUrl = appendThemeToURL(portalResponse.data.portal_url, options?.theme);
+            // Create portal UI if not exists
+            if (!this.portalUI) {
+                this.portalUI = new PortalUI(this.baseUrl);
+            }
+            // Show portal
+            this.portalUI.show(themedPortalUrl, this.sessionId || '', {
+                onSuccess: async (userId) => {
+                    try {
+                        if (!this.sessionId) {
+                            throw new SessionError('Session not initialized');
+                        }
+                        // Get tokens from portal UI
+                        const userToken = this.portalUI.getTokens();
+                        if (!userToken) {
+                            throw new Error('No tokens received from portal');
+                        }
+                        // Set the tokens internally
+                        this.userToken = userToken;
+                        // Set tokens in ApiClient for automatic token management
+                        const expiresAt = new Date(Date.now() + 3600 * 1000).toISOString(); // 1 hour from now
+                        this.apiClient.setTokens(userToken.accessToken, userToken.refreshToken, expiresAt, userId);
+                        // Emit portal success event
+                        this.emit('portal:success', userId);
+                        // Emit legacy success event
+                        this.emit('success', userId);
+                        options?.onSuccess?.(userId);
+                    }
+                    catch (error) {
+                        if (error instanceof CompanyAccessError) {
+                            // Handle company access error by opening the portal
+                            await this.handleCompanyAccessError(error, options);
+                        }
+                        else {
+                            this.emit('error', error);
+                            options?.onError?.(error);
+                        }
+                    }
+                },
+                onError: (error) => {
+                    // Emit portal error event
+                    this.emit('portal:error', error);
+                    // Emit legacy error event
+                    this.emit('error', error);
+                    options?.onError?.(error);
+                },
+                onClose: () => {
+                    // Emit portal close event
+                    this.emit('portal:close');
+                    // Emit legacy close event
+                    this.emit('close');
+                    options?.onClose?.();
+                },
+                onEvent: (type, data) => {
+                    console.log('[FinaticConnect] Portal event received:', type, data);
+                    // Emit generic event
+                    this.emit('event', type, data);
+                    // Call the event callback
+                    options?.onEvent?.(type, data);
+                },
+            });
+        }
+        catch (error) {
+            if (error instanceof CompanyAccessError) {
+                // Handle company access error by opening the portal
+                await this.handleCompanyAccessError(error, options);
+            }
+            else {
+                this.emit('error', error);
+                options?.onError?.(error);
+            }
+        }
+    }
+    /**
+     * Close the Finatic Connect Portal
+     */
+    closePortal() {
+        this.portalUI.hide();
+        this.emit('close');
+    }
+    /**
+     * Initialize a new session
+     * @param oneTimeToken - The one-time token from initSession
+     */
+    async startSession(oneTimeToken) {
+        try {
+            const response = await this.apiClient.startSession(oneTimeToken);
+            this.sessionId = response.data.session_id;
+            this.currentSessionState = response.data.state;
+            // Set session context in API client
+            if (this.apiClient && typeof this.apiClient.setSessionContext === 'function') {
+                this.apiClient.setSessionContext(this.sessionId, this.companyId, response.data.csrf_token // If available in response
+                );
+            }
+            // For non-direct auth, we need to wait for the session to be ACTIVE
+            if (response.data.state === SessionState.PENDING) {
+                // Wait for session to become active
+                const maxAttempts = 5;
+                let attempts = 0;
+                while (attempts < maxAttempts) {
+                    const sessionResponse = await this.apiClient.validatePortalSession(this.sessionId, '');
+                    if (sessionResponse.status === 'active') {
+                        this.currentSessionState = SessionState.ACTIVE;
+                        break;
+                    }
+                    await new Promise(resolve => setTimeout(resolve, 1000)); // Wait 1 second between attempts
+                    attempts++;
+                }
+                if (attempts === maxAttempts) {
+                    throw new SessionError('Session failed to become active');
+                }
+            }
+        }
+        catch (error) {
+            if (error instanceof SessionError) {
+                throw new AuthenticationError('Failed to start session', error.details);
+            }
+            throw error;
+        }
+    }
+    /**
+     * Place a new order using the broker order API
+     * @param order - Order details with broker context
+     */
+    async placeOrder(order) {
+        if (!this.userToken) {
+            throw new Error('Not initialized with user');
+        }
+        try {
+            // Convert order format to match broker API
+            const brokerOrder = {
+                symbol: order.symbol,
+                orderQty: order.quantity,
+                action: order.side === 'buy' ? 'Buy' : 'Sell',
+                orderType: order.orderType === 'market'
+                    ? 'Market'
+                    : order.orderType === 'limit'
+                        ? 'Limit'
+                        : order.orderType === 'stop'
+                            ? 'Stop'
+                            : 'TrailingStop',
+                assetType: order.assetType || 'Stock',
+                timeInForce: order.timeInForce,
+                price: order.price,
+                stopPrice: order.stopPrice,
+                broker: order.broker,
+                accountNumber: order.accountNumber,
+            };
+            return await this.apiClient.placeBrokerOrder(this.userToken.accessToken, brokerOrder);
+        }
+        catch (error) {
+            this.emit('error', error);
+            throw error;
+        }
+    }
+    /**
+     * Cancel a broker order
+     * @param orderId - The order ID to cancel
+     * @param broker - Optional broker override
+     */
+    async cancelOrder(orderId, broker) {
+        if (!this.userToken) {
+            throw new Error('Not initialized with user');
+        }
+        try {
+            return await this.apiClient.cancelBrokerOrder(orderId, broker);
+        }
+        catch (error) {
+            this.emit('error', error);
+            throw error;
+        }
+    }
+    /**
+     * Modify a broker order
+     * @param orderId - The order ID to modify
+     * @param modifications - The modifications to apply
+     * @param broker - Optional broker override
+     */
+    async modifyOrder(orderId, modifications, broker) {
+        if (!this.userToken) {
+            throw new Error('Not initialized with user');
+        }
+        try {
+            // Convert modifications to broker format
+            const brokerModifications = {};
+            if (modifications.symbol)
+                brokerModifications.symbol = modifications.symbol;
+            if (modifications.quantity)
+                brokerModifications.orderQty = modifications.quantity;
+            if (modifications.price)
+                brokerModifications.price = modifications.price;
+            if (modifications.stopPrice)
+                brokerModifications.stopPrice = modifications.stopPrice;
+            if (modifications.timeInForce)
+                brokerModifications.timeInForce = modifications.timeInForce;
+            return await this.apiClient.modifyBrokerOrder(orderId, brokerModifications, broker);
+        }
+        catch (error) {
+            this.emit('error', error);
+            throw error;
+        }
+    }
+    /**
+     * Set the broker context for trading
+     * @param broker - The broker to use for trading
+     */
+    setBroker(broker) {
+        this.apiClient.setBroker(broker);
+    }
+    /**
+     * Set the account context for trading
+     * @param accountNumber - The account number to use for trading
+     * @param accountId - Optional account ID
+     */
+    setAccount(accountNumber, accountId) {
+        this.apiClient.setAccount(accountNumber, accountId);
+    }
+    /**
+     * Get the current trading context
+     */
+    getTradingContext() {
+        return this.apiClient.getTradingContext();
+    }
+    /**
+     * Clear the trading context
+     */
+    clearTradingContext() {
+        this.apiClient.clearTradingContext();
+    }
+    /**
+     * Place a stock market order (convenience method)
+     */
+    async placeStockMarketOrder(symbol, quantity, side, broker, accountNumber) {
+        if (!this.userToken) {
+            throw new Error('Not initialized with user');
+        }
+        try {
+            return await this.apiClient.placeStockMarketOrder(this.userToken.accessToken, symbol, quantity, side === 'buy' ? 'Buy' : 'Sell', broker, accountNumber);
+        }
+        catch (error) {
+            this.emit('error', error);
+            throw error;
+        }
+    }
+    /**
+     * Place a stock limit order (convenience method)
+     */
+    async placeStockLimitOrder(symbol, quantity, side, price, timeInForce = 'gtc', broker, accountNumber) {
+        if (!this.userToken) {
+            throw new Error('Not initialized with user');
+        }
+        try {
+            return await this.apiClient.placeStockLimitOrder(this.userToken.accessToken, symbol, quantity, side === 'buy' ? 'Buy' : 'Sell', price, timeInForce, broker, accountNumber);
+        }
+        catch (error) {
+            this.emit('error', error);
+            throw error;
+        }
+    }
+    /**
+     * Get the current user ID
+     * @returns The current user ID or undefined if not authenticated
+     * @throws AuthenticationError if user is not authenticated
+     */
+    getUserId() {
+        if (!this.isAuthenticated()) {
+            return null;
+        }
+        if (!this.userToken?.user_id) {
+            return null;
+        }
+        return this.userToken.user_id;
+    }
+    /**
+     * Get list of supported brokers
+     * @returns Promise with array of broker information
+     */
+    async getBrokerList() {
+        if (!this.isAuthenticated()) {
+            throw new AuthenticationError('Not authenticated');
+        }
+        const response = await this.apiClient.getBrokerListAuto();
+        const baseUrl = this.baseUrl.replace('/api/v1', ''); // Remove /api/v1 to get the base URL
+        // Transform the broker list to include full logo URLs
+        return response.response_data.map((broker) => ({
+            ...broker,
+            logo_path: broker.logo_path ? `${baseUrl}${broker.logo_path}` : '',
+        }));
+    }
+    /**
+     * Get broker connections
+     * @returns Promise with array of broker connections
+     * @throws AuthenticationError if user is not authenticated
+     */
+    async getBrokerConnections() {
+        if (!this.isAuthenticated()) {
+            throw new AuthenticationError('User is not authenticated. Please connect a broker first.');
+        }
+        if (!this.userToken?.user_id) {
+            throw new AuthenticationError('No user ID available. Please connect a broker first.');
+        }
+        const response = await this.apiClient.getBrokerConnectionsAuto();
+        if (response.status_code !== 200) {
+            throw new Error(response.message || 'Failed to retrieve broker connections');
+        }
+        return response.response_data;
+    }
+    // Abstract convenience methods
+    /**
+     * Get only open positions
+     * @returns Promise with array of open positions
+     */
+    async getOpenPositions() {
+        return this.getAllPositions({ position_status: 'open' });
+    }
+    /**
+     * Get only filled orders
+     * @returns Promise with array of filled orders
+     */
+    async getFilledOrders() {
+        return this.getAllOrders({ status: 'filled' });
+    }
+    /**
+     * Get only pending orders
+     * @returns Promise with array of pending orders
+     */
+    async getPendingOrders() {
+        return this.getAllOrders({ status: 'pending' });
+    }
+    /**
+     * Get only active accounts
+     * @returns Promise with array of active accounts
+     */
+    async getActiveAccounts() {
+        return this.getAllAccounts({ status: 'active' });
+    }
+    /**
+     * Get orders for a specific symbol
+     * @param symbol - The symbol to filter by
+     * @returns Promise with array of orders for the symbol
+     */
+    async getOrdersBySymbol(symbol) {
+        return this.getAllOrders({ symbol });
+    }
+    /**
+     * Get positions for a specific symbol
+     * @param symbol - The symbol to filter by
+     * @returns Promise with array of positions for the symbol
+     */
+    async getPositionsBySymbol(symbol) {
+        return this.getAllPositions({ symbol });
+    }
+    /**
+     * Get orders for a specific broker
+     * @param brokerId - The broker ID to filter by
+     * @returns Promise with array of orders for the broker
+     */
+    async getOrdersByBroker(brokerId) {
+        return this.getAllOrders({ broker_id: brokerId });
+    }
+    /**
+     * Get positions for a specific broker
+     * @param brokerId - The broker ID to filter by
+     * @returns Promise with array of positions for the broker
+     */
+    async getPositionsByBroker(brokerId) {
+        return this.getAllPositions({ broker_id: brokerId });
+    }
+    // Pagination methods
+    /**
+     * Get a specific page of orders with pagination metadata
+     * @param page - Page number (default: 1)
+     * @param perPage - Items per page (default: 100)
+     * @param filter - Optional filter parameters
+     * @returns Promise with paginated orders result
+     */
+    async getOrdersPage(page = 1, perPage = 100, filter) {
+        if (!this.isAuthenticated()) {
+            throw new AuthenticationError('User is not authenticated');
+        }
+        return this.apiClient.getBrokerOrdersPage(page, perPage, filter);
+    }
+    /**
+     * Get a specific page of positions with pagination metadata
+     * @param page - Page number (default: 1)
+     * @param perPage - Items per page (default: 100)
+     * @param filter - Optional filter parameters
+     * @returns Promise with paginated positions result
+     */
+    async getPositionsPage(page = 1, perPage = 100, filter) {
+        if (!this.isAuthenticated()) {
+            throw new AuthenticationError('User is not authenticated');
+        }
+        return this.apiClient.getBrokerPositionsPage(page, perPage, filter);
+    }
+    /**
+     * Get a specific page of accounts with pagination metadata
+     * @param page - Page number (default: 1)
+     * @param perPage - Items per page (default: 100)
+     * @param filter - Optional filter parameters
+     * @returns Promise with paginated accounts result
+     */
+    async getAccountsPage(page = 1, perPage = 100, filter) {
+        if (!this.isAuthenticated()) {
+            throw new AuthenticationError('User is not authenticated');
+        }
+        return this.apiClient.getBrokerAccountsPage(page, perPage, filter);
+    }
+    /**
+     * Get the next page of orders
+     * @param previousResult - The previous paginated result
+     * @returns Promise with next page of orders or null if no more pages
+     */
+    async getNextOrdersPage(previousResult) {
+        if (!this.isAuthenticated()) {
+            throw new AuthenticationError('User is not authenticated');
+        }
+        return this.apiClient.getNextPage(previousResult, (offset, limit) => {
+            const page = Math.floor(offset / limit) + 1;
+            return this.apiClient.getBrokerOrdersPage(page, limit);
+        });
+    }
+    /**
+     * Get the next page of positions
+     * @param previousResult - The previous paginated result
+     * @returns Promise with next page of positions or null if no more pages
+     */
+    async getNextPositionsPage(previousResult) {
+        if (!this.isAuthenticated()) {
+            throw new AuthenticationError('User is not authenticated');
+        }
+        return this.apiClient.getNextPage(previousResult, (offset, limit) => {
+            const page = Math.floor(offset / limit) + 1;
+            return this.apiClient.getBrokerPositionsPage(page, limit);
+        });
+    }
+    /**
+     * Get the next page of accounts
+     * @param previousResult - The previous paginated result
+     * @returns Promise with next page of accounts or null if no more pages
+     */
+    async getNextAccountsPage(previousResult) {
+        if (!this.isAuthenticated()) {
+            throw new AuthenticationError('User is not authenticated');
+        }
+        return this.apiClient.getNextPage(previousResult, (offset, limit) => {
+            const page = Math.floor(offset / limit) + 1;
+            return this.apiClient.getBrokerAccountsPage(page, limit);
+        });
+    }
+    /**
+     * Get all orders across all pages (convenience method)
+     * @param filter - Optional filter parameters
+     * @returns Promise with all orders
+     */
+    async getAllOrders(filter) {
+        if (!this.isAuthenticated()) {
+            throw new AuthenticationError('User is not authenticated');
+        }
+        const allData = [];
+        let currentResult = await this.getOrdersPage(1, 100, filter);
+        while (currentResult) {
+            allData.push(...currentResult.data);
+            if (!currentResult.hasNext)
+                break;
+            const nextResult = await this.getNextOrdersPage(currentResult);
+            if (!nextResult)
+                break;
+            currentResult = nextResult;
+        }
+        return allData;
+    }
+    /**
+     * Get all positions across all pages (convenience method)
+     * @param filter - Optional filter parameters
+     * @returns Promise with all positions
+     */
+    async getAllPositions(filter) {
+        if (!this.isAuthenticated()) {
+            throw new AuthenticationError('User is not authenticated');
+        }
+        const allData = [];
+        let currentResult = await this.getPositionsPage(1, 100, filter);
+        while (currentResult) {
+            allData.push(...currentResult.data);
+            if (!currentResult.hasNext)
+                break;
+            const nextResult = await this.getNextPositionsPage(currentResult);
+            if (!nextResult)
+                break;
+            currentResult = nextResult;
+        }
+        return allData;
+    }
+    /**
+     * Get all accounts across all pages (convenience method)
+     * @param filter - Optional filter parameters
+     * @returns Promise with all accounts
+     */
+    async getAllAccounts(filter) {
+        if (!this.isAuthenticated()) {
+            throw new AuthenticationError('User is not authenticated');
+        }
+        const allData = [];
+        let currentResult = await this.getAccountsPage(1, 100, filter);
+        while (currentResult) {
+            allData.push(...currentResult.data);
+            if (!currentResult.hasNext)
+                break;
+            const nextResult = await this.getNextAccountsPage(currentResult);
+            if (!nextResult)
+                break;
+            currentResult = nextResult;
+        }
+        return allData;
+    }
+    /**
+     * Register automatic session cleanup on page unload/visibility change
+     */
+    registerSessionCleanup() {
+        // Cleanup on page unload (refresh, close tab, navigate away)
+        window.addEventListener('beforeunload', this.handleSessionCleanup.bind(this));
+        // Cleanup on page visibility change (mobile browsers, app switching)
+        document.addEventListener('visibilitychange', this.handleVisibilityChange.bind(this));
+    }
+    /**
+     * Handle session cleanup when page is unloading
+     */
+    async handleSessionCleanup() {
+        if (this.sessionId) {
+            await this.completeSession(this.sessionId);
+        }
+    }
+    /**
+     * Handle visibility change (mobile browsers)
+     */
+    async handleVisibilityChange() {
+        if (document.visibilityState === 'hidden' && this.sessionId) {
+            await this.completeSession(this.sessionId);
+        }
+    }
+    /**
+     * Complete the session by calling the API
+     * @param sessionId - The session ID to complete
+     */
+    async completeSession(sessionId) {
+        try {
+            // Check if we're in mock mode (check if apiClient is a mock client)
+            const isMockMode = this.apiClient &&
+                typeof this.apiClient.isMockClient === 'function' &&
+                this.apiClient.isMockClient();
+            if (isMockMode) {
+                // Mock the completion response
+                console.log('[FinaticConnect] Mock session completion for session:', sessionId);
+                return;
+            }
+            // Real API call
+            const response = await fetch(`${this.baseUrl}/portal/${sessionId}/complete`, {
+                method: 'POST',
+                headers: {
+                    Authorization: `Bearer ${this.userToken?.accessToken || ''}`,
+                    'Content-Type': 'application/json',
+                },
+            });
+            if (response.ok) {
+                console.log('[FinaticConnect] Session completed successfully');
+            }
+            else {
+                console.warn('[FinaticConnect] Failed to complete session:', response.status);
+            }
+        }
+        catch (error) {
+            // Silent failure - don't throw errors during cleanup
+            console.warn('[FinaticConnect] Session cleanup failed:', error);
+        }
+    }
+}
+FinaticConnect.instance = null;
+
+class CoreTradingService {
+    constructor(apiClient) {
+        this.apiClient = apiClient;
+    }
+    async getAccounts(filter) {
+        return this.getAllAccounts(filter);
+    }
+    async getOrders(filter) {
+        return this.getAllOrders(filter);
+    }
+    async getPositions(filter) {
+        return this.getAllPositions(filter);
+    }
+    async placeOrder(order) {
+        const response = await this.apiClient.placeOrder(order);
+        return response.data.orderId;
+    }
+    async cancelOrder(orderId) {
+        const response = await this.apiClient.cancelOrder(orderId);
+        return response.data.success;
+    }
+    async placeOptionsOrder(order) {
+        const response = await this.apiClient.placeOptionsOrder(order);
+        return response.data.orderId;
+    }
+    // Pagination methods
+    async getAccountsPage(page = 1, perPage = 100, filter) {
+        return this.apiClient.getBrokerAccountsPage(page, perPage, filter);
+    }
+    async getOrdersPage(page = 1, perPage = 100, filter) {
+        return this.apiClient.getBrokerOrdersPage(page, perPage, filter);
+    }
+    async getPositionsPage(page = 1, perPage = 100, filter) {
+        return this.apiClient.getBrokerPositionsPage(page, perPage, filter);
+    }
+    // Navigation methods
+    async getNextAccountsPage(previousResult) {
+        return this.apiClient.getNextPage(previousResult, (offset, limit) => this.apiClient.getBrokerAccountsPage(1, limit, { offset }));
+    }
+    async getNextOrdersPage(previousResult) {
+        return this.apiClient.getNextPage(previousResult, (offset, limit) => this.apiClient.getBrokerOrdersPage(1, limit, { offset }));
+    }
+    async getNextPositionsPage(previousResult) {
+        return this.apiClient.getNextPage(previousResult, (offset, limit) => this.apiClient.getBrokerPositionsPage(1, limit, { offset }));
+    }
+    // Get all pages convenience methods
+    async getAllAccounts(filter) {
+        const allData = [];
+        let currentResult = await this.getAccountsPage(1, 100, filter);
+        while (currentResult) {
+            allData.push(...currentResult.data);
+            if (!currentResult.hasNext)
+                break;
+            const nextResult = await this.getNextAccountsPage(currentResult);
+            if (!nextResult)
+                break;
+            currentResult = nextResult;
+        }
+        return allData;
+    }
+    async getAllOrders(filter) {
+        const allData = [];
+        let currentResult = await this.getOrdersPage(1, 100, filter);
+        while (currentResult) {
+            allData.push(...currentResult.data);
+            if (!currentResult.hasNext)
+                break;
+            const nextResult = await this.getNextOrdersPage(currentResult);
+            if (!nextResult)
+                break;
+            currentResult = nextResult;
+        }
+        return allData;
+    }
+    async getAllPositions(filter) {
+        const allData = [];
+        let currentResult = await this.getPositionsPage(1, 100, filter);
+        while (currentResult) {
+            allData.push(...currentResult.data);
+            if (!currentResult.hasNext)
+                break;
+            const nextResult = await this.getNextPositionsPage(currentResult);
+            if (!nextResult)
+                break;
+            currentResult = nextResult;
+        }
+        return allData;
+    }
+    // Abstract convenience methods
+    async getOpenPositions() {
+        return this.getPositions({ position_status: 'open' });
+    }
+    async getFilledOrders() {
+        return this.getOrders({ status: 'filled' });
+    }
+    async getPendingOrders() {
+        return this.getOrders({ status: 'pending' });
+    }
+    async getActiveAccounts() {
+        return this.getAccounts({ status: 'active' });
+    }
+    async getOrdersBySymbol(symbol) {
+        return this.getOrders({ symbol });
+    }
+    async getPositionsBySymbol(symbol) {
+        return this.getPositions({ symbol });
+    }
+    async getOrdersByBroker(brokerId) {
+        return this.getOrders({ broker_id: brokerId });
+    }
+    async getPositionsByBroker(brokerId) {
+        return this.getPositions({ broker_id: brokerId });
+    }
+}
+
+class CoreAnalyticsService {
+    constructor(apiClient) {
+        this.apiClient = apiClient;
+    }
+    async getPerformance() {
+        const response = await this.apiClient.getPerformance();
+        return response.data.performance;
+    }
+    async getDailyHistory() {
+        const response = await this.apiClient.getDailyHistory();
+        return response.data.history;
+    }
+    async getWeeklySnapshots() {
+        const response = await this.apiClient.getWeeklySnapshots();
+        return response.data.snapshots;
+    }
+    async getPortfolioDeltas() {
+        const response = await this.apiClient.getPortfolioDeltas();
+        return response.data.deltas;
+    }
+    async getUserLogs(userId) {
+        const response = await this.apiClient.getUserLogs(userId);
+        return response.data.logs;
+    }
+}
+
+class CorePortalService {
+    constructor(apiClient) {
+        this.apiClient = apiClient;
+        this.iframe = null;
+    }
+    async createPortal(config) {
+        // Create iframe
+        this.iframe = document.createElement('iframe');
+        this.iframe.style.display = 'none';
+        document.body.appendChild(this.iframe);
+        // Get portal content from API
+        const response = await this.apiClient.getPortalContent();
+        const content = response.data.content;
+        // Set iframe content
+        if (this.iframe.contentWindow) {
+            this.iframe.contentWindow.document.open();
+            this.iframe.contentWindow.document.write(content);
+            this.iframe.contentWindow.document.close();
+        }
+        // Position and style iframe
+        this.positionIframe(config);
+        this.styleIframe(config);
+        // Show iframe
+        this.iframe.style.display = 'block';
+    }
+    async closePortal() {
+        if (this.iframe) {
+            this.iframe.remove();
+            this.iframe = null;
+        }
+    }
+    async updateTheme(theme) {
+        if (this.iframe?.contentWindow) {
+            this.iframe.contentWindow.postMessage({ type: 'update_theme', theme }, '*');
+        }
+    }
+    async getBrokerAccounts() {
+        const response = await this.apiClient.getBrokerAccounts();
+        return response.data.accounts;
+    }
+    async linkBrokerAccount(brokerId) {
+        await this.apiClient.connectBroker(brokerId);
+    }
+    async unlinkBrokerAccount(brokerId) {
+        await this.apiClient.disconnectBroker(brokerId);
+    }
+    positionIframe(config) {
+        if (!this.iframe)
+            return;
+        const position = config.position || 'center';
+        const width = config.width || '600px';
+        const height = config.height || '800px';
+        this.iframe.style.width = width;
+        this.iframe.style.height = height;
+        switch (position) {
+            case 'center':
+                this.iframe.style.position = 'fixed';
+                this.iframe.style.top = '50%';
+                this.iframe.style.left = '50%';
+                this.iframe.style.transform = 'translate(-50%, -50%)';
+                break;
+            case 'top':
+                this.iframe.style.position = 'fixed';
+                this.iframe.style.top = '0';
+                this.iframe.style.left = '50%';
+                this.iframe.style.transform = 'translateX(-50%)';
+                break;
+            case 'bottom':
+                this.iframe.style.position = 'fixed';
+                this.iframe.style.bottom = '0';
+                this.iframe.style.left = '50%';
+                this.iframe.style.transform = 'translateX(-50%)';
+                break;
+            // Note: 'left' and 'right' positions removed from PortalConfig interface
+            // Default to center if invalid position is provided
+            default:
+                this.iframe.style.position = 'fixed';
+                this.iframe.style.top = '50%';
+                this.iframe.style.left = '50%';
+                this.iframe.style.transform = 'translate(-50%, -50%)';
+                break;
+        }
+    }
+    styleIframe(config) {
+        if (!this.iframe)
+            return;
+        // Apply z-index if specified
+        if (config.zIndex) {
+            this.iframe.style.zIndex = config.zIndex.toString();
+        }
+    }
+}
+
+exports.ApiClient = ApiClient;
+exports.ApiError = ApiError;
+exports.AuthenticationError = AuthenticationError;
+exports.AuthorizationError = AuthorizationError;
+exports.BaseError = BaseError;
+exports.CompanyAccessError = CompanyAccessError;
+exports.CoreAnalyticsService = CoreAnalyticsService;
+exports.CorePortalService = CorePortalService;
+exports.CoreTradingService = CoreTradingService;
+exports.EventEmitter = EventEmitter;
+exports.FinaticConnect = FinaticConnect;
+exports.MockFactory = MockFactory;
+exports.NetworkError = NetworkError;
+exports.OrderError = OrderError;
+exports.OrderValidationError = OrderValidationError;
+exports.PaginatedResult = PaginatedResult;
+exports.RateLimitError = RateLimitError;
+exports.SecurityError = SecurityError;
+exports.SessionError = SessionError;
+exports.TokenError = TokenError;
+exports.ValidationError = ValidationError;
+exports.appendThemeToURL = appendThemeToURL;
+exports.createCustomThemeFromPreset = createCustomThemeFromPreset;
+exports.generatePortalThemeURL = generatePortalThemeURL;
+exports.getThemePreset = getThemePreset;
+exports.portalThemePresets = portalThemePresets;
+exports.validateCustomTheme = validateCustomTheme;
+//# sourceMappingURL=index.js.map