@finatic/client 0.0.140 → 0.0.142

package/dist/index.js

@@ -2,9 +2,287 @@
 
 var uuid = require('uuid');
 
+var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
+const LOG_LEVEL_ORDER = {
+    error: 0,
+    warn: 1,
+    info: 2,
+    debug: 3,
+};
+const LEVEL_TO_CONSOLE = {
+    error: 'error',
+    warn: 'warn',
+    info: 'info',
+    debug: 'debug',
+};
+const DEFAULT_LOGGER_NAME = 'FinaticLogger';
+const parseLogLevel = (value, fallback) => {
+    if (typeof value !== 'string') {
+        return fallback;
+    }
+    const normalized = value.toLowerCase().trim();
+    if (normalized === 'silent' || normalized === 'error' || normalized === 'warn' || normalized === 'info' || normalized === 'debug') {
+        return normalized;
+    }
+    return fallback;
+};
+const parseVerbosity = (value, fallback) => {
+    if (typeof value !== 'string' && typeof value !== 'number') {
+        return fallback;
+    }
+    const numeric = typeof value === 'number' ? value : Number.parseInt(value, 10);
+    if (Number.isNaN(numeric)) {
+        return fallback;
+    }
+    if (numeric <= 0) {
+        return 0;
+    }
+    if (numeric >= 3) {
+        return 3;
+    }
+    return numeric;
+};
+const resolveEnv = (key) => {
+    try {
+        if (typeof process !== 'undefined' && process.env && typeof process.env[key] === 'string') {
+            return process.env[key];
+        }
+    }
+    catch {
+        // ignore
+    }
+    try {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const metaEnv = typeof ({ url: (typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index.js', document.baseURI).href)) }) !== 'undefined' ? undefined : undefined;
+        if (metaEnv && typeof metaEnv[key] === 'string') {
+            return metaEnv[key];
+        }
+    }
+    catch {
+        // ignore
+    }
+    try {
+        if (typeof globalThis !== 'undefined') {
+            const value = globalThis[key];
+            if (typeof value === 'string') {
+                return value;
+            }
+        }
+    }
+    catch {
+        // ignore
+    }
+    return undefined;
+};
+const resolveDefaultLogLevel = (explicitLevel) => {
+    if (explicitLevel) {
+        return explicitLevel;
+    }
+    const envLevel = resolveEnv('FINATIC_LOG_LEVEL') ||
+        resolveEnv('VITE_FINATIC_LOG_LEVEL') ||
+        resolveEnv('NEXT_PUBLIC_FINATIC_LOG_LEVEL') ||
+        resolveEnv('NEXT_FINATIC_LOG_LEVEL') ||
+        resolveEnv('REACT_APP_FINATIC_LOG_LEVEL') ||
+        resolveEnv('NUXT_PUBLIC_FINATIC_LOG_LEVEL') ||
+        resolveEnv('NX_FINATIC_LOG_LEVEL');
+    if (envLevel) {
+        return parseLogLevel(envLevel, 'silent');
+    }
+    return 'silent';
+};
+const resolveVerbosity = () => {
+    const envVerbosity = resolveEnv('FINATIC_LOG_VERBOSITY') ||
+        resolveEnv('VITE_FINATIC_LOG_VERBOSITY') ||
+        resolveEnv('NEXT_PUBLIC_FINATIC_LOG_VERBOSITY') ||
+        resolveEnv('NEXT_FINATIC_LOG_VERBOSITY') ||
+        resolveEnv('REACT_APP_FINATIC_LOG_VERBOSITY') ||
+        resolveEnv('NUXT_PUBLIC_FINATIC_LOG_VERBOSITY') ||
+        resolveEnv('NX_FINATIC_LOG_VERBOSITY');
+    if (envVerbosity) {
+        return parseVerbosity(envVerbosity, 1);
+    }
+    return 1;
+};
+const resolveBaseMetadata = () => {
+    const base = {
+        timestamp: new Date().toISOString(),
+    };
+    try {
+        if (typeof globalThis !== 'undefined') {
+            if (typeof globalThis.location !== 'undefined') {
+                base.host = globalThis.location.hostname;
+            }
+            if (typeof globalThis.navigator !== 'undefined') {
+                base.user_agent = globalThis.navigator.userAgent;
+            }
+        }
+    }
+    catch {
+        // ignore
+    }
+    try {
+        if (typeof process !== 'undefined') {
+            base.pid = process.pid;
+        }
+    }
+    catch {
+        // ignore
+    }
+    return base;
+};
+const normalizeError = (error) => {
+    if (!error) {
+        return undefined;
+    }
+    if (error instanceof Error) {
+        return {
+            type: error.name,
+            message: error.message,
+            stacktrace: error.stack,
+        };
+    }
+    if (typeof error === 'object') {
+        return { ...error };
+    }
+    return {
+        type: 'Error',
+        message: String(error),
+    };
+};
+const shouldLog = (requestedLevel, currentLevel) => {
+    if (currentLevel === 'silent') {
+        return false;
+    }
+    const currentOrder = LOG_LEVEL_ORDER[currentLevel];
+    const requestedOrder = LOG_LEVEL_ORDER[requestedLevel];
+    return requestedOrder <= currentOrder;
+};
+const buildPayload = (name, level, message, defaultMetadata, extra, verbosity) => {
+    const payload = {
+        timestamp: new Date().toISOString(),
+        message,
+    };
+    if (verbosity >= 1 && extra) {
+        if (extra.module) {
+            payload.module = extra.module;
+        }
+        if (extra.function) {
+            payload.function = extra.function;
+        }
+    }
+    if (verbosity >= 2) {
+        if (extra?.duration_ms !== undefined) {
+            payload.duration_ms = extra.duration_ms;
+        }
+        if (extra?.event) {
+            payload.event = extra.event;
+        }
+        if (extra?.error) {
+            payload.error = normalizeError(extra.error);
+        }
+    }
+    if (verbosity >= 3) {
+        payload.level = level.toUpperCase();
+        payload.name = name;
+        const baseMetadata = resolveBaseMetadata();
+        const mergedMetadata = {
+            ...baseMetadata,
+            ...(defaultMetadata || {}),
+            ...(extra?.metadata || {}),
+        };
+        if (Object.keys(mergedMetadata).length > 0) {
+            payload.metadata = mergedMetadata;
+        }
+    }
+    const restKeys = ['module', 'function', 'event', 'duration_ms', 'error', 'metadata'];
+    if (extra) {
+        Object.entries(extra).forEach(([key, value]) => {
+            if (!restKeys.includes(key) && value !== undefined) {
+                payload[key] = value;
+            }
+        });
+    }
+    return payload;
+};
+const consoleWrite = (consoleLevel, name, level, message, payload) => {
+    if (typeof console === 'undefined' || typeof console[consoleLevel] !== 'function') {
+        return;
+    }
+    const prefix = `${level.toUpperCase()}: ${name} || ${message}`;
+    console[consoleLevel](prefix, payload);
+};
+const setupLogger = (nameOrOptions, level, defaultMetadata) => {
+    const options = typeof nameOrOptions === 'string'
+        ? {
+            name: nameOrOptions,
+            level,
+            defaultMetadata,
+        }
+        : nameOrOptions;
+    const loggerName = options.name || DEFAULT_LOGGER_NAME;
+    let currentLevel = resolveDefaultLogLevel(options.level);
+    const loggerDefaultMetadata = options.defaultMetadata;
+    const verbosity = resolveVerbosity();
+    const log = (requestedLevel, message, extra) => {
+        if (!shouldLog(requestedLevel, currentLevel)) {
+            return;
+        }
+        const payload = buildPayload(loggerName, requestedLevel, message, loggerDefaultMetadata, extra, verbosity);
+        consoleWrite(LEVEL_TO_CONSOLE[requestedLevel], loggerName, requestedLevel, message, payload);
+    };
+    return {
+        getLevel: () => currentLevel,
+        setLevel: (nextLevel) => {
+            currentLevel = nextLevel;
+        },
+        debug: (message, extra) => log('debug', message, extra),
+        info: (message, extra) => log('info', message, extra),
+        warn: (message, extra) => log('warn', message, extra),
+        error: (message, extra) => log('error', message, extra),
+        exception: (message, error, extra) => {
+            log('error', message, {
+                ...extra,
+                error,
+                event: extra?.event || 'exception',
+            });
+        },
+    };
+};
+const buildLoggerExtra = (metadata) => ({
+    metadata,
+});
+const logStartEnd = (logger) => (fn) => async (...args) => {
+    const start = Date.now();
+    const functionName = fn.name || 'anonymous';
+    logger.debug('START', { module: 'logStartEnd', function: functionName, event: 'start' });
+    try {
+        const result = await fn(...args);
+        const duration = Date.now() - start;
+        logger.info('END', { module: 'logStartEnd', function: functionName, event: 'end', duration_ms: duration });
+        return result;
+    }
+    catch (error) {
+        const duration = Date.now() - start;
+        logger.exception('EXCEPTION', error, {
+            module: 'logStartEnd',
+            function: functionName,
+            duration_ms: duration,
+        });
+        throw error;
+    }
+};
+
 /**
  * Pagination-related types and classes
  */
+const paginationLogger = setupLogger('FinaticClientSDK.Pagination', undefined, {
+    codebase: 'FinaticClientSDK',
+});
+const buildPaginationExtra = (functionName, metadata) => ({
+    module: 'PaginatedResult',
+    function: functionName,
+    ...(metadata ? buildLoggerExtra(metadata) : {}),
+});
 class PaginatedResult {
     constructor(data, paginationInfo, navigationCallback) {
         this.data = data;
@@ -36,7 +314,10 @@ class PaginatedResult {
             return await this.navigationCallback(this.metadata.nextOffset, this.metadata.limit);
         }
         catch (error) {
-            console.error('Error fetching next page:', error);
+            paginationLogger.exception('Error fetching next page', error, buildPaginationExtra('nextPage', {
+                next_offset: this.metadata.nextOffset,
+                limit: this.metadata.limit,
+            }));
             return null;
         }
     }
@@ -49,7 +330,10 @@ class PaginatedResult {
             return await this.navigationCallback(previousOffset, this.metadata.limit);
         }
         catch (error) {
-            console.error('Error fetching previous page:', error);
+            paginationLogger.exception('Error fetching previous page', error, buildPaginationExtra('previousPage', {
+                previous_offset: previousOffset,
+                limit: this.metadata.limit,
+            }));
             return null;
         }
     }
@@ -62,7 +346,11 @@ class PaginatedResult {
             return await this.navigationCallback(offset, this.metadata.limit);
         }
         catch (error) {
-            console.error('Error fetching page:', pageNumber, error);
+            paginationLogger.exception('Error fetching page', error, buildPaginationExtra('goToPage', {
+                page_number: pageNumber,
+                offset,
+                limit: this.metadata.limit,
+            }));
             return null;
         }
     }
@@ -74,7 +362,9 @@ class PaginatedResult {
             return await this.navigationCallback(0, this.metadata.limit);
         }
         catch (error) {
-            console.error('Error fetching first page:', error);
+            paginationLogger.exception('Error fetching first page', error, buildPaginationExtra('firstPage', {
+                limit: this.metadata.limit,
+            }));
             return null;
         }
     }
@@ -96,7 +386,9 @@ class PaginatedResult {
             return await findLast(this);
         }
         catch (error) {
-            console.error('Error fetching last page:', error);
+            paginationLogger.exception('Error fetching last page', error, buildPaginationExtra('lastPage', {
+                limit: this.metadata.limit,
+            }));
             return null;
         }
     }
@@ -207,6 +499,13 @@ class TradingNotEnabledError extends ApiError {
 
 // Supabase import removed - SDK no longer depends on Supabase
 class ApiClient {
+    buildLoggerExtra(functionName, metadata) {
+        return {
+            module: 'ApiClient',
+            function: functionName,
+            ...(metadata ? buildLoggerExtra(metadata) : {}),
+        };
+    }
     constructor(baseUrl, deviceInfo) {
         this.currentSessionState = null;
         this.currentSessionId = null;
@@ -215,6 +514,9 @@ class ApiClient {
         // Session and company context
         this.companyId = null;
         this.csrfToken = null;
+        this.logger = setupLogger('FinaticClientSDK.ApiClient', undefined, {
+            codebase: 'FinaticClientSDK',
+        });
         this.baseUrl = baseUrl;
         this.deviceInfo = deviceInfo;
         // Ensure baseUrl doesn't end with a slash
@@ -335,29 +637,28 @@ class ApiClient {
                 safariSafeHeaders[normalizedKey] = normalizedValue;
             }
         });
-        // Debug logging for development
-        if (typeof window !== 'undefined' && window.location.hostname === 'localhost') {
-            console.log('Request to:', url.toString());
-            console.log('Safari-safe headers:', safariSafeHeaders);
-            console.log('Browser:', navigator.userAgent);
-            console.log('Session ID:', this.currentSessionId);
-            console.log('Company ID:', this.companyId);
-            console.log('CSRF Token:', this.csrfToken);
-        }
+        this.logger.debug('Dispatching API request', this.buildLoggerExtra('request', {
+            url: url.toString(),
+            method: options.method,
+            has_body: Boolean(options.body),
+        }));
         const response = await fetch(url.toString(), {
             method: options.method,
             headers: safariSafeHeaders,
             body: options.body ? JSON.stringify(options.body) : undefined,
         });
-        // Debug logging for response
-        if (typeof window !== 'undefined' && window.location.hostname === 'localhost') {
-            console.log('Response status:', response.status);
-            console.log('Response headers:', Object.fromEntries(response.headers.entries()));
-            console.log('Request was made with headers:', safariSafeHeaders);
-        }
+        this.logger.debug('Received API response', this.buildLoggerExtra('request', {
+            url: url.toString(),
+            status: response.status,
+        }));
         if (!response.ok) {
             const error = await response.json();
-            throw this.handleError(response.status, error);
+            const apiError = this.handleError(response.status, error);
+            this.logger.exception('API request failed', apiError, this.buildLoggerExtra('request', {
+                url: url.toString(),
+                status: response.status,
+            }));
+            throw apiError;
         }
         const data = await response.json();
         // Check if the response has a success field and it's false
@@ -368,11 +669,21 @@ class ApiClient {
                 // Add context that this is an order-related error
                 data._isOrderError = true;
             }
-            throw this.handleError(data.status_code || 500, data);
+            const apiError = this.handleError(data.status_code || 500, data);
+            this.logger.exception('API response indicated failure', apiError, this.buildLoggerExtra('request', {
+                url: url.toString(),
+                status: data.status_code || 500,
+            }));
+            throw apiError;
         }
         // 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);
+            const apiError = this.handleError(data.status_code, data);
+            this.logger.exception('API status code error', apiError, this.buildLoggerExtra('request', {
+                url: url.toString(),
+                status: data.status_code,
+            }));
+            throw apiError;
         }
         // Check if the response has errors field with content
         if (data &&
@@ -381,7 +692,12 @@ class ApiClient {
             data.errors &&
             Array.isArray(data.errors) &&
             data.errors.length > 0) {
-            throw this.handleError(data.status_code || 500, data);
+            const apiError = this.handleError(data.status_code || 500, data);
+            this.logger.exception('API response contained errors', apiError, this.buildLoggerExtra('request', {
+                url: url.toString(),
+                status: data.status_code || 500,
+            }));
+            throw apiError;
         }
         return data;
     }
@@ -1411,8 +1727,160 @@ 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,
+        });
+    }
 }
 
+const eventsLogger = setupLogger('FinaticClientSDK.Events', undefined, {
+    codebase: 'FinaticClientSDK',
+});
 class EventEmitter {
     constructor() {
         this.events = new Map();
@@ -1442,7 +1910,13 @@ class EventEmitter {
                     callback(...args);
                 }
                 catch (error) {
-                    console.error(`Error in event handler for ${event}:`, error);
+                    eventsLogger.exception('Error in event handler', error, {
+                        module: 'EventEmitter',
+                        function: 'emit',
+                        ...buildLoggerExtra({
+                            event_name: event,
+                        }),
+                    });
                 }
             });
         }
@@ -1463,6 +1937,9 @@ class EventEmitter {
     }
 }
 
+const portalLogger = setupLogger('FinaticClientSDK.PortalUI', undefined, {
+    codebase: 'FinaticClientSDK',
+});
 class PortalUI {
     constructor(portalUrl) {
         this.iframe = null;
@@ -1471,10 +1948,18 @@ class PortalUI {
         this.sessionId = null;
         this.portalOrigin = null;
         this.originalBodyStyle = null;
+        this.logger = portalLogger;
         this.createContainer();
     }
+    buildLoggerExtra(functionName, metadata) {
+        return {
+            module: 'PortalUI',
+            function: functionName,
+            ...(metadata ? buildLoggerExtra(metadata) : {}),
+        };
+    }
     createContainer() {
-        console.debug('[PortalUI] Creating container and iframe');
+        this.logger.debug('Creating portal container and iframe', this.buildLoggerExtra('createContainer'));
         this.container = document.createElement('div');
         this.container.style.cssText = `
             position: fixed;
@@ -1521,7 +2006,7 @@ class PortalUI {
         this.iframe.contentDocument?.head.appendChild(meta);
         this.container.appendChild(this.iframe);
         document.body.appendChild(this.container);
-        console.debug('[PortalUI] Container and iframe created successfully');
+        this.logger.debug('Portal container and iframe created successfully', this.buildLoggerExtra('createContainer'));
     }
     /**
      * Lock background scrolling by setting overflow: hidden on body
@@ -1535,7 +2020,7 @@ class PortalUI {
             document.body.style.position = 'fixed';
             document.body.style.width = '100%';
             document.body.style.top = `-${window.scrollY}px`;
-            console.debug('[PortalUI] Background scroll locked');
+            this.logger.debug('Background scroll locked', this.buildLoggerExtra('lockScroll'));
         }
     }
     /**
@@ -1551,7 +2036,7 @@ class PortalUI {
             document.body.style.top = '';
             window.scrollTo(0, parseInt(scrollY || '0') * -1);
             this.originalBodyStyle = null;
-            console.debug('[PortalUI] Background scroll unlocked');
+            this.logger.debug('Background scroll unlocked', this.buildLoggerExtra('unlockScroll'));
         }
     }
     show(url, sessionId, options = {}) {
@@ -1593,11 +2078,17 @@ class PortalUI {
     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);
+            this.logger.warn('Received message from unauthorized origin', this.buildLoggerExtra('handleMessage', {
+                received_origin: event.origin,
+                expected_origin: this.portalOrigin || 'unknown',
+            }));
             return;
         }
         const { type, userId, access_token, refresh_token, error, height, data } = event.data;
-        console.log('[PortalUI] Received message:', event.data);
+        this.logger.debug('Received portal message', this.buildLoggerExtra('handleMessage', {
+            message_type: type,
+            has_data: Boolean(data),
+        }));
         switch (type) {
             case 'portal-success': {
                 // Handle both direct userId and data.userId formats
@@ -1635,36 +2126,50 @@ class PortalUI {
                 this.handleClose();
                 break;
             default:
-                console.warn('[PortalUI] Received unhandled message type:', type);
+                this.logger.warn('Received unhandled message type', this.buildLoggerExtra('handleMessage', {
+                    message_type: type,
+                }));
         }
     }
     handlePortalSuccess(userId, tokens) {
         if (!userId) {
-            console.error('[PortalUI] Missing userId in portal-success message');
+            this.logger.error('Missing userId in portal-success message', this.buildLoggerExtra('handlePortalSuccess'));
             return;
         }
-        console.log('[PortalUI] Portal success - User connected:', userId);
+        this.logger.info('Portal success - user connected', this.buildLoggerExtra('handlePortalSuccess', {
+            user_id_present: Boolean(userId),
+            tokens_provided: Boolean(tokens?.access_token && tokens?.refresh_token),
+        }));
         if (tokens?.access_token && tokens?.refresh_token) {
-            console.log('[PortalUI] Tokens received for user:', userId);
+            this.logger.debug('Tokens received for user', this.buildLoggerExtra('handlePortalSuccess', {
+                tokens_provided: true,
+            }));
         }
         // Pass userId to parent (SDK will handle tokens internally)
         this.options?.onSuccess?.(userId, tokens);
     }
     handlePortalError(error) {
-        console.error('[PortalUI] Portal error:', error);
+        this.logger.error('Portal error received', this.buildLoggerExtra('handlePortalError', {
+            error_message: error,
+        }));
         this.options?.onError?.(new Error(error || 'Unknown portal error'));
     }
     handlePortalClose() {
-        console.log('[PortalUI] Portal closed by user');
+        this.logger.info('Portal closed by user', this.buildLoggerExtra('handlePortalClose'));
         this.options?.onClose?.();
         this.hide();
     }
     handleGenericEvent(data) {
         if (!data || !data.type) {
-            console.warn('[PortalUI] Invalid event data:', data);
+            this.logger.warn('Invalid event data received', this.buildLoggerExtra('handleGenericEvent', {
+                has_type: Boolean(data?.type),
+            }));
             return;
         }
-        console.log('[PortalUI] Generic event received:', data.type, data.data);
+        this.logger.debug('Generic event received', this.buildLoggerExtra('handleGenericEvent', {
+            event_type: data.type,
+            payload_present: Boolean(data.data),
+        }));
         // Emit the event to be handled by the SDK
         // This will be implemented in FinaticConnect
         if (this.options?.onEvent) {
@@ -1673,24 +2178,28 @@ class PortalUI {
     }
     handleSuccess(userId) {
         if (!userId) {
-            console.error('[PortalUI] Missing required fields in success message');
+            this.logger.error('Missing required fields in success message', this.buildLoggerExtra('handleSuccess'));
             return;
         }
         // Pass userId to parent
         this.options?.onSuccess?.(userId);
     }
     handleError(error) {
-        console.error('[PortalUI] Received error:', error);
+        this.logger.error('Received portal error message', this.buildLoggerExtra('handleError', {
+            error_message: error,
+        }));
         this.options?.onError?.(new Error(error || 'Unknown error'));
     }
     handleClose() {
-        console.log('[PortalUI] Received close message');
+        this.logger.debug('Received close message', this.buildLoggerExtra('handleClose'));
         this.options?.onClose?.();
         this.hide();
     }
     handleResize(height) {
         if (height && this.iframe) {
-            console.log('[PortalUI] Received resize message:', height);
+            this.logger.debug('Received resize message', this.buildLoggerExtra('handleResize', {
+                height,
+            }));
             this.iframe.style.height = `${height}px`;
         }
     }
@@ -2518,11 +3027,21 @@ class MockDataProvider {
     }
 }
 
+const mockApiLogger = setupLogger('FinaticClientSDK.MockApiClient', undefined, {
+    codebase: 'FinaticClientSDK',
+});
 /**
  * Mock API Client that implements the same interface as the real ApiClient
  * but returns mock data instead of making HTTP requests
  */
 class MockApiClient {
+    buildLoggerExtra(functionName, metadata) {
+        return {
+            module: 'MockApiClient',
+            function: functionName,
+            ...(metadata ? buildLoggerExtra(metadata) : {}),
+        };
+    }
     constructor(baseUrl, deviceInfo, mockConfig) {
         this.currentSessionState = null;
         this.currentSessionId = null;
@@ -2534,16 +3053,21 @@ class MockApiClient {
         // Session and company context
         this.companyId = null;
         this.csrfToken = null;
+        this.logger = mockApiLogger;
         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)');
+            this.logger.info('Using mock API client (API only, real portal)', this.buildLoggerExtra('constructor', {
+                mock_api_only: true,
+            }));
         }
         else {
-            console.log('🔧 Finatic SDK: Using MOCK API Client');
+            this.logger.info('Using mock API client', this.buildLoggerExtra('constructor', {
+                mock_api_only: false,
+            }));
         }
     }
     /**
@@ -2737,14 +3261,12 @@ class MockApiClient {
     async placeBrokerOrder(params, extras = {}, connection_id) {
         await this.getValidAccessToken();
         // Debug logging
-        console.log('MockApiClient.placeBrokerOrder Debug:', {
-            params,
-            tradingContext: this.tradingContext,
-            paramsBroker: params.broker,
-            contextBroker: this.tradingContext.broker,
-            paramsAccountNumber: params.accountNumber,
-            contextAccountNumber: this.tradingContext.accountNumber,
-        });
+        this.logger.debug('placeBrokerOrder parameters', this.buildLoggerExtra('placeBrokerOrder', {
+            has_params_broker: Boolean(params.broker),
+            has_context_broker: Boolean(this.tradingContext.broker),
+            has_params_account: Boolean(params.accountNumber),
+            has_context_account: Boolean(this.tradingContext.accountNumber),
+        }));
         const fullParams = {
             broker: (params.broker || this.tradingContext.broker) ||
                 (() => {
@@ -2765,7 +3287,13 @@ class MockApiClient {
             stopPrice: params.stopPrice,
             order_id: params.order_id,
         };
-        console.log('MockApiClient.placeBrokerOrder Debug - Final params:', fullParams);
+        this.logger.debug('placeBrokerOrder normalized parameters', this.buildLoggerExtra('placeBrokerOrder', {
+            broker: fullParams.broker,
+            account_number_present: Boolean(fullParams.accountNumber),
+            symbol: fullParams.symbol,
+            order_type: fullParams.orderType,
+            asset_type: fullParams.assetType,
+        }));
         return this.mockDataProvider.mockPlaceOrder(fullParams);
     }
     async cancelBrokerOrder(orderId, broker, extras = {}, connection_id) {
@@ -2803,14 +3331,18 @@ class MockApiClient {
         this.tradingContext.accountId = undefined;
     }
     setAccount(accountNumber, accountId) {
-        console.log('MockApiClient.setAccount Debug:', {
-            accountNumber,
-            accountId,
-            previousContext: { ...this.tradingContext },
-        });
+        this.logger.debug('setAccount invoked', this.buildLoggerExtra('setAccount', {
+            account_number: accountNumber,
+            account_id_present: Boolean(accountId),
+            had_existing_account: Boolean(this.tradingContext.accountNumber),
+        }));
         this.tradingContext.accountNumber = accountNumber;
         this.tradingContext.accountId = accountId;
-        console.log('MockApiClient.setAccount Debug - Updated context:', this.tradingContext);
+        this.logger.debug('setAccount updated context', this.buildLoggerExtra('setAccount', {
+            broker: this.tradingContext.broker,
+            account_number_present: Boolean(this.tradingContext.accountNumber),
+            account_id_present: Boolean(this.tradingContext.accountId),
+        }));
     }
     // Stock convenience methods
     async placeStockMarketOrder(symbol, orderQty, action, broker, accountNumber, extras = {}) {
@@ -4592,6 +5124,14 @@ const portalThemePresets = {
     stockAlgos: stockAlgosTheme,
 };
 
+const themeLogger = setupLogger('FinaticClientSDK.ThemeUtils', undefined, {
+    codebase: 'FinaticClientSDK',
+});
+const buildThemeExtra = (functionName, metadata) => ({
+    module: 'ThemeUtils',
+    function: functionName,
+    ...(metadata ? buildLoggerExtra(metadata) : {}),
+});
 /**
  * Generate a portal URL with theme parameters
  * @param baseUrl The base portal URL
@@ -4617,7 +5157,10 @@ function generatePortalThemeURL(baseUrl, theme) {
         return url.toString();
     }
     catch (error) {
-        console.error('Failed to generate theme URL:', error);
+        themeLogger.exception('Failed to generate theme URL', error, buildThemeExtra('generatePortalThemeURL', {
+            base_url: baseUrl,
+            has_theme: Boolean(theme),
+        }));
         return baseUrl;
     }
 }
@@ -4646,7 +5189,10 @@ function appendThemeToURL(baseUrl, theme) {
         return url.toString();
     }
     catch (error) {
-        console.error('Failed to append theme to URL:', error);
+        themeLogger.exception('Failed to append theme to URL', error, buildThemeExtra('appendThemeToURL', {
+            base_url: baseUrl,
+            has_theme: Boolean(theme),
+        }));
         return baseUrl;
     }
 }
@@ -4701,7 +5247,7 @@ function validateCustomTheme(theme) {
         return true;
     }
     catch (error) {
-        console.error('Theme validation error:', error);
+        themeLogger.exception('Theme validation error', error, buildThemeExtra('validateCustomTheme'));
         return false;
     }
 }
@@ -4714,7 +5260,9 @@ function validateCustomTheme(theme) {
 function createCustomThemeFromPreset(preset, modifications) {
     const baseTheme = getThemePreset(preset);
     if (!baseTheme) {
-        console.error(`Preset theme '${preset}' not found`);
+        themeLogger.warn('Preset theme not found', buildThemeExtra('createCustomThemeFromPreset', {
+            preset,
+        }));
         return null;
     }
     return {
@@ -4726,6 +5274,14 @@ function createCustomThemeFromPreset(preset, modifications) {
 /**
  * Broker filtering utility functions
  */
+const brokerLogger = setupLogger('FinaticClientSDK.BrokerUtils', undefined, {
+    codebase: 'FinaticClientSDK',
+});
+const buildBrokerExtra = (functionName, metadata) => ({
+    module: 'BrokerUtils',
+    function: functionName,
+    ...(metadata ? buildLoggerExtra(metadata) : {}),
+});
 // Supported broker names and their corresponding IDs (including aliases)
 const SUPPORTED_BROKERS = {
     'alpaca': 'alpaca',
@@ -4768,7 +5324,9 @@ function appendBrokerFilterToURL(baseUrl, brokerNames) {
         const url = new URL(baseUrl);
         const { brokerIds, warnings } = convertBrokerNamesToIds(brokerNames);
         // Log warnings for unsupported broker names
-        warnings.forEach(warning => console.warn(`[FinaticConnect] ${warning}`));
+        warnings.forEach(warning => brokerLogger.warn('Unsupported broker name provided', buildBrokerExtra('appendBrokerFilterToURL', {
+            warning,
+        })));
         // Only add broker filter if we have valid broker IDs
         if (brokerIds.length > 0) {
             const encodedBrokers = btoa(JSON.stringify(brokerIds));
@@ -4777,12 +5335,30 @@ function appendBrokerFilterToURL(baseUrl, brokerNames) {
         return url.toString();
     }
     catch (error) {
-        console.error('Failed to append broker filter to URL:', error);
+        brokerLogger.exception('Failed to append broker filter to URL', error, buildBrokerExtra('appendBrokerFilterToURL', {
+            base_url: baseUrl,
+            brokers_count: brokerNames?.length ?? 0,
+        }));
         return baseUrl;
     }
 }
 
+const finaticConnectLogger = setupLogger('FinaticClientSDK.FinaticConnect', undefined, {
+    codebase: 'FinaticClientSDK',
+});
+const makeFinaticConnectExtra = (functionName, metadata) => ({
+    module: 'FinaticConnect',
+    function: functionName,
+    ...(metadata ? buildLoggerExtra(metadata) : {}),
+});
 class FinaticConnect extends EventEmitter {
+    buildLoggerExtra(functionName, metadata) {
+        return {
+            module: 'FinaticConnect',
+            function: functionName,
+            ...(metadata ? buildLoggerExtra(metadata) : {}),
+        };
+    }
     constructor(options, deviceInfo) {
         super();
         this.userToken = null;
@@ -4797,6 +5373,7 @@ class FinaticConnect extends EventEmitter {
         this.SESSION_VALIDATION_TIMEOUT = 1000 * 30; // 30 seconds
         this.SESSION_REFRESH_BUFFER_HOURS = 16; // Refresh session at 16 hours
         this.sessionStartTime = null;
+        this.logger = finaticConnectLogger;
         this.options = options;
         this.baseUrl = options.baseUrl || 'https://api.finatic.dev';
         this.apiClient = MockFactory.createApiClient(this.baseUrl, deviceInfo);
@@ -4849,7 +5426,7 @@ class FinaticConnect extends EventEmitter {
     async linkUserToSession(userId) {
         try {
             if (!this.sessionId) {
-                console.error('No session ID available for user linking');
+                this.logger.error('No session ID available for user linking', this.buildLoggerExtra('linkUserToSession'));
                 return false;
             }
             // Call API endpoint to authenticate user with session
@@ -4861,14 +5438,20 @@ class FinaticConnect extends EventEmitter {
                 },
             });
             if (response.error) {
-                console.error('Failed to link user to session:', response.error);
+                this.logger.error('Failed to link user to session', {
+                    ...this.buildLoggerExtra('linkUserToSession', {
+                        session_id: this.sessionId,
+                        user_id: userId,
+                    }),
+                    error: response.error,
+                });
                 return false;
             }
-            console.log('User linked to session successfully');
+            this.logger.info('User linked to session successfully', this.buildLoggerExtra('linkUserToSession', { session_id: this.sessionId, user_id: userId }));
             return true;
         }
         catch (error) {
-            console.error('Error linking user to session:', error);
+            this.logger.exception('Error linking user to session', error, this.buildLoggerExtra('linkUserToSession', { session_id: this.sessionId, user_id: userId }));
             return false;
         }
     }
@@ -5013,7 +5596,7 @@ class FinaticConnect extends EventEmitter {
         // Safari-specific fix: Clear instance if it exists but has no valid session
         // This prevents stale instances from interfering with new requests
         if (FinaticConnect.instance && !FinaticConnect.instance.sessionId) {
-            console.log('[FinaticConnect] Clearing stale instance for Safari compatibility');
+            finaticConnectLogger.debug('Clearing stale instance for Safari compatibility', makeFinaticConnectExtra('init'));
             FinaticConnect.instance = null;
         }
         if (!FinaticConnect.instance) {
@@ -5065,7 +5648,7 @@ class FinaticConnect extends EventEmitter {
                         FinaticConnect.instance.emit('success', normalizedUserId);
                     }
                     else {
-                        console.warn('Failed to link user to session during initialization');
+                        finaticConnectLogger.warn('Failed to link user to session during initialization', makeFinaticConnectExtra('init', { user_id: normalizedUserId }));
                     }
                 }
                 catch (error) {
@@ -5095,7 +5678,7 @@ class FinaticConnect extends EventEmitter {
             // Try to link user to session
             const linked = await this.linkUserToSession(userId);
             if (!linked) {
-                console.warn('Failed to link user to session during initialization');
+                this.logger.warn('Failed to link user to session during initialization', this.buildLoggerExtra('initializeWithUser', { user_id: userId }));
                 // Don't throw error, just continue without authentication
                 return;
             }
@@ -5183,7 +5766,7 @@ class FinaticConnect extends EventEmitter {
                         // 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');
+                            this.logger.warn('Failed to link user to session, continuing with authentication', this.buildLoggerExtra('openPortal.onSuccess', { user_id: userId }));
                         }
                         // Emit portal success event
                         this.emit('portal:success', userId);
@@ -5217,7 +5800,13 @@ class FinaticConnect extends EventEmitter {
                     options?.onClose?.();
                 },
                 onEvent: (type, data) => {
-                    console.log('[FinaticConnect] Portal event received:', type, data);
+                    this.logger.debug('Portal event received', {
+                        ...this.buildLoggerExtra('openPortal.onEvent', {
+                            event_type: type,
+                            payload_present: Boolean(data),
+                        }),
+                        event: 'portal-event',
+                    });
                     // Emit generic event
                     this.emit('event', type, data);
                     // Call the event callback
@@ -5728,7 +6317,7 @@ class FinaticConnect extends EventEmitter {
         this.sessionKeepAliveInterval = setInterval(() => {
             this.validateSessionKeepAlive();
         }, this.SESSION_KEEP_ALIVE_INTERVAL);
-        console.log('[FinaticConnect] Session keep-alive started (5-minute intervals)');
+        this.logger.debug('Session keep-alive started', this.buildLoggerExtra('startSessionKeepAlive', { interval_ms: this.SESSION_KEEP_ALIVE_INTERVAL }));
     }
     /**
      * Stop the session keep-alive mechanism
@@ -5737,7 +6326,7 @@ class FinaticConnect extends EventEmitter {
         if (this.sessionKeepAliveInterval) {
             clearInterval(this.sessionKeepAliveInterval);
             this.sessionKeepAliveInterval = null;
-            console.log('[FinaticConnect] Session keep-alive stopped');
+            this.logger.debug('Session keep-alive stopped', this.buildLoggerExtra('stopSessionKeepAlive'));
         }
     }
     /**
@@ -5745,22 +6334,22 @@ class FinaticConnect extends EventEmitter {
      */
     async validateSessionKeepAlive() {
         if (!this.sessionId || !(await this.isAuthenticated())) {
-            console.log('[FinaticConnect] Session keep-alive skipped - no active session');
+            this.logger.debug('Session keep-alive skipped - no active session', this.buildLoggerExtra('validateSessionKeepAlive'));
             return;
         }
         try {
-            console.log('[FinaticConnect] Validating session for keep-alive...');
+            this.logger.debug('Validating session for keep-alive', this.buildLoggerExtra('validateSessionKeepAlive', { session_id: this.sessionId }));
             // Check if we need to refresh the session (at 16 hours)
             if (this.shouldRefreshSession()) {
                 await this.refreshSessionAutomatically();
                 return;
             }
             // Session keep-alive - assume session is active if we have a session ID
-            console.log('[FinaticConnect] Session keep-alive successful');
+            this.logger.debug('Session keep-alive successful', this.buildLoggerExtra('validateSessionKeepAlive', { session_id: this.sessionId }));
             this.currentSessionState = 'active';
         }
         catch (error) {
-            console.warn('[FinaticConnect] Session keep-alive error:', error);
+            this.logger.exception('Session keep-alive error', error, this.buildLoggerExtra('validateSessionKeepAlive', { session_id: this.sessionId }));
             // Don't throw errors during keep-alive - just log them
         }
     }
@@ -5774,12 +6363,16 @@ class FinaticConnect extends EventEmitter {
         const sessionAgeHours = (Date.now() - this.sessionStartTime) / (1000 * 60 * 60);
         const hoursUntilRefresh = this.SESSION_REFRESH_BUFFER_HOURS - sessionAgeHours;
         if (hoursUntilRefresh <= 0) {
-            console.log(`[FinaticConnect] Session is ${sessionAgeHours.toFixed(1)} hours old - triggering refresh`);
+            this.logger.info('Session age threshold exceeded - triggering refresh', this.buildLoggerExtra('shouldRefreshSession', {
+                session_age_hours: Number(sessionAgeHours.toFixed(1)),
+            }));
             return true;
         }
         // Log when refresh will occur (every 5 minutes during keep-alive)
         if (hoursUntilRefresh <= 1) {
-            console.log(`[FinaticConnect] Session will refresh in ${hoursUntilRefresh.toFixed(1)} hours`);
+            this.logger.debug('Session refresh scheduled', this.buildLoggerExtra('shouldRefreshSession', {
+                hours_until_refresh: Number(hoursUntilRefresh.toFixed(1)),
+            }));
         }
         return false;
     }
@@ -5788,25 +6381,34 @@ class FinaticConnect extends EventEmitter {
      */
     async refreshSessionAutomatically() {
         if (!this.sessionId) {
-            console.warn('[FinaticConnect] Cannot refresh session - no session ID');
+            this.logger.warn('Cannot refresh session - missing session ID', this.buildLoggerExtra('refreshSessionAutomatically'));
             return;
         }
         try {
-            console.log('[FinaticConnect] Automatically refreshing session (16+ hours old)...');
+            this.logger.info('Automatically refreshing session', this.buildLoggerExtra('refreshSessionAutomatically', {
+                session_id: this.sessionId,
+            }));
             const response = await this.apiClient.refreshSession();
             if (response.success) {
-                console.log('[FinaticConnect] Session automatically refreshed successfully');
-                console.log('[FinaticConnect] New session expires at:', response.response_data.expires_at);
+                this.logger.info('Session automatically refreshed successfully', this.buildLoggerExtra('refreshSessionAutomatically', {
+                    session_id: this.sessionId,
+                    status: response.response_data.status,
+                    expires_at: response.response_data.expires_at,
+                }));
                 this.currentSessionState = response.response_data.status;
                 // Update session start time to prevent immediate re-refresh
                 this.sessionStartTime = Date.now();
             }
             else {
-                console.warn('[FinaticConnect] Automatic session refresh failed');
+                this.logger.warn('Automatic session refresh failed', this.buildLoggerExtra('refreshSessionAutomatically', {
+                    session_id: this.sessionId,
+                }));
             }
         }
         catch (error) {
-            console.warn('[FinaticConnect] Automatic session refresh error:', error);
+            this.logger.exception('Automatic session refresh error', error, this.buildLoggerExtra('refreshSessionAutomatically', {
+                session_id: this.sessionId,
+            }));
             // Don't throw errors during automatic refresh - just log them
         }
     }
@@ -5826,7 +6428,9 @@ class FinaticConnect extends EventEmitter {
     async handleVisibilityChange() {
         // For 24-hour sessions, we don't want to complete sessions on visibility changes
         // This prevents sessions from being closed when users switch tabs or apps
-        console.log('[FinaticConnect] Page visibility changed to:', document.visibilityState);
+        this.logger.debug('Page visibility changed', this.buildLoggerExtra('handleVisibilityChange', {
+            visibility_state: document.visibilityState,
+        }));
         // Only pause keep-alive when hidden, but don't complete the session
         if (document.visibilityState === 'hidden') {
             this.stopSessionKeepAlive();
@@ -5848,7 +6452,7 @@ class FinaticConnect extends EventEmitter {
                 this.apiClient.isMockClient();
             if (isMockMode) {
                 // Mock the completion response
-                console.log('[FinaticConnect] Mock session completion for session:', sessionId);
+                this.logger.debug('Mock session completion', this.buildLoggerExtra('completeSession', { session_id: sessionId }));
                 return;
             }
             // Real API call
@@ -5859,15 +6463,18 @@ class FinaticConnect extends EventEmitter {
                 },
             });
             if (response.ok) {
-                console.log('[FinaticConnect] Session completed successfully');
+                this.logger.info('Session completed successfully', this.buildLoggerExtra('completeSession', { session_id: sessionId }));
             }
             else {
-                console.warn('[FinaticConnect] Failed to complete session:', response.status);
+                this.logger.warn('Failed to complete session', this.buildLoggerExtra('completeSession', {
+                    session_id: sessionId,
+                    response_status: response.status,
+                }));
             }
         }
         catch (error) {
             // Silent failure - don't throw errors during cleanup
-            console.warn('[FinaticConnect] Session cleanup failed:', error);
+            this.logger.exception('Session cleanup failed', error, this.buildLoggerExtra('completeSession', { session_id: sessionId }));
         }
     }
     /**
@@ -5885,6 +6492,69 @@ class FinaticConnect extends EventEmitter {
         }
         return this.apiClient.disconnectCompany(connectionId);
     }
+    /**
+     * 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) {
+        if (!(await this.isAuthenticated())) {
+            throw new AuthenticationError('User is not authenticated');
+        }
+        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');
+        }
+        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;
 
@@ -5907,9 +6577,12 @@ exports.TokenError = TokenError;
 exports.TradingNotEnabledError = TradingNotEnabledError;
 exports.ValidationError = ValidationError;
 exports.appendThemeToURL = appendThemeToURL;
+exports.buildLoggerExtra = buildLoggerExtra;
 exports.createCustomThemeFromPreset = createCustomThemeFromPreset;
 exports.generatePortalThemeURL = generatePortalThemeURL;
 exports.getThemePreset = getThemePreset;
+exports.logStartEnd = logStartEnd;
 exports.portalThemePresets = portalThemePresets;
+exports.setupLogger = setupLogger;
 exports.validateCustomTheme = validateCustomTheme;
 //# sourceMappingURL=index.js.map