@finatic/client 0.0.139 → 0.0.141

package/dist/index.js

@@ -205,15 +205,13 @@ class TradingNotEnabledError extends ApiError {
     }
 }
 
+// Supabase import removed - SDK no longer depends on Supabase
 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 management (no Supabase needed)
         // Session and company context
         this.companyId = null;
         this.csrfToken = null;
@@ -225,7 +223,9 @@ class ApiClient {
         if (!this.baseUrl.includes('/api/v1')) {
             this.baseUrl = `${this.baseUrl}/api/v1`;
         }
+        // No Supabase initialization needed - SDK is clean
     }
+    // Supabase initialization removed - SDK no longer depends on Supabase
     /**
      * Set session context (session ID, company ID, CSRF token)
      */
@@ -253,105 +253,30 @@ class ApiClient {
         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
+     * Get a valid access token (session-based auth - no tokens needed)
      */
     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;
+        // Session-based auth - return empty token as we use session headers
+        return '';
     }
+    // Token expiration check removed - session-based auth doesn't use expiring tokens
+    // Supabase refresh method removed - SDK no longer uses Supabase tokens
     /**
-     * Check if the current token is expired or about to expire
+     * Perform the actual Supabase session refresh
      */
-    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;
-    }
+    // Supabase refresh method removed - SDK no longer uses Supabase tokens
     /**
-     * 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)
+     * Clear session tokens (useful for logout)
      */
     clearTokens() {
-        this.tokenInfo = null;
-        this.refreshPromise = null;
+        // Session-based auth - no tokens to clear
     }
     /**
-     * Get current token info (for debugging/testing)
+     * Get current session info (for debugging/testing) - session-based auth
      */
     getTokenInfo() {
-        return this.tokenInfo ? { ...this.tokenInfo } : null;
+        // Session-based auth - no tokens to return
+        return null;
     }
     /**
      * Make a request to the API.
@@ -365,9 +290,12 @@ class ApiClient {
                 url.searchParams.append(key, value);
             });
         }
+        // Get Supabase JWT token
+        const accessToken = await this.getValidAccessToken();
         // Build comprehensive headers object with all available session data
         const comprehensiveHeaders = {
             'Content-Type': 'application/json',
+            Authorization: `Bearer ${accessToken}`,
         };
         // Add device info if available
         if (this.deviceInfo) {
@@ -535,7 +463,7 @@ class ApiClient {
     }
     // Session Management
     async startSession(token, userId) {
-        const response = await this.request('/auth/session/start', {
+        const response = await this.request('/session/start', {
             method: 'POST',
             headers: {
                 'Content-Type': 'application/json',
@@ -589,11 +517,8 @@ class ApiClient {
                 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);
-        }
+        // OTP verification successful - tokens are handled by Supabase client
+        if (response.success && response.data) ;
         return response;
     }
     // Direct Authentication
@@ -602,7 +527,7 @@ class ApiClient {
         if (this.currentSessionState !== SessionState.ACTIVE) {
             throw new SessionError('Session must be in ACTIVE state to authenticate');
         }
-        const response = await this.request('/auth/session/authenticate', {
+        const response = await this.request('/session/authenticate', {
             method: 'POST',
             headers: {
                 'Content-Type': 'application/json',
@@ -620,11 +545,7 @@ class ApiClient {
             },
         });
         // 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);
-        }
+        if (response.success && response.data) ;
         return response;
     }
     // Portal Management
@@ -638,7 +559,7 @@ class ApiClient {
         if (this.currentSessionState !== SessionState.ACTIVE) {
             throw new SessionError('Session must be in ACTIVE state to get portal URL');
         }
-        return this.request('/auth/session/portal', {
+        return this.request('/session/portal', {
             method: 'GET',
             headers: {
                 'Content-Type': 'application/json',
@@ -799,12 +720,6 @@ class ApiClient {
         this.tradingContext.accountNumber = accountNumber;
         this.tradingContext.accountId = accountId;
     }
-    getTradingContext() {
-        return { ...this.tradingContext };
-    }
-    clearTradingContext() {
-        this.tradingContext = {};
-    }
     // Stock convenience methods
     async placeStockMarketOrder(symbol, orderQty, action, broker, accountNumber, extras = {}, connection_id) {
         return this.placeBrokerOrder({
@@ -812,7 +727,7 @@ class ApiClient {
             orderQty,
             action,
             orderType: 'Market',
-            assetType: 'Stock',
+            assetType: 'equity',
             timeInForce: 'day',
             broker,
             accountNumber,
@@ -824,7 +739,7 @@ class ApiClient {
             orderQty,
             action,
             orderType: 'Limit',
-            assetType: 'Stock',
+            assetType: 'equity',
             price,
             timeInForce,
             broker,
@@ -837,7 +752,7 @@ class ApiClient {
             orderQty,
             action,
             orderType: 'Stop',
-            assetType: 'Stock',
+            assetType: 'equity',
             stopPrice,
             timeInForce,
             broker,
@@ -851,7 +766,7 @@ class ApiClient {
             orderQty,
             action,
             orderType: 'Market',
-            assetType: 'Crypto',
+            assetType: 'crypto',
             timeInForce: 'day',
             broker,
             accountNumber,
@@ -864,7 +779,7 @@ class ApiClient {
             orderQty,
             action,
             orderType: 'Limit',
-            assetType: 'Crypto',
+            assetType: 'crypto',
             price,
             timeInForce,
             broker,
@@ -879,7 +794,7 @@ class ApiClient {
             orderQty,
             action,
             orderType: 'Market',
-            assetType: 'Option',
+            assetType: 'equity_option',
             timeInForce: 'day',
             broker,
             accountNumber,
@@ -892,7 +807,7 @@ class ApiClient {
             orderQty,
             action,
             orderType: 'Limit',
-            assetType: 'Option',
+            assetType: 'equity_option',
             price,
             timeInForce,
             broker,
@@ -907,7 +822,7 @@ class ApiClient {
             orderQty,
             action,
             orderType: 'Market',
-            assetType: 'Future',
+            assetType: 'future',
             timeInForce: 'day',
             broker,
             accountNumber,
@@ -919,7 +834,7 @@ class ApiClient {
             orderQty,
             action,
             orderType: 'Limit',
-            assetType: 'Future',
+            assetType: 'future',
             price,
             timeInForce,
             broker,
@@ -1023,7 +938,7 @@ class ApiClient {
     }
     async getUserToken(sessionId) {
         const accessToken = await this.getValidAccessToken();
-        return this.request(`/auth/session/${sessionId}/user`, {
+        return this.request(`/session/${sessionId}/user`, {
             method: 'GET',
             headers: {
                 Authorization: `Bearer ${accessToken}`,
@@ -1038,18 +953,27 @@ class ApiClient {
     }
     /**
      * Refresh the current session to extend its lifetime
+     * Note: This now uses Supabase session refresh instead of custom endpoint
      */
     async refreshSession() {
         if (!this.currentSessionId || !this.companyId) {
             throw new SessionError('No active session to refresh');
         }
-        return this.request('/auth/session/refresh', {
-            method: 'POST',
-            headers: {
-                'Session-ID': this.currentSessionId,
-                'X-Company-ID': this.companyId,
+        // Session-based auth - no token refresh needed
+        // Return session info in expected format
+        return {
+            success: true,
+            response_data: {
+                session_id: this.currentSessionId,
+                company_id: this.companyId,
+                status: 'active',
+                expires_at: new Date(Date.now() + 60 * 60 * 1000).toISOString(), // 1 hour from now
+                user_id: '', // Session-based auth - user_id comes from session
+                auto_login: false,
             },
-        });
+            message: 'Session refreshed successfully',
+            status_code: 200,
+        };
     }
     // Broker Data Management
     async getBrokerList() {
@@ -1487,6 +1411,155 @@ class ApiClient {
             },
         });
     }
+    /**
+     * Get order fills for a specific order
+     * @param orderId - The order ID
+     * @param filter - Optional filter parameters
+     * @returns Promise with order fills response
+     */
+    async getOrderFills(orderId, filter) {
+        const accessToken = await this.getValidAccessToken();
+        const params = {};
+        if (filter?.connection_id) {
+            params.connection_id = filter.connection_id;
+        }
+        if (filter?.limit) {
+            params.limit = filter.limit.toString();
+        }
+        if (filter?.offset) {
+            params.offset = filter.offset.toString();
+        }
+        return this.request(`/brokers/data/orders/${orderId}/fills`, {
+            method: 'GET',
+            headers: {
+                Authorization: `Bearer ${accessToken}`,
+            },
+            params,
+        });
+    }
+    /**
+     * Get order events for a specific order
+     * @param orderId - The order ID
+     * @param filter - Optional filter parameters
+     * @returns Promise with order events response
+     */
+    async getOrderEvents(orderId, filter) {
+        const accessToken = await this.getValidAccessToken();
+        const params = {};
+        if (filter?.connection_id) {
+            params.connection_id = filter.connection_id;
+        }
+        if (filter?.limit) {
+            params.limit = filter.limit.toString();
+        }
+        if (filter?.offset) {
+            params.offset = filter.offset.toString();
+        }
+        return this.request(`/brokers/data/orders/${orderId}/events`, {
+            method: 'GET',
+            headers: {
+                Authorization: `Bearer ${accessToken}`,
+            },
+            params,
+        });
+    }
+    /**
+     * Get order groups
+     * @param filter - Optional filter parameters
+     * @returns Promise with order groups response
+     */
+    async getOrderGroups(filter) {
+        const accessToken = await this.getValidAccessToken();
+        const params = {};
+        if (filter?.broker_id) {
+            params.broker_id = filter.broker_id;
+        }
+        if (filter?.connection_id) {
+            params.connection_id = filter.connection_id;
+        }
+        if (filter?.limit) {
+            params.limit = filter.limit.toString();
+        }
+        if (filter?.offset) {
+            params.offset = filter.offset.toString();
+        }
+        if (filter?.created_after) {
+            params.created_after = filter.created_after;
+        }
+        if (filter?.created_before) {
+            params.created_before = filter.created_before;
+        }
+        return this.request('/brokers/data/orders/groups', {
+            method: 'GET',
+            headers: {
+                Authorization: `Bearer ${accessToken}`,
+            },
+            params,
+        });
+    }
+    /**
+     * Get position lots (tax lots for positions)
+     * @param filter - Optional filter parameters
+     * @returns Promise with position lots response
+     */
+    async getPositionLots(filter) {
+        const accessToken = await this.getValidAccessToken();
+        const params = {};
+        if (filter?.broker_id) {
+            params.broker_id = filter.broker_id;
+        }
+        if (filter?.connection_id) {
+            params.connection_id = filter.connection_id;
+        }
+        if (filter?.account_id) {
+            params.account_id = filter.account_id;
+        }
+        if (filter?.symbol) {
+            params.symbol = filter.symbol;
+        }
+        if (filter?.position_id) {
+            params.position_id = filter.position_id;
+        }
+        if (filter?.limit) {
+            params.limit = filter.limit.toString();
+        }
+        if (filter?.offset) {
+            params.offset = filter.offset.toString();
+        }
+        return this.request('/brokers/data/positions/lots', {
+            method: 'GET',
+            headers: {
+                Authorization: `Bearer ${accessToken}`,
+            },
+            params,
+        });
+    }
+    /**
+     * Get position lot fills for a specific lot
+     * @param lotId - The position lot ID
+     * @param filter - Optional filter parameters
+     * @returns Promise with position lot fills response
+     */
+    async getPositionLotFills(lotId, filter) {
+        const accessToken = await this.getValidAccessToken();
+        const params = {};
+        if (filter?.connection_id) {
+            params.connection_id = filter.connection_id;
+        }
+        if (filter?.limit) {
+            params.limit = filter.limit.toString();
+        }
+        if (filter?.offset) {
+            params.offset = filter.offset.toString();
+        }
+        return this.request(`/brokers/data/positions/lots/${lotId}/fills`, {
+            method: 'GET',
+            headers: {
+                Authorization: `Bearer ${accessToken}`,
+            },
+            params,
+        });
+    }
 }
 
 class EventEmitter {
@@ -1820,15 +1893,11 @@ class MockDataProvider {
      * Generate mock tokens
      */
     generateTokens(userId) {
-        const accessToken = `mock_access_${uuid.v4().replace(/-/g, '')}`;
-        const refreshToken = `mock_refresh_${uuid.v4().replace(/-/g, '')}`;
+        `mock_access_${uuid.v4().replace(/-/g, '')}`;
+        `mock_refresh_${uuid.v4().replace(/-/g, '')}`;
         return {
-            accessToken,
-            refreshToken,
-            expiresIn: 3600, // 1 hour
             user_id: userId,
-            tokenType: 'Bearer',
-            scope: 'read write',
+            // Removed token fields - we no longer use Supabase tokens in the SDK
         };
     }
     // Authentication & Session Management Mocks
@@ -1848,6 +1917,7 @@ class MockDataProvider {
         };
         this.sessionData.set(sessionId, sessionData);
         return {
+            success: true,
             data: sessionData,
             message: 'Session started successfully',
         };
@@ -1869,12 +1939,12 @@ class MockDataProvider {
             success: true,
             message: 'OTP verified successfully',
             data: {
-                access_token: tokens.accessToken,
-                refresh_token: tokens.refreshToken,
+                access_token: '', // No longer using Supabase tokens
+                refresh_token: '', // No longer using Supabase tokens
                 user_id: userId,
-                expires_in: tokens.expiresIn,
-                scope: tokens.scope,
-                token_type: tokens.tokenType,
+                expires_in: 0, // No token expiration for session-based auth
+                scope: 'api:access',
+                token_type: 'Bearer',
             },
         };
     }
@@ -1886,8 +1956,8 @@ class MockDataProvider {
             success: true,
             message: 'Authentication successful',
             data: {
-                access_token: tokens.accessToken,
-                refresh_token: tokens.refreshToken,
+                access_token: '', // No longer using Supabase tokens
+                refresh_token: '', // No longer using Supabase tokens
             },
         };
     }
@@ -1933,6 +2003,8 @@ class MockDataProvider {
             valid: true,
             company_id: this.generateCompanyId(),
             status: 'active',
+            is_sandbox: false,
+            environment: 'production',
         };
     }
     async mockCompletePortalSession(sessionId) {
@@ -2036,6 +2108,12 @@ class MockDataProvider {
                 created_at: new Date().toISOString(),
                 updated_at: new Date().toISOString(),
                 last_synced_at: new Date().toISOString(),
+                positions_synced_at: new Date().toISOString(),
+                orders_synced_at: new Date().toISOString(),
+                balances_synced_at: new Date().toISOString(),
+                account_created_at: new Date(Date.now() - 365 * 24 * 60 * 60 * 1000).toISOString(), // 1 year ago
+                account_updated_at: new Date().toISOString(),
+                account_first_trade_at: new Date(Date.now() - 300 * 24 * 60 * 60 * 1000).toISOString(), // 300 days ago
             },
             {
                 id: uuid.v4(),
@@ -2050,6 +2128,12 @@ class MockDataProvider {
                 created_at: new Date().toISOString(),
                 updated_at: new Date().toISOString(),
                 last_synced_at: new Date().toISOString(),
+                positions_synced_at: new Date().toISOString(),
+                orders_synced_at: new Date().toISOString(),
+                balances_synced_at: new Date().toISOString(),
+                account_created_at: new Date(Date.now() - 730 * 24 * 60 * 60 * 1000).toISOString(), // 2 years ago
+                account_updated_at: new Date().toISOString(),
+                account_first_trade_at: new Date(Date.now() - 700 * 24 * 60 * 60 * 1000).toISOString(), // 700 days ago
             },
         ];
         return {
@@ -2535,6 +2619,12 @@ class MockDataProvider {
                 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(),
+                positions_synced_at: new Date().toISOString(),
+                orders_synced_at: new Date().toISOString(),
+                balances_synced_at: new Date().toISOString(),
+                account_created_at: new Date(Date.now() - Math.random() * 730 * 24 * 60 * 60 * 1000).toISOString(), // Random date within last 2 years
+                account_updated_at: new Date().toISOString(),
+                account_first_trade_at: new Date(Date.now() - Math.random() * 500 * 24 * 60 * 60 * 1000).toISOString(), // Random date within last 500 days
             });
         }
         return accounts;
@@ -2871,12 +2961,6 @@ class MockApiClient {
         this.tradingContext.accountId = accountId;
         console.log('MockApiClient.setAccount Debug - Updated context:', this.tradingContext);
     }
-    getTradingContext() {
-        return { ...this.tradingContext };
-    }
-    clearTradingContext() {
-        this.tradingContext = {};
-    }
     // Stock convenience methods
     async placeStockMarketOrder(symbol, orderQty, action, broker, accountNumber, extras = {}) {
         return this.placeBrokerOrder({
@@ -2886,7 +2970,7 @@ class MockApiClient {
             orderQty,
             action,
             orderType: 'Market',
-            assetType: 'Stock',
+            assetType: 'equity',
             timeInForce: 'day',
         }, extras);
     }
@@ -2898,7 +2982,7 @@ class MockApiClient {
             orderQty,
             action,
             orderType: 'Limit',
-            assetType: 'Stock',
+            assetType: 'equity',
             timeInForce,
             price,
         }, extras);
@@ -2911,7 +2995,7 @@ class MockApiClient {
             orderQty,
             action,
             orderType: 'Stop',
-            assetType: 'Stock',
+            assetType: 'equity',
             timeInForce,
             stopPrice,
         }, extras);
@@ -2925,7 +3009,7 @@ class MockApiClient {
             orderQty: options.quantity || orderQty,
             action,
             orderType: 'Market',
-            assetType: 'Crypto',
+            assetType: 'crypto',
             timeInForce: 'gtc', // Crypto typically uses GTC
         };
         return this.placeBrokerOrder(orderParams, extras);
@@ -2938,7 +3022,7 @@ class MockApiClient {
             orderQty: options.quantity || orderQty,
             action,
             orderType: 'Limit',
-            assetType: 'Crypto',
+            assetType: 'crypto',
             timeInForce,
             price,
         };
@@ -2953,7 +3037,7 @@ class MockApiClient {
             orderQty,
             action,
             orderType: 'Market',
-            assetType: 'Option',
+            assetType: 'equity_option',
             timeInForce: 'day',
         };
         return this.placeBrokerOrder(orderParams, extras);
@@ -2966,7 +3050,7 @@ class MockApiClient {
             orderQty,
             action,
             orderType: 'Limit',
-            assetType: 'Option',
+            assetType: 'equity_option',
             timeInForce,
             price,
         };
@@ -2981,7 +3065,7 @@ class MockApiClient {
             orderQty,
             action,
             orderType: 'Market',
-            assetType: 'Future',
+            assetType: 'future',
             timeInForce: 'day',
         }, extras);
     }
@@ -2993,7 +3077,7 @@ class MockApiClient {
             orderQty,
             action,
             orderType: 'Limit',
-            assetType: 'Future',
+            assetType: 'future',
             timeInForce,
             price,
         }, extras);
@@ -3207,6 +3291,8 @@ class MockApiClient {
 /**
  * Utility functions for mock system environment detection
  */
+// Type declarations for Node.js environment
+// Note: process is already declared globally in Node.js types
 /**
  * Check if mocks should be used based on environment variables
  * Supports both browser and Node.js environments
@@ -4909,95 +4995,161 @@ class FinaticConnect extends EventEmitter {
         // Register automatic session cleanup
         this.registerSessionCleanup();
     }
-    handleTokens(tokens) {
-        if (!tokens.access_token || !tokens.refresh_token) {
-            return;
+    async linkUserToSession(userId) {
+        try {
+            if (!this.sessionId) {
+                console.error('No session ID available for user linking');
+                return false;
+            }
+            // Call API endpoint to authenticate user with session
+            const response = await this.apiClient.request('/session/authenticate', {
+                method: 'POST',
+                body: {
+                    session_id: this.sessionId,
+                    user_id: userId,
+                },
+            });
+            if (response.error) {
+                console.error('Failed to link user to session:', response.error);
+                return false;
+            }
+            console.log('User linked to session successfully');
+            return true;
+        }
+        catch (error) {
+            console.error('Error linking user to session:', error);
+            return false;
         }
-        // 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 fully authenticated (has userId, access token, and refresh token)
-     * @returns True if the user is fully authenticated and ready for API calls
+     * Store user ID for authentication state persistence
+     * @param userId - The user ID to store
      */
-    isAuthed() {
-        return !!(this.userToken?.accessToken &&
-            this.userToken?.refreshToken &&
-            this.userToken?.user_id);
+    storeUserId(userId) {
+        // Initialize userToken if it doesn't exist
+        if (!this.userToken) {
+            this.userToken = {
+                user_id: userId,
+            };
+        }
+        else {
+            // Update existing userToken with new userId
+            this.userToken.user_id = userId;
+        }
+        // Set user ID in ApiClient for session context
+        this.apiClient.setSessionContext(this.sessionId || '', this.companyId, undefined);
     }
     /**
-     * Check if the client is authenticated (alias for isAuthed for consistency)
-     * @returns True if authenticated, false otherwise
+     * Check if the user is fully authenticated (has userId in session context)
+     * @returns True if the user is fully authenticated and ready for API calls
      */
-    is_authenticated() {
-        return this.isAuthed();
+    async isAuthenticated() {
+        // Check internal session context only - no localStorage dependency
+        return this.userToken?.user_id !== undefined && this.userToken?.user_id !== null;
     }
     /**
      * 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.isAuthed()) {
+    async getOrders(page = 1, perPage = 100, options, filters) {
+        if (!(await 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);
+        const result = await this.apiClient.getBrokerOrdersPage(page, perPage, filters);
+        // Add navigation methods to the result
+        const paginatedResult = result;
+        paginatedResult.next_page = async () => {
+            if (paginatedResult.hasNext) {
+                return this.apiClient.getBrokerOrdersPage(page + 1, perPage, filters);
+            }
+            throw new Error('No next page available');
+        };
+        paginatedResult.previous_page = async () => {
+            if (paginatedResult.has_previous) {
+                return this.apiClient.getBrokerOrdersPage(page - 1, perPage, filters);
+            }
+            throw new Error('No previous page available');
+        };
+        return paginatedResult;
     }
     /**
      * 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.isAuthed()) {
+    async getPositions(page = 1, perPage = 100, options, filters) {
+        if (!(await 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);
+        const result = await this.apiClient.getBrokerPositionsPage(page, perPage, filters);
+        // Add navigation methods to the result
+        const paginatedResult = result;
+        paginatedResult.next_page = async () => {
+            if (paginatedResult.hasNext) {
+                return this.apiClient.getBrokerPositionsPage(page + 1, perPage, filters);
+            }
+            throw new Error('No next page available');
+        };
+        paginatedResult.previous_page = async () => {
+            if (paginatedResult.has_previous) {
+                return this.apiClient.getBrokerPositionsPage(page - 1, perPage, filters);
+            }
+            throw new Error('No previous page available');
+        };
+        return paginatedResult;
     }
     /**
      * 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.isAuthed()) {
+    async getAccounts(page = 1, perPage = 100, options, filters) {
+        if (!(await 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);
+        const result = await this.apiClient.getBrokerAccountsPage(page, perPage, filters);
+        // Add navigation methods to the result
+        const paginatedResult = result;
+        paginatedResult.next_page = async () => {
+            if (paginatedResult.hasNext) {
+                return this.apiClient.getBrokerAccountsPage(page + 1, perPage, filters);
+            }
+            throw new Error('No next page available');
+        };
+        paginatedResult.previous_page = async () => {
+            if (paginatedResult.has_previous) {
+                return this.apiClient.getBrokerAccountsPage(page - 1, perPage, filters);
+            }
+            throw new Error('No previous page available');
+        };
+        return paginatedResult;
     }
     /**
      * Get user's balances with pagination and optional filtering
      * @param params - Query parameters including page, perPage, and filters
      * @returns Promise with paginated result that supports navigation
      */
-    async getBalances(params) {
-        if (!this.isAuthed()) {
+    async getBalances(page = 1, perPage = 100, options, filters) {
+        if (!(await 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.getBalancesPage(page, perPage, filter);
+        const result = await this.apiClient.getBrokerBalancesPage(page, perPage, filters);
+        // Add navigation methods to the result
+        const paginatedResult = result;
+        paginatedResult.next_page = async () => {
+            if (paginatedResult.hasNext) {
+                return this.apiClient.getBrokerBalancesPage(page + 1, perPage, filters);
+            }
+            throw new Error('No next page available');
+        };
+        paginatedResult.previous_page = async () => {
+            if (paginatedResult.has_previous) {
+                return this.apiClient.getBrokerBalancesPage(page - 1, perPage, filters);
+            }
+            throw new Error('No previous page available');
+        };
+        return paginatedResult;
     }
     /**
      * Initialize the Finatic Connect SDK
@@ -5050,26 +5202,20 @@ class FinaticConnect extends EventEmitter {
                 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 userId is provided, try to link user to session
             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);
+                    // Try to link user to session via API
+                    const linked = await FinaticConnect.instance.linkUserToSession(normalizedUserId);
+                    if (linked) {
+                        // Store user ID for authentication state
+                        FinaticConnect.instance.storeUserId(normalizedUserId);
+                        // Emit success event
+                        FinaticConnect.instance.emit('success', normalizedUserId);
+                    }
+                    else {
+                        console.warn('Failed to link user to session during initialization');
+                    }
                 }
                 catch (error) {
                     FinaticConnect.instance.emit('error', error);
@@ -5090,38 +5236,25 @@ class FinaticConnect extends EventEmitter {
      * Get the user and tokens for a completed session
      * @returns Promise with user information and tokens
      */
-    async getSessionUser() {
-        if (!this.isAuthed()) {
-            throw new AuthenticationError('User is not authenticated');
-        }
-        if (!this.userToken) {
-            throw new AuthenticationError('No user token available');
-        }
-        return {
-            user_id: this.userToken.userId,
-            access_token: this.userToken.accessToken,
-            refresh_token: this.userToken.refreshToken,
-            expires_in: this.userToken.expiresIn,
-            token_type: this.userToken.tokenType,
-            scope: this.userToken.scope,
-            company_id: this.companyId,
-        };
-    }
     async initializeWithUser(userId) {
         try {
             if (!this.sessionId) {
                 throw new SessionError('Session not initialized');
             }
-            this.userToken = await this.apiClient.getUserToken(this.sessionId);
-            // 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);
+            // Try to link user to session
+            const linked = await this.linkUserToSession(userId);
+            if (!linked) {
+                console.warn('Failed to link user to session during initialization');
+                // Don't throw error, just continue without authentication
+                return;
             }
+            // Store user ID for authentication state
+            this.storeUserId(userId);
             this.emit('success', userId);
         }
         catch (error) {
             this.emit('error', error);
+            throw error;
         }
     }
     /**
@@ -5174,20 +5307,32 @@ class FinaticConnect extends EventEmitter {
                 url.searchParams.set('email', options.email);
                 themedPortalUrl = url.toString();
             }
+            // Add session ID to portal URL so the portal can use it
+            const url = new URL(themedPortalUrl);
+            if (this.sessionId) {
+                url.searchParams.set('session_id', this.sessionId);
+            }
+            if (this.companyId) {
+                url.searchParams.set('company_id', this.companyId);
+            }
+            themedPortalUrl = url.toString();
             // 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, tokens) => {
+                onSuccess: async (userId) => {
                     try {
                         if (!this.sessionId) {
                             throw new SessionError('Session not initialized');
                         }
-                        // Handle tokens if provided
-                        if (tokens?.access_token && tokens?.refresh_token) {
-                            this.handleTokens(tokens);
+                        // Store the userId for authentication state
+                        this.storeUserId(userId);
+                        // Try to link user to session via API
+                        const linked = await this.linkUserToSession(userId);
+                        if (!linked) {
+                            console.warn('Failed to link user to session, but continuing with authentication');
                         }
                         // Emit portal success event
                         this.emit('portal:success', userId);
@@ -5278,32 +5423,16 @@ class FinaticConnect extends EventEmitter {
      * 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');
+    async placeOrder(order, extras) {
+        if (!(await 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.');
         }
         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'
-                            : 'StopLimit',
-                assetType: order.assetType || 'Stock',
-                timeInForce: order.timeInForce,
-                price: order.price,
-                stopPrice: order.stopPrice,
-                broker: order.broker,
-                accountNumber: order.accountNumber,
-                order_id: order.order_id,
-            };
-            return await this.apiClient.placeBrokerOrder(this.userToken.accessToken, brokerOrder, {}, order.connection_id);
+            // Use the order parameter directly since it's already BrokerOrderParams
+            return await this.apiClient.placeBrokerOrder(order, extras || {}, order.connection_id);
         }
         catch (error) {
             this.emit('error', error);
@@ -5317,8 +5446,11 @@ class FinaticConnect extends EventEmitter {
      * @param connection_id - Optional connection ID for testing bypass
      */
     async cancelOrder(orderId, broker, connection_id) {
-        if (!this.userToken) {
-            throw new Error('Not initialized with user');
+        if (!(await 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.');
         }
         try {
             return await this.apiClient.cancelBrokerOrder(orderId, broker, {}, connection_id);
@@ -5336,8 +5468,11 @@ class FinaticConnect extends EventEmitter {
      * @param connection_id - Optional connection ID for testing bypass
      */
     async modifyOrder(orderId, modifications, broker, connection_id) {
-        if (!this.userToken) {
-            throw new Error('Not initialized with user');
+        if (!(await 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.');
         }
         try {
             // Convert modifications to broker format
@@ -5365,39 +5500,15 @@ class FinaticConnect extends EventEmitter {
             throw error;
         }
     }
-    /**
-     * Set the broker context for trading
-     * @param broker - The broker to use for trading
-     */
-    setTradingContextBroker(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
-     */
-    setTradingContextAccount(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');
+        if (!(await 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.');
         }
         try {
             return await this.apiClient.placeStockMarketOrder(symbol, quantity, side === 'buy' ? 'Buy' : 'Sell', broker, accountNumber);
@@ -5411,8 +5522,11 @@ class FinaticConnect extends EventEmitter {
      * 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');
+        if (!(await 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.');
         }
         try {
             return await this.apiClient.placeStockLimitOrder(symbol, quantity, side === 'buy' ? 'Buy' : 'Sell', price, timeInForce, broker, accountNumber);
@@ -5426,8 +5540,11 @@ class FinaticConnect extends EventEmitter {
      * Place a stock stop order (convenience method)
      */
     async placeStockStopOrder(symbol, quantity, side, stopPrice, timeInForce = 'gtc', broker, accountNumber) {
-        if (!this.userToken) {
-            throw new Error('Not initialized with user');
+        if (!(await 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.');
         }
         try {
             return await this.apiClient.placeStockStopOrder(symbol, quantity, side === 'buy' ? 'Buy' : 'Sell', stopPrice, timeInForce, broker, accountNumber);
@@ -5441,8 +5558,11 @@ class FinaticConnect extends EventEmitter {
      * Place a crypto market order (convenience method)
      */
     async placeCryptoMarketOrder(symbol, quantity, side, broker, accountNumber) {
-        if (!this.userToken) {
-            throw new Error('Not initialized with user');
+        if (!(await 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.');
         }
         try {
             return await this.apiClient.placeCryptoMarketOrder(symbol, quantity, side === 'buy' ? 'Buy' : 'Sell', broker, accountNumber);
@@ -5456,8 +5576,11 @@ class FinaticConnect extends EventEmitter {
      * Place a crypto limit order (convenience method)
      */
     async placeCryptoLimitOrder(symbol, quantity, side, price, timeInForce = 'gtc', broker, accountNumber) {
-        if (!this.userToken) {
-            throw new Error('Not initialized with user');
+        if (!(await 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.');
         }
         try {
             return await this.apiClient.placeCryptoLimitOrder(symbol, quantity, side === 'buy' ? 'Buy' : 'Sell', price, timeInForce, broker, accountNumber);
@@ -5471,8 +5594,11 @@ class FinaticConnect extends EventEmitter {
      * Place an options market order (convenience method)
      */
     async placeOptionsMarketOrder(symbol, quantity, side, broker, accountNumber) {
-        if (!this.userToken) {
-            throw new Error('Not initialized with user');
+        if (!(await 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.');
         }
         try {
             return await this.apiClient.placeOptionsMarketOrder(symbol, quantity, side === 'buy' ? 'Buy' : 'Sell', broker, accountNumber);
@@ -5486,8 +5612,11 @@ class FinaticConnect extends EventEmitter {
      * Place an options limit order (convenience method)
      */
     async placeOptionsLimitOrder(symbol, quantity, side, price, timeInForce = 'gtc', broker, accountNumber) {
-        if (!this.userToken) {
-            throw new Error('Not initialized with user');
+        if (!(await 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.');
         }
         try {
             return await this.apiClient.placeOptionsLimitOrder(symbol, quantity, side === 'buy' ? 'Buy' : 'Sell', price, timeInForce, broker, accountNumber);
@@ -5501,8 +5630,11 @@ class FinaticConnect extends EventEmitter {
      * Place a futures market order (convenience method)
      */
     async placeFuturesMarketOrder(symbol, quantity, side, broker, accountNumber) {
-        if (!this.userToken) {
-            throw new Error('Not initialized with user');
+        if (!(await 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.');
         }
         try {
             return await this.apiClient.placeFuturesMarketOrder(symbol, quantity, side === 'buy' ? 'Buy' : 'Sell', broker, accountNumber);
@@ -5516,8 +5648,11 @@ class FinaticConnect extends EventEmitter {
      * Place a futures limit order (convenience method)
      */
     async placeFuturesLimitOrder(symbol, quantity, side, price, timeInForce = 'gtc', broker, accountNumber) {
-        if (!this.userToken) {
-            throw new Error('Not initialized with user');
+        if (!(await 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.');
         }
         try {
             return await this.apiClient.placeFuturesLimitOrder(symbol, quantity, side === 'buy' ? 'Buy' : 'Sell', price, timeInForce, broker, accountNumber);
@@ -5532,8 +5667,8 @@ class FinaticConnect extends EventEmitter {
      * @returns The current user ID or undefined if not authenticated
      * @throws AuthenticationError if user is not authenticated
      */
-    getUserId() {
-        if (!this.isAuthed()) {
+    async getUserId() {
+        if (!(await this.isAuthenticated())) {
             return null;
         }
         if (!this.userToken?.user_id) {
@@ -5546,7 +5681,7 @@ class FinaticConnect extends EventEmitter {
      * @returns Promise with array of broker information
      */
     async getBrokerList() {
-        // if (!this.isAuthed()) {
+        // if (!this.isAuthenticated()) {
         //   throw new AuthenticationError('Not authenticated');
         // }
         const response = await this.apiClient.getBrokerList();
@@ -5563,7 +5698,7 @@ class FinaticConnect extends EventEmitter {
      * @throws AuthenticationError if user is not authenticated
      */
     async getBrokerConnections() {
-        if (!this.isAuthed()) {
+        if (!(await this.isAuthenticated())) {
             throw new AuthenticationError('User is not authenticated. Please connect a broker first.');
         }
         if (!this.userToken?.user_id) {
@@ -5637,118 +5772,22 @@ class FinaticConnect extends EventEmitter {
         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.isAuthed()) {
-            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.isAuthed()) {
-            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.isAuthed()) {
-            throw new AuthenticationError('User is not authenticated');
-        }
-        return this.apiClient.getBrokerAccountsPage(page, perPage, filter);
-    }
-    async getBalancesPage(page = 1, perPage = 100, filter) {
-        if (!this.isAuthed()) {
-            throw new AuthenticationError('User is not authenticated');
-        }
-        return this.apiClient.getBrokerBalancesPage(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.isAuthed()) {
-            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.isAuthed()) {
-            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.isAuthed()) {
-            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);
-        });
-    }
-    async getNextBalancesPage(previousResult) {
-        if (!this.isAuthed()) {
-            throw new AuthenticationError('User is not authenticated');
-        }
-        return this.apiClient.getNextPage(previousResult, (offset, limit) => {
-            const page = Math.floor(offset / limit) + 1;
-            return this.apiClient.getBrokerBalancesPage(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.isAuthed()) {
+        if (!(await this.isAuthenticated())) {
             throw new AuthenticationError('User is not authenticated');
         }
         const allData = [];
-        let currentResult = await this.getOrdersPage(1, 100, filter);
+        let currentResult = await this.apiClient.getBrokerOrdersPage(1, 100, filter);
         while (currentResult) {
             allData.push(...currentResult.data);
             if (!currentResult.hasNext)
                 break;
-            const nextResult = await this.getNextOrdersPage(currentResult);
+            const nextResult = await currentResult.nextPage();
             if (!nextResult)
                 break;
             currentResult = nextResult;
@@ -5761,16 +5800,16 @@ class FinaticConnect extends EventEmitter {
      * @returns Promise with all positions
      */
     async getAllPositions(filter) {
-        if (!this.isAuthed()) {
+        if (!(await this.isAuthenticated())) {
             throw new AuthenticationError('User is not authenticated');
         }
         const allData = [];
-        let currentResult = await this.getPositionsPage(1, 100, filter);
+        let currentResult = await this.apiClient.getBrokerPositionsPage(1, 100, filter);
         while (currentResult) {
             allData.push(...currentResult.data);
             if (!currentResult.hasNext)
                 break;
-            const nextResult = await this.getNextPositionsPage(currentResult);
+            const nextResult = await currentResult.nextPage();
             if (!nextResult)
                 break;
             currentResult = nextResult;
@@ -5783,16 +5822,16 @@ class FinaticConnect extends EventEmitter {
      * @returns Promise with all accounts
      */
     async getAllAccounts(filter) {
-        if (!this.isAuthed()) {
+        if (!(await this.isAuthenticated())) {
             throw new AuthenticationError('User is not authenticated');
         }
         const allData = [];
-        let currentResult = await this.getAccountsPage(1, 100, filter);
+        let currentResult = await this.apiClient.getBrokerAccountsPage(1, 100, filter);
         while (currentResult) {
             allData.push(...currentResult.data);
             if (!currentResult.hasNext)
                 break;
-            const nextResult = await this.getNextAccountsPage(currentResult);
+            const nextResult = await currentResult.nextPage();
             if (!nextResult)
                 break;
             currentResult = nextResult;
@@ -5800,16 +5839,16 @@ class FinaticConnect extends EventEmitter {
         return allData;
     }
     async getAllBalances(filter) {
-        if (!this.isAuthed()) {
+        if (!(await this.isAuthenticated())) {
             throw new AuthenticationError('User is not authenticated');
         }
         const allData = [];
-        let currentResult = await this.getBalancesPage(1, 100, filter);
+        let currentResult = await this.apiClient.getBrokerBalancesPage(1, 100, filter);
         while (currentResult) {
             allData.push(...currentResult.data);
             if (!currentResult.hasNext)
                 break;
-            const nextResult = await this.getNextBalancesPage(currentResult);
+            const nextResult = await currentResult.nextPage();
             if (!nextResult)
                 break;
             currentResult = nextResult;
@@ -5854,7 +5893,7 @@ class FinaticConnect extends EventEmitter {
      * Validate session for keep-alive purposes and handle automatic refresh
      */
     async validateSessionKeepAlive() {
-        if (!this.sessionId || !this.isAuthed()) {
+        if (!this.sessionId || !(await this.isAuthenticated())) {
             console.log('[FinaticConnect] Session keep-alive skipped - no active session');
             return;
         }
@@ -5965,7 +6004,6 @@ class FinaticConnect extends EventEmitter {
             const response = await fetch(`${this.baseUrl}/portal/${sessionId}/complete`, {
                 method: 'POST',
                 headers: {
-                    Authorization: `Bearer ${this.userToken?.accessToken || ''}`,
                     'Content-Type': 'application/json',
                 },
             });
@@ -5988,7 +6026,7 @@ class FinaticConnect extends EventEmitter {
      * @throws AuthenticationError if user is not authenticated
      */
     async disconnectCompany(connectionId) {
-        if (!this.isAuthed()) {
+        if (!(await this.isAuthenticated())) {
             throw new AuthenticationError('User is not authenticated. Please connect a broker first.');
         }
         if (!this.userToken?.user_id) {
@@ -5997,22 +6035,67 @@ class FinaticConnect extends EventEmitter {
         return this.apiClient.disconnectCompany(connectionId);
     }
     /**
-     * Get account balances for the authenticated user
-     * @param filters - Optional filters for balances
-     * @returns Promise with balance data
+     * Get order fills for a specific order
+     * @param orderId - The order ID
+     * @param filter - Optional filter parameters
+     * @returns Promise with order fills response
      */
-    async getBalances(filters) {
-        if (!this.isAuthed()) {
+    async getOrderFills(orderId, filter) {
+        if (!(await this.isAuthenticated())) {
             throw new AuthenticationError('User is not authenticated');
         }
-        try {
-            const response = await this.apiClient.getBalances(filters);
-            return response.response_data || [];
+        const response = await this.apiClient.getOrderFills(orderId, filter);
+        return response.response_data;
+    }
+    /**
+     * Get order events for a specific order
+     * @param orderId - The order ID
+     * @param filter - Optional filter parameters
+     * @returns Promise with order events response
+     */
+    async getOrderEvents(orderId, filter) {
+        if (!(await this.isAuthenticated())) {
+            throw new AuthenticationError('User is not authenticated');
         }
-        catch (error) {
-            this.emit('error', error);
-            throw error;
+        const response = await this.apiClient.getOrderEvents(orderId, filter);
+        return response.response_data;
+    }
+    /**
+     * Get order groups
+     * @param filter - Optional filter parameters
+     * @returns Promise with order groups response
+     */
+    async getOrderGroups(filter) {
+        if (!(await this.isAuthenticated())) {
+            throw new AuthenticationError('User is not authenticated');
         }
+        const response = await this.apiClient.getOrderGroups(filter);
+        return response.response_data;
+    }
+    /**
+     * Get position lots (tax lots for positions)
+     * @param filter - Optional filter parameters
+     * @returns Promise with position lots response
+     */
+    async getPositionLots(filter) {
+        if (!(await this.isAuthenticated())) {
+            throw new AuthenticationError('User is not authenticated');
+        }
+        const response = await this.apiClient.getPositionLots(filter);
+        return response.response_data;
+    }
+    /**
+     * Get position lot fills for a specific lot
+     * @param lotId - The position lot ID
+     * @param filter - Optional filter parameters
+     * @returns Promise with position lot fills response
+     */
+    async getPositionLotFills(lotId, filter) {
+        if (!(await this.isAuthenticated())) {
+            throw new AuthenticationError('User is not authenticated');
+        }
+        const response = await this.apiClient.getPositionLotFills(lotId, filter);
+        return response.response_data;
     }
 }
 FinaticConnect.instance = null;
@@ -6025,7 +6108,6 @@ exports.BaseError = BaseError;
 exports.CompanyAccessError = CompanyAccessError;
 exports.EventEmitter = EventEmitter;
 exports.FinaticConnect = FinaticConnect;
-exports.MockFactory = MockFactory;
 exports.NetworkError = NetworkError;
 exports.OrderError = OrderError;
 exports.OrderValidationError = OrderValidationError;