@finatic/client 0.0.142 → 0.9.0

package/dist/generated/FinaticConnect.js

@@ -0,0 +1,890 @@
+"use strict";
+/**
+ * Main client class for Finatic Client SDK.
+ *
+ * This file is regenerated on each run - do not edit directly.
+ * For custom logic, extend this class or use custom wrappers.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FinaticConnect = void 0;
+const configuration_1 = require("./configuration");
+const config_1 = require("./config");
+const url_utils_1 = require("./utils/url-utils");
+const events_1 = require("./utils/events");
+const PortalUI_1 = require("./portal/PortalUI");
+const brokers_api_1 = require("./api/brokers-api");
+const session_api_1 = require("./api/session-api");
+const brokers_1 = require("./wrappers/brokers");
+const session_1 = require("./wrappers/session");
+class FinaticConnect extends events_1.EventEmitter {
+    constructor(options) {
+        super(); // Initialize EventEmitter
+        this.options = options;
+        this.config = new configuration_1.Configuration({
+            basePath: options.baseUrl || 'https://api.finatic.dev',
+        });
+        this.sdkConfig = { ...config_1.defaultConfig, ...options.sdkConfig };
+        // Initialize logger
+        try {
+            const { getLogger } = require('./utils/logger');
+            this.logger = getLogger(this.sdkConfig);
+        }
+        catch {
+            // Fallback logger for browser environments where pino might not work correctly
+            this.logger = console;
+        }
+        this.brokers = new brokers_1.BrokersWrapper(new brokers_api_1.BrokersApi(this.config), this.config, this.sdkConfig);
+        this.session = new session_1.SessionWrapper(new session_api_1.SessionApi(this.config), this.config, this.sdkConfig);
+    }
+    /**
+     * Static initialization method - creates instance and starts session.
+     * This is the recommended way to initialize the Client SDK.
+     */
+    static async init(token, userId, options) {
+        // Use console for static method logging (instance logger will be initialized in constructor)
+        const logger = console;
+        logger.debug?.('FinaticConnect.init() called', {
+            token: token ? `${token.substring(0, 20)}...` : 'missing',
+            userId,
+            hasOptions: !!options,
+        });
+        try {
+            // Access private instance via type assertion to base class
+            const baseClass = FinaticConnect;
+            // Clear instance if it exists but has no valid session (Safari compatibility)
+            if (baseClass.instance && !baseClass.instance.sessionId) {
+                logger.debug?.('Clearing existing instance without sessionId');
+                baseClass.instance = null;
+            }
+            let instance;
+            if (!baseClass.instance) {
+                logger.debug?.('Creating new FinaticConnect instance');
+                const connectOptions = {
+                    token,
+                    baseUrl: options?.baseUrl || 'https://api.finatic.dev',
+                    ...(options?.sdkConfig ? { sdkConfig: options.sdkConfig } : {}),
+                };
+                instance = new FinaticConnect(connectOptions);
+                baseClass.instance = instance;
+                // CRITICAL: Client SDK init() receives a one-time token directly (not an API key)
+                // Unlike Server SDK, Client SDK does NOT call _initSession() - it goes straight to _startSession()
+                logger.debug?.('Calling _startSession() inside init() with provided token');
+                await instance._startSession(token, userId);
+                logger.debug?.('_startSession() completed in init()');
+            }
+            else {
+                logger.debug?.('Using existing FinaticConnect instance');
+                instance = baseClass.instance;
+            }
+            // Verify session was initialized correctly
+            const sessionId = instance.getSessionId();
+            if (!sessionId) {
+                const error = new Error('Session initialization failed: startSession() did not return a session_id. ' +
+                    'Please check that the API endpoint returned a valid session response. ' +
+                    'The network call to /api/v1/session/start may have failed or returned an invalid response.');
+                logger.error?.('FinaticConnect.init() failed - no sessionId', error, {});
+                throw error;
+            }
+            logger.debug?.('FinaticConnect.init() completed successfully', { sessionId });
+            return instance;
+        }
+        catch (error) {
+            // Re-throw with more context if it's a session initialization error
+            if (error instanceof Error) {
+                if (error.message.includes('Session not initialized')) {
+                    const enhancedError = new Error(`Failed to initialize Finatic session: ${error.message}. ` +
+                        'This may indicate that startSession() was called but did not successfully create a session. ' +
+                        'Please check the API response and ensure the one-time token is valid.');
+                    logger.error?.('FinaticConnect.init() session initialization error', enhancedError, {});
+                    throw enhancedError;
+                }
+                logger.error?.('FinaticConnect.init() error', error, {});
+            }
+            // Re-throw other errors as-is
+            throw error;
+        }
+    }
+    /**
+     * Start a session with a one-time token (internal/private).
+     *
+     * Note: Client SDK does NOT use _initSession() - the token passed to init() is already a one-time token.
+     * Only Server SDKs use _initSession() to convert API keys to one-time tokens.
+     */
+    async _startSession(oneTimeToken, userId) {
+        const requestBody = userId !== undefined ? { user_id: userId } : {};
+        // Phase 2C: Use typed input object
+        const response = await this.session.startSession({
+            OneTimeToken: oneTimeToken,
+            body: requestBody,
+        });
+        // Phase 2C: Unwrap standard response structure
+        if (response.Error) {
+            throw new Error(response.Error.message || 'Failed to start session');
+        }
+        const data = response.success?.data;
+        const sessionId = data?.session_id || '';
+        const companyId = data?.company_id || '';
+        // csrf_token is not in SessionResponseData, get from response headers if available
+        const csrfToken = data?.csrf_token || '';
+        if (sessionId && companyId) {
+            this.setSessionContext(sessionId, companyId, csrfToken);
+        }
+        return { session_id: sessionId, company_id: companyId };
+    }
+    /**
+     * Get portal URL with optional theme and broker filters.
+     * This is where URL manipulation happens (not in session wrapper).
+     * Returns the URL - app can use it as needed.
+     *
+     * Note: For Client SDK, use openPortal() to open in iframe directly.
+     */
+    async getPortalUrl(options) {
+        if (!this.sessionId) {
+            throw new Error('Session not initialized. Call startSession() first.');
+        }
+        // Get raw portal URL from session wrapper
+        const response = await this.session.getPortalUrl({});
+        // Check for errors
+        if (response.Error) {
+            this.logger.error?.('Failed to get portal URL', new Error(response.Error.message), {
+                code: response.Error.code,
+                status: response.Error.status,
+            });
+            throw new Error(response.Error.message || 'Failed to get portal URL');
+        }
+        // Validate response structure
+        if (!response.success?.data?.portal_url) {
+            this.logger.error?.('Invalid portal URL response: missing data', new Error('Invalid response'), {});
+            throw new Error('Invalid portal URL response: missing portal_url');
+        }
+        let portalUrl = response.success.data.portal_url;
+        // Validate URL before manipulation
+        try {
+            new URL(portalUrl);
+        }
+        catch (error) {
+            this.logger.error?.('Invalid portal URL from API', error, { portalUrl });
+            throw new Error(`Invalid portal URL received from API: ${portalUrl}`);
+        }
+        // Append theme if provided
+        if (options?.theme) {
+            portalUrl = (0, url_utils_1.appendThemeToURL)(portalUrl, options.theme);
+        }
+        // Append broker filter if provided
+        if (options?.brokers) {
+            portalUrl = (0, url_utils_1.appendBrokerFilterToURL)(portalUrl, options.brokers);
+        }
+        // Append email if provided
+        if (options?.email) {
+            const url = new URL(portalUrl);
+            url.searchParams.set('email', options.email);
+            portalUrl = url.toString();
+        }
+        // Append mode if provided (light or dark)
+        if (options?.mode) {
+            const url = new URL(portalUrl);
+            url.searchParams.set('mode', options.mode);
+            portalUrl = url.toString();
+        }
+        // Add session ID and company ID to URL
+        const url = new URL(portalUrl);
+        if (this.sessionId) {
+            url.searchParams.set('session_id', this.sessionId);
+        }
+        if (this.companyId) {
+            url.searchParams.set('company_id', this.companyId);
+        }
+        this.logger.debug?.('Portal URL generated', { portalUrl: url.toString() });
+        return url.toString();
+    }
+    /**
+     * Open portal in iframe (Client SDK only).
+     * The portal handles user authentication and linking to session at the source of truth.
+     * This method just records the userId for SDK state.
+     */
+    async openPortal(options) {
+        if (!this.sessionId) {
+            throw new Error('Session not initialized. Call startSession() first.');
+        }
+        // Get portal URL with all parameters
+        const portalUrl = await this.getPortalUrl(options);
+        // Create portal UI if not exists
+        if (!this.portalUI) {
+            this.portalUI = new PortalUI_1.PortalUI(this.options.baseUrl || 'https://api.finatic.dev');
+        }
+        // Show portal with event handlers
+        this.portalUI.show(portalUrl, this.sessionId, {
+            onSuccess: (userId) => {
+                // Store userId for SDK state (portal already linked user to session)
+                this.userId = userId;
+                // Emit portal success event
+                this.emit('portal:success', userId);
+                // Call optional callback
+                options?.onSuccess?.(userId);
+            },
+            onError: (error) => {
+                // Emit portal error event
+                this.emit('portal:error', error);
+                // Call optional callback
+                options?.onError?.(error);
+            },
+            onClose: () => {
+                // Emit portal close event
+                this.emit('portal:close');
+                // Call optional callback
+                options?.onClose?.();
+            },
+        });
+    }
+    /**
+     * Close the portal iframe.
+     */
+    closePortal() {
+        if (this.portalUI) {
+            this.portalUI.hide();
+            this.emit('portal:close');
+        }
+    }
+    /**
+     * Get current user ID (set after portal authentication).
+     */
+    getUserId() {
+        return this.userId;
+    }
+    /**
+     * Get session user information after portal authentication.
+     */
+    async getSessionUser() {
+        if (!this.sessionId) {
+            throw new Error('Session not initialized. Call startSession() first.');
+        }
+        const response = await this.session.getSessionUser(this.sessionId);
+        return {
+            user_id: response.user_id || '',
+            company_id: response.company_id || this.companyId || '',
+            token_type: response.token_type || 'Bearer',
+        };
+    }
+    /**
+     * Set session context for all wrappers.
+     */
+    setSessionContext(sessionId, companyId, csrfToken) {
+        this.sessionId = sessionId;
+        this.companyId = companyId;
+        this.csrfToken = csrfToken;
+        // Update all wrappers with session context
+        this.brokers.setSessionContext(sessionId, companyId, csrfToken);
+        this.session.setSessionContext(sessionId, companyId, csrfToken);
+    }
+    /**
+     * Get current session ID.
+     */
+    getSessionId() {
+        return this.sessionId;
+    }
+    /**
+     * Get current company ID.
+     */
+    getCompanyId() {
+        return this.companyId;
+    }
+    // Phase 2C: _convertToPlainObject removed - now handled in generated methods via convertToPlainObject utility
+    /**
+     * Check if user is authenticated.
+     */
+    isAuthenticated() {
+        return !!(this.userId && this.sessionId);
+    }
+    /**
+     * Alias for isAuthenticated().
+     */
+    isAuthed() {
+        return this.isAuthenticated();
+    }
+    /**
+     * Get list of supported brokers.
+     * Phase 2C: Uses typed input objects and handles standard response structure.
+     */
+    async getBrokerList() {
+        const response = await this.brokers.getBrokers({});
+        const brokers = response.success?.data || [];
+        const baseUrl = this.config.basePath?.replace('/api/v1', '') ||
+            this.options.baseUrl?.replace('/api/v1', '') ||
+            'https://api.finatic.dev';
+        // Transform broker list to include full logo URLs
+        return brokers.map((broker) => ({
+            ...broker,
+            logo_path: broker.logo_path ? `${baseUrl}${broker.logo_path}` : '',
+        }));
+    }
+    /**
+     * Get user's broker connections.
+     * Phase 2C: Uses typed input objects and handles standard response structure.
+     */
+    async getBrokerConnections() {
+        const response = await this.brokers.listBrokerConnections({});
+        return response.success?.data || [];
+    }
+    /**
+     * Get all accounts across all pages.
+     * Phase 2C: Uses typed input objects and handles standard response structure.
+     */
+    async getAllAccounts(filter) {
+        const allData = [];
+        let offset = 0;
+        const limit = 100;
+        while (true) {
+            const response = await this.brokers.getAccounts({
+                brokerId: filter?.brokerId,
+                connectionId: filter?.connectionId,
+                accountType: filter?.accountType, // Will be coerced to enum
+                status: filter?.status, // Will be coerced to enum
+                currency: filter?.currency,
+                limit,
+                offset,
+                withMetadata: filter?.withMetadata,
+            });
+            const result = response.success?.data || [];
+            if (!result || result.length === 0)
+                break;
+            allData.push(...result);
+            if (result.length < limit)
+                break;
+            offset += limit;
+        }
+        return allData;
+    }
+    /**
+     * Get all orders across all pages.
+     * Phase 2C: Uses typed input objects and handles standard response structure.
+     */
+    async getAllOrders(filter) {
+        const allData = [];
+        let offset = 0;
+        const limit = 100;
+        while (true) {
+            const response = await this.brokers.getOrders({
+                brokerId: filter?.brokerId,
+                connectionId: filter?.connectionId,
+                accountId: filter?.accountId,
+                symbol: filter?.symbol,
+                orderStatus: filter?.orderStatus, // Will be coerced to enum
+                side: filter?.side, // Will be coerced to enum
+                assetType: filter?.assetType, // Will be coerced to enum
+                limit,
+                offset,
+                createdAfter: filter?.createdAfter,
+                createdBefore: filter?.createdBefore,
+                withMetadata: filter?.withMetadata,
+            });
+            const result = response.success?.data || [];
+            if (!result || result.length === 0)
+                break;
+            allData.push(...result);
+            if (result.length < limit)
+                break;
+            offset += limit;
+        }
+        return allData;
+    }
+    /**
+     * Get all positions across all pages.
+     * Phase 2C: Uses typed input objects and handles standard response structure.
+     */
+    async getAllPositions(filter) {
+        const allData = [];
+        let offset = 0;
+        const limit = 100;
+        while (true) {
+            const response = await this.brokers.getPositions({
+                brokerId: filter?.brokerId,
+                connectionId: filter?.connectionId,
+                accountId: filter?.accountId,
+                symbol: filter?.symbol,
+                side: filter?.side, // Will be coerced to enum
+                assetType: filter?.assetType, // Will be coerced to enum
+                positionStatus: filter?.positionStatus, // Will be coerced to enum
+                limit,
+                offset,
+                updatedAfter: filter?.updatedAfter,
+                updatedBefore: filter?.updatedBefore,
+                withMetadata: filter?.withMetadata,
+            });
+            const result = response.success?.data || [];
+            if (!result || result.length === 0)
+                break;
+            allData.push(...result);
+            if (result.length < limit)
+                break;
+            offset += limit;
+        }
+        return allData;
+    }
+    /**
+     * Get all balances across all pages.
+     * Phase 2C: Uses typed input objects and handles standard response structure.
+     */
+    async getAllBalances(filter) {
+        const allData = [];
+        let offset = 0;
+        const limit = 100;
+        while (true) {
+            const response = await this.brokers.getBalances({
+                brokerId: filter?.brokerId,
+                connectionId: filter?.connectionId,
+                accountId: filter?.accountId,
+                isEndOfDaySnapshot: filter?.isEndOfDaySnapshot,
+                limit,
+                offset,
+                balanceCreatedAfter: filter?.balanceCreatedAfter,
+                balanceCreatedBefore: filter?.balanceCreatedBefore,
+                withMetadata: filter?.withMetadata,
+            });
+            const result = response.success?.data || [];
+            if (!result || result.length === 0)
+                break;
+            allData.push(...result);
+            if (result.length < limit)
+                break;
+            offset += limit;
+        }
+        return allData;
+    }
+    /**
+     * Get paginated accounts.
+     * Phase 2C: Uses typed input objects and handles standard response structure.
+     */
+    async getAccounts(page = 1, perPage = 100, filter) {
+        const offset = (page - 1) * perPage;
+        const response = await this.brokers.getAccounts({
+            limit: perPage,
+            offset,
+        });
+        return response.success?.data || [];
+    }
+    /**
+     * Get paginated orders.
+     * Phase 2C: Uses typed input objects and handles standard response structure.
+     */
+    async getOrders(page = 1, perPage = 100, filter) {
+        const offset = (page - 1) * perPage;
+        const response = await this.brokers.getOrders({
+            symbol: filter?.symbol,
+            orderStatus: filter?.orderStatus, // Will be coerced to enum
+            side: filter?.side, // Will be coerced to enum
+            assetType: filter?.assetType, // Will be coerced to enum
+            limit: perPage,
+            offset,
+        });
+        return response.success?.data || [];
+    }
+    /**
+     * Get paginated positions.
+     * Phase 2C: Uses typed input objects and handles standard response structure.
+     */
+    async getPositions(page = 1, perPage = 100, filter) {
+        const offset = (page - 1) * perPage;
+        const response = await this.brokers.getPositions({
+            symbol: filter?.symbol,
+            side: filter?.side, // Will be coerced to enum
+            assetType: filter?.assetType, // Will be coerced to enum
+            positionStatus: filter?.positionStatus, // Will be coerced to enum
+            limit: perPage,
+            offset,
+        });
+        return response.success?.data || [];
+    }
+    /**
+     * Get paginated balances.
+     * Phase 2C: Uses typed input objects and handles standard response structure.
+     */
+    async getBalances(page = 1, perPage = 100, filter) {
+        const offset = (page - 1) * perPage;
+        const response = await this.brokers.getBalances({
+            isEndOfDaySnapshot: filter?.isEndOfDaySnapshot,
+            limit: perPage,
+            offset,
+        });
+        return response.success?.data || [];
+    }
+    /**
+     * Get only open positions.
+     * Phase 2C: Uses enum coercion (case-insensitive string matching).
+     */
+    async getOpenPositions(filter) {
+        // Phase 2C: Enum coercion happens in getAllPositions via typed input object
+        return await this.getAllPositions({ ...filter, positionStatus: 'active' });
+    }
+    /**
+     * Get only filled orders.
+     * Phase 2C: Uses enum coercion (case-insensitive string matching).
+     */
+    async getFilledOrders(filter) {
+        // Phase 2C: Enum coercion happens in getAllOrders via typed input object
+        return await this.getAllOrders({ ...filter, orderStatus: 'filled' });
+    }
+    /**
+     * Get only pending orders.
+     * Phase 2C: Uses enum coercion (case-insensitive string matching).
+     */
+    async getPendingOrders(filter) {
+        // Phase 2C: Enum coercion happens in getAllOrders via typed input object
+        return await this.getAllOrders({ ...filter, orderStatus: 'new' });
+    }
+    /**
+     * Get only active accounts.
+     * Phase 2C: Uses enum coercion (case-insensitive string matching).
+     */
+    async getActiveAccounts(filter) {
+        // Phase 2C: Enum coercion happens in getAllAccounts via typed input object
+        return await this.getAllAccounts({ ...filter, status: 'active' });
+    }
+    /**
+     * Get orders filtered by symbol.
+     */
+    async getOrdersBySymbol(symbol, filter) {
+        return await this.getAllOrders({ ...filter, symbol });
+    }
+    /**
+     * Get positions filtered by symbol.
+     */
+    async getPositionsBySymbol(symbol, filter) {
+        return await this.getAllPositions({ ...filter, symbol });
+    }
+    /**
+     * Get orders filtered by broker.
+     */
+    async getOrdersByBroker(brokerId, filter) {
+        return await this.getAllOrders({ ...filter, brokerId });
+    }
+    /**
+     * Get positions filtered by broker.
+     */
+    async getPositionsByBroker(brokerId, filter) {
+        return await this.getAllPositions({ ...filter, brokerId });
+    }
+    /**
+     * Get all order groups across all pages.
+     * Phase 2C: Uses typed input objects and handles standard response structure.
+     */
+    async getAllOrderGroups(filter) {
+        const allData = [];
+        let offset = 0;
+        const limit = 100;
+        while (true) {
+            const response = await this.brokers.getOrderGroups({
+                brokerId: filter?.brokerId,
+                connectionId: filter?.connectionId,
+                limit,
+                offset,
+                createdAfter: filter?.createdAfter,
+                createdBefore: filter?.createdBefore,
+            });
+            const result = response.success?.data || [];
+            if (!result || result.length === 0)
+                break;
+            allData.push(...result);
+            if (result.length < limit)
+                break;
+            offset += limit;
+        }
+        return allData;
+    }
+    /**
+     * Get paginated order groups.
+     * Phase 2C: Uses typed input objects and handles standard response structure.
+     */
+    async getOrderGroups(page = 1, perPage = 100, filter) {
+        const offset = (page - 1) * perPage;
+        const response = await this.brokers.getOrderGroups({
+            brokerId: filter?.brokerId,
+            connectionId: filter?.connectionId,
+            limit: perPage,
+            offset,
+            createdAfter: filter?.createdAfter,
+            createdBefore: filter?.createdBefore,
+        });
+        return response.success?.data || [];
+    }
+    /**
+     * Get all position lots across all pages.
+     * Phase 2C: Uses typed input objects and handles standard response structure.
+     */
+    async getAllPositionLots(filter) {
+        const allData = [];
+        let offset = 0;
+        const limit = 100;
+        while (true) {
+            const response = await this.brokers.getPositionLots({
+                brokerId: filter?.brokerId,
+                connectionId: filter?.connectionId,
+                accountId: filter?.accountId,
+                symbol: filter?.symbol,
+                positionId: filter?.positionId,
+                limit,
+                offset,
+            });
+            const result = response.success?.data || [];
+            if (!result || result.length === 0)
+                break;
+            allData.push(...result);
+            if (result.length < limit)
+                break;
+            offset += limit;
+        }
+        return allData;
+    }
+    /**
+     * Get paginated position lots.
+     * Phase 2C: Uses typed input objects and handles standard response structure.
+     */
+    async getPositionLots(page = 1, perPage = 100, filter) {
+        const offset = (page - 1) * perPage;
+        const response = await this.brokers.getPositionLots({
+            brokerId: filter?.brokerId,
+            connectionId: filter?.connectionId,
+            accountId: filter?.accountId,
+            symbol: filter?.symbol,
+            positionId: filter?.positionId,
+            limit: perPage,
+            offset,
+        });
+        return response.success?.data || [];
+    }
+    /**
+     * Disconnect company from broker.
+     * Phase 2C: Uses typed input objects and handles standard response structure.
+     */
+    async disconnectCompany(connectionId) {
+        if (!this.sessionId) {
+            throw new Error('Session not initialized. Call startSession() first.');
+        }
+        const response = await this.brokers.disconnectCompanyFromBroker({ connectionId });
+        return response.success?.data || null;
+    }
+    /**
+     * Get order fills for a specific order.
+     * Phase 2C: Uses typed input objects and handles standard response structure.
+     */
+    async getOrderFills(orderId, page = 1, perPage = 100, filter) {
+        if (!this.sessionId) {
+            throw new Error('Session not initialized. Call startSession() first.');
+        }
+        const offset = (page - 1) * perPage;
+        const response = await this.brokers.getOrderFills({
+            orderId,
+            connectionId: filter?.connectionId,
+            limit: perPage,
+            offset,
+        });
+        return response.success?.data || [];
+    }
+    /**
+     * Get order events for a specific order.
+     * Phase 2C: Uses typed input objects and handles standard response structure.
+     */
+    async getOrderEvents(orderId, page = 1, perPage = 100, filter) {
+        if (!this.sessionId) {
+            throw new Error('Session not initialized. Call startSession() first.');
+        }
+        const offset = (page - 1) * perPage;
+        const response = await this.brokers.getOrderEvents({
+            orderId,
+            connectionId: filter?.connectionId,
+            limit: perPage,
+            offset,
+        });
+        return response.success?.data || [];
+    }
+    /**
+     * Get position lot fills for a specific lot.
+     * Phase 2C: Uses typed input objects and handles standard response structure.
+     */
+    async getPositionLotFills(lotId, page = 1, perPage = 100, filter) {
+        if (!this.sessionId) {
+            throw new Error('Session not initialized. Call startSession() first.');
+        }
+        const offset = (page - 1) * perPage;
+        const response = await this.brokers.getPositionLotFills({
+            lotId,
+            connectionId: filter?.connectionId,
+            limit: perPage,
+            offset,
+        });
+        return response.success?.data || [];
+    }
+    /**
+     * Place a stock market order.
+     */
+    async placeStockMarketOrder(symbol, quantity, side, broker, accountNumber) {
+        const orderParams = {
+            broker: broker || 'robinhood',
+            order_type: 'Market',
+            asset_type: 'equity',
+            action: side === 'buy' ? 'Buy' : 'Sell',
+            time_in_force: 'day',
+            account_number: accountNumber !== undefined ? accountNumber : '',
+            symbol,
+            order_qty: quantity,
+        };
+        return await this.brokers.placeOrder({ body: orderParams });
+    }
+    /**
+     * Place a stock limit order.
+     */
+    async placeStockLimitOrder(symbol, quantity, side, price, timeInForce = 'gtc', broker, accountNumber) {
+        const orderParams = {
+            broker: broker || 'robinhood',
+            order_type: 'Limit',
+            asset_type: 'equity',
+            action: side === 'buy' ? 'Buy' : 'Sell',
+            time_in_force: timeInForce,
+            account_number: accountNumber !== undefined ? accountNumber : '',
+            symbol,
+            order_qty: quantity,
+            price,
+        };
+        return await this.brokers.placeOrder({ body: orderParams });
+    }
+    /**
+     * Place a stock stop order.
+     */
+    async placeStockStopOrder(symbol, quantity, side, stopPrice, timeInForce = 'gtc', broker, accountNumber) {
+        const orderParams = {
+            broker: broker || 'robinhood',
+            order_type: 'Stop',
+            asset_type: 'equity',
+            action: side === 'buy' ? 'Buy' : 'Sell',
+            time_in_force: timeInForce,
+            account_number: accountNumber !== undefined ? accountNumber : '',
+            symbol,
+            order_qty: quantity,
+            stop_price: stopPrice,
+        };
+        return await this.brokers.placeOrder({ body: orderParams });
+    }
+    /**
+     * Place a crypto market order.
+     */
+    async placeCryptoMarketOrder(symbol, quantity, side, broker, accountNumber) {
+        const orderParams = {
+            broker: broker || 'robinhood',
+            order_type: 'Market',
+            asset_type: 'crypto',
+            action: side === 'buy' ? 'Buy' : 'Sell',
+            time_in_force: 'day',
+            account_number: accountNumber !== undefined ? accountNumber : '',
+            symbol,
+            order_qty: quantity,
+        };
+        return await this.brokers.placeOrder({ body: orderParams });
+    }
+    /**
+     * Place a crypto limit order.
+     */
+    async placeCryptoLimitOrder(symbol, quantity, side, price, timeInForce = 'gtc', broker, accountNumber) {
+        const orderParams = {
+            broker: broker || 'robinhood',
+            order_type: 'Limit',
+            asset_type: 'crypto',
+            action: side === 'buy' ? 'Buy' : 'Sell',
+            time_in_force: timeInForce,
+            account_number: accountNumber !== undefined ? accountNumber : '',
+            symbol,
+            order_qty: quantity,
+            price,
+        };
+        return await this.brokers.placeOrder({ body: orderParams });
+    }
+    /**
+     * Place an options market order.
+     */
+    async placeOptionsMarketOrder(symbol, quantity, side, broker, accountNumber) {
+        const orderParams = {
+            broker: broker || 'robinhood',
+            order_type: 'Market',
+            asset_type: 'equity_option',
+            action: side === 'buy' ? 'Buy' : 'Sell',
+            time_in_force: 'day',
+            account_number: accountNumber !== undefined ? accountNumber : '',
+            symbol,
+            order_qty: quantity,
+        };
+        return await this.brokers.placeOrder({ body: orderParams });
+    }
+    /**
+     * Place an options limit order.
+     */
+    async placeOptionsLimitOrder(symbol, quantity, side, price, timeInForce = 'gtc', broker, accountNumber) {
+        const orderParams = {
+            broker: broker || 'robinhood',
+            order_type: 'Limit',
+            asset_type: 'equity_option',
+            action: side === 'buy' ? 'Buy' : 'Sell',
+            time_in_force: timeInForce,
+            account_number: accountNumber !== undefined ? accountNumber : '',
+            symbol,
+            order_qty: quantity,
+            price,
+        };
+        return await this.brokers.placeOrder({ body: orderParams });
+    }
+    /**
+     * Place a futures market order.
+     */
+    async placeFuturesMarketOrder(symbol, quantity, side, broker, accountNumber) {
+        const orderParams = {
+            broker: broker || 'robinhood',
+            order_type: 'Market',
+            asset_type: 'future',
+            action: side === 'buy' ? 'Buy' : 'Sell',
+            time_in_force: 'day',
+            account_number: accountNumber !== undefined ? accountNumber : '',
+            symbol,
+            order_qty: quantity,
+        };
+        return await this.brokers.placeOrder({ body: orderParams });
+    }
+    /**
+     * Place a futures limit order.
+     */
+    async placeFuturesLimitOrder(symbol, quantity, side, price, timeInForce = 'gtc', broker, accountNumber) {
+        const orderParams = {
+            broker: broker || 'robinhood',
+            order_type: 'Limit',
+            asset_type: 'future',
+            action: side === 'buy' ? 'Buy' : 'Sell',
+            time_in_force: timeInForce,
+            account_number: accountNumber !== undefined ? accountNumber : '',
+            symbol,
+            order_qty: quantity,
+            price,
+        };
+        return await this.brokers.placeOrder({ body: orderParams });
+    }
+    /**
+     * Place a generic order.
+     */
+    async placeOrder(orderParams) {
+        return await this.brokers.placeOrder({ body: orderParams });
+    }
+    /**
+     * Modify an existing order.
+     */
+    async modifyOrder(orderId, orderParams) {
+        return await this.brokers.modifyOrder({ orderId, body: orderParams });
+    }
+    /**
+     * Cancel an existing order.
+     */
+    async cancelOrder(orderId, accountNumber, connectionId) {
+        return await this.brokers.cancelOrder({
+            orderId,
+            ...(accountNumber ? { accountNumber } : {}),
+            ...(connectionId ? { connectionId } : {}),
+        });
+    }
+}
+exports.FinaticConnect = FinaticConnect;
+FinaticConnect.instance = null;
+//# sourceMappingURL=FinaticConnect.js.map