@finatic/client 0.0.131

package/dist/types/client/ApiClient.d.ts

@@ -0,0 +1,234 @@
+import { SessionResponse, OtpRequestResponse, OtpVerifyResponse, PortalUrlResponse, SessionValidationResponse, SessionAuthenticateResponse, UserToken, Holding, Order, Portfolio, BrokerInfo, BrokerAccount, BrokerOrder, BrokerPosition, BrokerDataOptions, SessionState, BrokerOrderParams, BrokerExtras, CryptoOrderOptions, OptionsOrderOptions, OrderResponse, TradingContext, BrokerConnection, TokenInfo, OrdersFilter, PositionsFilter, AccountsFilter } from '../types/api';
+import { PaginatedResult } from '../types';
+import { DeviceInfo } from '../types/api';
+import { ApiError } from '../utils/errors';
+export declare class ApiClient {
+    private readonly baseUrl;
+    protected readonly deviceInfo?: DeviceInfo;
+    protected currentSessionState: SessionState | null;
+    protected currentSessionId: string | null;
+    private tradingContext;
+    private tokenInfo;
+    private refreshPromise;
+    private readonly REFRESH_BUFFER_MINUTES;
+    private companyId;
+    private csrfToken;
+    constructor(baseUrl: string, deviceInfo?: DeviceInfo);
+    /**
+     * Set session context (session ID, company ID, CSRF token)
+     */
+    setSessionContext(sessionId: string, companyId: string, csrfToken?: string): void;
+    /**
+     * Get the current session ID
+     */
+    getCurrentSessionId(): string | null;
+    /**
+     * Get the current company ID
+     */
+    getCurrentCompanyId(): string | null;
+    /**
+     * Get the current CSRF token
+     */
+    getCurrentCsrfToken(): string | null;
+    /**
+     * Store tokens after successful authentication
+     */
+    setTokens(accessToken: string, refreshToken: string, expiresAt: string, userId?: string): void;
+    /**
+     * Get the current access token, refreshing if necessary
+     */
+    getValidAccessToken(): Promise<string>;
+    /**
+     * Check if the current token is expired or about to expire
+     */
+    private isTokenExpired;
+    /**
+     * Refresh the access token using the refresh token
+     */
+    private refreshTokens;
+    /**
+     * Perform the actual token refresh request
+     */
+    private performTokenRefresh;
+    /**
+     * Clear stored tokens (useful for logout)
+     */
+    clearTokens(): void;
+    /**
+     * Get current token info (for debugging/testing)
+     */
+    getTokenInfo(): TokenInfo | null;
+    /**
+     * Make a request to the API.
+     */
+    protected request<T>(path: string, options: {
+        method: string;
+        headers?: Record<string, string>;
+        body?: any;
+        params?: Record<string, string>;
+    }): Promise<T>;
+    /**
+     * Handle API errors. This method can be overridden by language-specific implementations.
+     */
+    protected handleError(status: number, error: any): ApiError;
+    startSession(token: string, userId?: string): Promise<SessionResponse>;
+    requestOtp(sessionId: string, email: string): Promise<OtpRequestResponse>;
+    verifyOtp(sessionId: string, otp: string): Promise<OtpVerifyResponse>;
+    authenticateDirectly(sessionId: string, userId: string): Promise<SessionAuthenticateResponse>;
+    /**
+     * Get the portal URL for an active session
+     * @param sessionId The session identifier
+     * @returns Portal URL response
+     * @throws SessionError if session is not in ACTIVE state
+     */
+    getPortalUrl(sessionId: string): Promise<PortalUrlResponse>;
+    validatePortalSession(sessionId: string, signature: string): Promise<SessionValidationResponse>;
+    completePortalSession(sessionId: string): Promise<PortalUrlResponse>;
+    getHoldings(accessToken: string): Promise<{
+        data: Holding[];
+    }>;
+    getOrders(accessToken: string): Promise<{
+        data: Order[];
+    }>;
+    getPortfolio(accessToken: string): Promise<{
+        data: Portfolio;
+    }>;
+    placeOrder(accessToken: string, order: Order): Promise<void>;
+    getHoldingsAuto(): Promise<{
+        data: Holding[];
+    }>;
+    getOrdersAuto(): Promise<{
+        data: Order[];
+    }>;
+    getPortfolioAuto(): Promise<{
+        data: Portfolio;
+    }>;
+    placeOrderAuto(order: Order): Promise<void>;
+    placeBrokerOrder(accessToken: string, params: Partial<BrokerOrderParams> & {
+        symbol: string;
+        orderQty: number;
+        action: 'Buy' | 'Sell';
+        orderType: 'Market' | 'Limit' | 'Stop' | 'TrailingStop';
+        assetType: 'Stock' | 'Option' | 'Crypto' | 'Futures';
+    }, extras?: BrokerExtras): Promise<OrderResponse>;
+    cancelBrokerOrder(orderId: string, broker?: 'robinhood' | 'tasty_trade' | 'ninja_trader', extras?: any): Promise<OrderResponse>;
+    modifyBrokerOrder(orderId: string, params: Partial<BrokerOrderParams>, broker?: 'robinhood' | 'tasty_trade' | 'ninja_trader', extras?: any): Promise<OrderResponse>;
+    setBroker(broker: 'robinhood' | 'tasty_trade' | 'ninja_trader'): void;
+    setAccount(accountNumber: string, accountId?: string): void;
+    getTradingContext(): TradingContext;
+    clearTradingContext(): void;
+    placeStockMarketOrder(accessToken: string, symbol: string, orderQty: number, action: 'Buy' | 'Sell', broker?: 'robinhood' | 'tasty_trade' | 'ninja_trader', accountNumber?: string, extras?: BrokerExtras): Promise<OrderResponse>;
+    placeStockLimitOrder(accessToken: string, symbol: string, orderQty: number, action: 'Buy' | 'Sell', price: number, timeInForce?: 'day' | 'gtc', broker?: 'robinhood' | 'tasty_trade' | 'ninja_trader', accountNumber?: string, extras?: BrokerExtras): Promise<OrderResponse>;
+    placeStockStopOrder(accessToken: string, symbol: string, orderQty: number, action: 'Buy' | 'Sell', stopPrice: number, timeInForce?: 'day' | 'gtc', broker?: 'robinhood' | 'tasty_trade' | 'ninja_trader', accountNumber?: string, extras?: BrokerExtras): Promise<OrderResponse>;
+    placeCryptoMarketOrder(accessToken: string, symbol: string, orderQty: number, action: 'Buy' | 'Sell', options?: CryptoOrderOptions, broker?: 'robinhood' | 'tasty_trade' | 'ninja_trader', accountNumber?: string, extras?: BrokerExtras): Promise<OrderResponse>;
+    placeCryptoLimitOrder(accessToken: string, symbol: string, orderQty: number, action: 'Buy' | 'Sell', price: number, timeInForce?: 'day' | 'gtc', options?: CryptoOrderOptions, broker?: 'robinhood' | 'tasty_trade' | 'ninja_trader', accountNumber?: string, extras?: BrokerExtras): Promise<OrderResponse>;
+    placeOptionsMarketOrder(accessToken: string, symbol: string, orderQty: number, action: 'Buy' | 'Sell', options: OptionsOrderOptions, broker?: 'robinhood' | 'tasty_trade' | 'ninja_trader', accountNumber?: string, extras?: BrokerExtras): Promise<OrderResponse>;
+    placeOptionsLimitOrder(accessToken: string, symbol: string, orderQty: number, action: 'Buy' | 'Sell', price: number, options: OptionsOrderOptions, timeInForce?: 'day' | 'gtc', broker?: 'robinhood' | 'tasty_trade' | 'ninja_trader', accountNumber?: string, extras?: BrokerExtras): Promise<OrderResponse>;
+    placeFuturesMarketOrder(accessToken: string, symbol: string, orderQty: number, action: 'Buy' | 'Sell', broker?: 'robinhood' | 'tasty_trade' | 'ninja_trader', accountNumber?: string, extras?: BrokerExtras): Promise<OrderResponse>;
+    placeFuturesLimitOrder(accessToken: string, symbol: string, orderQty: number, action: 'Buy' | 'Sell', price: number, timeInForce?: 'day' | 'gtc', broker?: 'robinhood' | 'tasty_trade' | 'ninja_trader', accountNumber?: string, extras?: BrokerExtras): Promise<OrderResponse>;
+    private buildOrderRequestBody;
+    private buildModifyRequestBody;
+    private applyBrokerDefaults;
+    revokeToken(accessToken: string): Promise<void>;
+    getUserToken(userId: string): Promise<UserToken>;
+    getCurrentSessionState(): SessionState | null;
+    getBrokerList(accessToken: string): Promise<{
+        _id: string;
+        response_data: BrokerInfo[];
+        message: string;
+        status_code: number;
+        warnings: null;
+        errors: null;
+    }>;
+    getBrokerAccounts(accessToken: string, options?: BrokerDataOptions): Promise<{
+        _id: string;
+        response_data: BrokerAccount[];
+        message: string;
+        status_code: number;
+        warnings: null;
+        errors: null;
+    }>;
+    getBrokerOrders(accessToken: string, options?: BrokerDataOptions): Promise<{
+        _id: string;
+        response_data: BrokerOrder[];
+        message: string;
+        status_code: number;
+        warnings: null;
+        errors: null;
+    }>;
+    getBrokerPositions(accessToken: string, options?: BrokerDataOptions): Promise<{
+        _id: string;
+        response_data: BrokerPosition[];
+        message: string;
+        status_code: number;
+        warnings: null;
+        errors: null;
+    }>;
+    getBrokerConnections(accessToken: string): Promise<{
+        _id: string;
+        response_data: BrokerConnection[];
+        message: string;
+        status_code: number;
+        warnings: null;
+        errors: null;
+    }>;
+    getBrokerListAuto(): Promise<{
+        _id: string;
+        response_data: BrokerInfo[];
+        message: string;
+        status_code: number;
+        warnings: null;
+        errors: null;
+    }>;
+    getBrokerAccountsAuto(options?: BrokerDataOptions): Promise<{
+        _id: string;
+        response_data: BrokerAccount[];
+        message: string;
+        status_code: number;
+        warnings: null;
+        errors: null;
+    }>;
+    getBrokerOrdersAuto(options?: BrokerDataOptions): Promise<{
+        _id: string;
+        response_data: BrokerOrder[];
+        message: string;
+        status_code: number;
+        warnings: null;
+        errors: null;
+    }>;
+    getBrokerPositionsAuto(options?: BrokerDataOptions): Promise<{
+        _id: string;
+        response_data: BrokerPosition[];
+        message: string;
+        status_code: number;
+        warnings: null;
+        errors: null;
+    }>;
+    getBrokerConnectionsAuto(): Promise<{
+        _id: string;
+        response_data: BrokerConnection[];
+        message: string;
+        status_code: number;
+        warnings: null;
+        errors: null;
+    }>;
+    placeBrokerOrderAuto(params: Partial<BrokerOrderParams> & {
+        symbol: string;
+        orderQty: number;
+        action: 'Buy' | 'Sell';
+        orderType: 'Market' | 'Limit' | 'Stop' | 'TrailingStop';
+        assetType: 'Stock' | 'Option' | 'Crypto' | 'Futures';
+    }, extras?: BrokerExtras): Promise<OrderResponse>;
+    placeStockMarketOrderAuto(symbol: string, orderQty: number, action: 'Buy' | 'Sell', broker?: 'robinhood' | 'tasty_trade' | 'ninja_trader', accountNumber?: string, extras?: BrokerExtras): Promise<OrderResponse>;
+    placeStockLimitOrderAuto(symbol: string, orderQty: number, action: 'Buy' | 'Sell', price: number, timeInForce?: 'day' | 'gtc', broker?: 'robinhood' | 'tasty_trade' | 'ninja_trader', accountNumber?: string, extras?: BrokerExtras): Promise<OrderResponse>;
+    placeStockStopOrderAuto(symbol: string, orderQty: number, action: 'Buy' | 'Sell', stopPrice: number, timeInForce?: 'day' | 'gtc', broker?: 'robinhood' | 'tasty_trade' | 'ninja_trader', accountNumber?: string, extras?: BrokerExtras): Promise<OrderResponse>;
+    getBrokerOrdersPage(page?: number, perPage?: number, filters?: OrdersFilter): Promise<PaginatedResult<BrokerOrder[]>>;
+    getBrokerAccountsPage(page?: number, perPage?: number, filters?: AccountsFilter): Promise<PaginatedResult<BrokerAccount[]>>;
+    getBrokerPositionsPage(page?: number, perPage?: number, filters?: PositionsFilter): Promise<PaginatedResult<BrokerPosition[]>>;
+    getNextPage<T>(previousResult: PaginatedResult<T>, fetchFunction: (offset: number, limit: number) => Promise<PaginatedResult<T>>): Promise<PaginatedResult<T> | null>;
+    /**
+     * Check if this is a mock client
+     * @returns false for real API client
+     */
+    isMockClient(): boolean;
+}

package/dist/types/client/FinaticConnect.d.ts

@@ -0,0 +1,307 @@
+import { EventEmitter } from '../utils/events';
+import { PaginatedResult } from '../types';
+import { BrokerInfo, OrderResponse, TradingContext, BrokerConnection, OrdersFilter, PositionsFilter, AccountsFilter, BrokerDataOrder, BrokerDataPosition, BrokerDataAccount } from '../types/api';
+import { FinaticConnectOptions, PortalOptions } from '../types/connect';
+interface DeviceInfo {
+    ip_address: string;
+    user_agent: string;
+    fingerprint: string;
+}
+export declare class FinaticConnect extends EventEmitter {
+    private static instance;
+    private apiClient;
+    private portalUI;
+    private options;
+    private userToken;
+    private sessionId;
+    private companyId;
+    private baseUrl;
+    private readonly BROKER_LIST_CACHE_KEY;
+    private readonly BROKER_LIST_CACHE_VERSION;
+    private readonly BROKER_LIST_CACHE_DURATION;
+    private readonly deviceInfo?;
+    private currentSessionState;
+    constructor(options: FinaticConnectOptions, deviceInfo?: DeviceInfo);
+    private handleTokens;
+    /**
+     * Check if the user is authenticated
+     * @returns True if the user has a valid access token
+     */
+    isAuthenticated(): boolean;
+    /**
+     * Check if the user is fully authenticated (has userId, access token, and refresh token)
+     * @returns True if the user is fully authenticated and ready for API calls
+     */
+    isAuthed(): boolean;
+    /**
+     * 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
+     */
+    getOrders(params?: {
+        page?: number;
+        perPage?: number;
+        filter?: OrdersFilter;
+    }): Promise<PaginatedResult<BrokerDataOrder[]>>;
+    /**
+     * 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
+     */
+    getPositions(params?: {
+        page?: number;
+        perPage?: number;
+        filter?: PositionsFilter;
+    }): Promise<PaginatedResult<BrokerDataPosition[]>>;
+    /**
+     * 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
+     */
+    getAccounts(params?: {
+        page?: number;
+        perPage?: number;
+        filter?: AccountsFilter;
+    }): Promise<PaginatedResult<BrokerDataAccount[]>>;
+    /**
+     * Revoke the current user's access
+     */
+    revokeToken(): Promise<void>;
+    /**
+     * Initialize the Finatic Connect SDK
+     * @param token - The portal token from your backend
+     * @param userId - Optional: The user ID if you have it from a previous session
+     * @param options - Optional configuration including baseUrl
+     * @returns FinaticConnect instance
+     */
+    static init(token: string, userId?: string | null | undefined, options?: {
+        baseUrl?: string;
+    } | undefined): Promise<FinaticConnect>;
+    /**
+     * Initialize the SDK with a user ID
+     * @param userId - The user ID from a previous session
+     */
+    setUserId(userId: string): Promise<void>;
+    private initializeWithUser;
+    /**
+     * Handle company access error by opening the portal
+     * @param error The company access error
+     * @param options Optional configuration for the portal
+     */
+    private handleCompanyAccessError;
+    /**
+     * Open the portal for user authentication
+     * @param options Optional configuration for the portal
+     */
+    openPortal(options?: PortalOptions): Promise<void>;
+    /**
+     * Close the Finatic Connect Portal
+     */
+    closePortal(): void;
+    /**
+     * Initialize a new session
+     * @param oneTimeToken - The one-time token from initSession
+     */
+    protected startSession(oneTimeToken: string): Promise<void>;
+    /**
+     * Place a new order using the broker order API
+     * @param order - Order details with broker context
+     */
+    placeOrder(order: {
+        symbol: string;
+        quantity: number;
+        side: 'buy' | 'sell';
+        orderType: 'market' | 'limit' | 'stop' | 'stop_limit';
+        price?: number;
+        stopPrice?: number;
+        timeInForce: 'day' | 'gtc' | 'gtd' | 'ioc' | 'fok';
+        broker?: 'robinhood' | 'tasty_trade' | 'ninja_trader';
+        accountNumber?: string;
+        assetType?: 'Stock' | 'Option' | 'Crypto' | 'Futures';
+    }): Promise<OrderResponse>;
+    /**
+     * Cancel a broker order
+     * @param orderId - The order ID to cancel
+     * @param broker - Optional broker override
+     */
+    cancelOrder(orderId: string, broker?: 'robinhood' | 'tasty_trade' | 'ninja_trader'): Promise<OrderResponse>;
+    /**
+     * Modify a broker order
+     * @param orderId - The order ID to modify
+     * @param modifications - The modifications to apply
+     * @param broker - Optional broker override
+     */
+    modifyOrder(orderId: string, modifications: Partial<{
+        symbol: string;
+        quantity: number;
+        price: number;
+        stopPrice: number;
+        timeInForce: 'day' | 'gtc' | 'gtd' | 'ioc' | 'fok';
+    }>, broker?: 'robinhood' | 'tasty_trade' | 'ninja_trader'): Promise<OrderResponse>;
+    /**
+     * Set the broker context for trading
+     * @param broker - The broker to use for trading
+     */
+    setBroker(broker: 'robinhood' | 'tasty_trade' | 'ninja_trader'): void;
+    /**
+     * Set the account context for trading
+     * @param accountNumber - The account number to use for trading
+     * @param accountId - Optional account ID
+     */
+    setAccount(accountNumber: string, accountId?: string): void;
+    /**
+     * Get the current trading context
+     */
+    getTradingContext(): TradingContext;
+    /**
+     * Clear the trading context
+     */
+    clearTradingContext(): void;
+    /**
+     * Place a stock market order (convenience method)
+     */
+    placeStockMarketOrder(symbol: string, quantity: number, side: 'buy' | 'sell', broker?: 'robinhood' | 'tasty_trade' | 'ninja_trader', accountNumber?: string): Promise<OrderResponse>;
+    /**
+     * Place a stock limit order (convenience method)
+     */
+    placeStockLimitOrder(symbol: string, quantity: number, side: 'buy' | 'sell', price: number, timeInForce?: 'day' | 'gtc', broker?: 'robinhood' | 'tasty_trade' | 'ninja_trader', accountNumber?: string): Promise<OrderResponse>;
+    /**
+     * Get the current user ID
+     * @returns The current user ID or undefined if not authenticated
+     * @throws AuthenticationError if user is not authenticated
+     */
+    getUserId(): string | null;
+    /**
+     * Get list of supported brokers
+     * @returns Promise with array of broker information
+     */
+    getBrokerList(): Promise<BrokerInfo[]>;
+    /**
+     * Get broker connections
+     * @returns Promise with array of broker connections
+     * @throws AuthenticationError if user is not authenticated
+     */
+    getBrokerConnections(): Promise<BrokerConnection[]>;
+    /**
+     * Get only open positions
+     * @returns Promise with array of open positions
+     */
+    getOpenPositions(): Promise<BrokerDataPosition[]>;
+    /**
+     * Get only filled orders
+     * @returns Promise with array of filled orders
+     */
+    getFilledOrders(): Promise<BrokerDataOrder[]>;
+    /**
+     * Get only pending orders
+     * @returns Promise with array of pending orders
+     */
+    getPendingOrders(): Promise<BrokerDataOrder[]>;
+    /**
+     * Get only active accounts
+     * @returns Promise with array of active accounts
+     */
+    getActiveAccounts(): Promise<BrokerDataAccount[]>;
+    /**
+     * Get orders for a specific symbol
+     * @param symbol - The symbol to filter by
+     * @returns Promise with array of orders for the symbol
+     */
+    getOrdersBySymbol(symbol: string): Promise<BrokerDataOrder[]>;
+    /**
+     * Get positions for a specific symbol
+     * @param symbol - The symbol to filter by
+     * @returns Promise with array of positions for the symbol
+     */
+    getPositionsBySymbol(symbol: string): Promise<BrokerDataPosition[]>;
+    /**
+     * Get orders for a specific broker
+     * @param brokerId - The broker ID to filter by
+     * @returns Promise with array of orders for the broker
+     */
+    getOrdersByBroker(brokerId: string): Promise<BrokerDataOrder[]>;
+    /**
+     * Get positions for a specific broker
+     * @param brokerId - The broker ID to filter by
+     * @returns Promise with array of positions for the broker
+     */
+    getPositionsByBroker(brokerId: string): Promise<BrokerDataPosition[]>;
+    /**
+     * 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
+     */
+    getOrdersPage(page?: number, perPage?: number, filter?: OrdersFilter): Promise<PaginatedResult<BrokerDataOrder[]>>;
+    /**
+     * 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
+     */
+    getPositionsPage(page?: number, perPage?: number, filter?: PositionsFilter): Promise<PaginatedResult<BrokerDataPosition[]>>;
+    /**
+     * 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
+     */
+    getAccountsPage(page?: number, perPage?: number, filter?: AccountsFilter): Promise<PaginatedResult<BrokerDataAccount[]>>;
+    /**
+     * 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
+     */
+    getNextOrdersPage(previousResult: PaginatedResult<BrokerDataOrder[]>): Promise<PaginatedResult<BrokerDataOrder[]> | null>;
+    /**
+     * 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
+     */
+    getNextPositionsPage(previousResult: PaginatedResult<BrokerDataPosition[]>): Promise<PaginatedResult<BrokerDataPosition[]> | null>;
+    /**
+     * 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
+     */
+    getNextAccountsPage(previousResult: PaginatedResult<BrokerDataAccount[]>): Promise<PaginatedResult<BrokerDataAccount[]> | null>;
+    /**
+     * Get all orders across all pages (convenience method)
+     * @param filter - Optional filter parameters
+     * @returns Promise with all orders
+     */
+    getAllOrders(filter?: OrdersFilter): Promise<BrokerDataOrder[]>;
+    /**
+     * Get all positions across all pages (convenience method)
+     * @param filter - Optional filter parameters
+     * @returns Promise with all positions
+     */
+    getAllPositions(filter?: PositionsFilter): Promise<BrokerDataPosition[]>;
+    /**
+     * Get all accounts across all pages (convenience method)
+     * @param filter - Optional filter parameters
+     * @returns Promise with all accounts
+     */
+    getAllAccounts(filter?: AccountsFilter): Promise<BrokerDataAccount[]>;
+    /**
+     * Register automatic session cleanup on page unload/visibility change
+     */
+    private registerSessionCleanup;
+    /**
+     * Handle session cleanup when page is unloading
+     */
+    private handleSessionCleanup;
+    /**
+     * Handle visibility change (mobile browsers)
+     */
+    private handleVisibilityChange;
+    /**
+     * Complete the session by calling the API
+     * @param sessionId - The session ID to complete
+     */
+    private completeSession;
+}
+export {};

package/dist/types/index.d.ts

@@ -0,0 +1,17 @@
+export type { ApiConfig, ApiResponse, Order, OptionsOrder, BrokerAccount, PortfolioSnapshot, PerformanceMetrics, UserToken, Holding, Portfolio, PortalResponse, SessionInitResponse, SessionStartResponse, OtpRequestResponse, OtpVerifyResponse, PortalUrlResponse, SessionValidationResponse, SessionAuthenticateResponse, RequestHeaders, SessionStatus, BrokerOrderParams, BrokerExtras, CryptoOrderOptions, OptionsOrderOptions, OrderResponse, TradingContext, DeviceInfo, BrokerOrder, BrokerPosition, BrokerDataOptions, BrokerInfo, TokenInfo, RefreshTokenRequest, RefreshTokenResponse, AccountsFilter, OrdersFilter, PositionsFilter, BrokerDataOrder, BrokerDataPosition, BrokerDataAccount, FilteredOrdersResponse, FilteredPositionsResponse, FilteredAccountsResponse, BrokerConnection, } from './types/api';
+export type { SDKConfig, PortalConfig } from './types/config';
+export type { Theme } from './types/theme';
+export type { FinaticConnectOptions, FinaticUserToken, PortalMessage } from './types/connect';
+export type { PortalProps, PortalTheme, PortalThemeConfig, PortalThemePreset, } from './types/portal';
+export type { BaseError, ApiError, SessionError, AuthenticationError, AuthorizationError, RateLimitError, TokenError, ValidationError, NetworkError, SecurityError, } from './types/errors';
+export { ApiClient } from './client/ApiClient';
+export { FinaticConnect } from './client/FinaticConnect';
+export { CoreTradingService } from './services/TradingService';
+export { CoreAnalyticsService } from './services/AnalyticsService';
+export { CorePortalService } from './services/PortalService';
+export { PaginatedResult } from './types';
+export * from './utils/errors';
+export * from './utils/events';
+export * from './utils/themeUtils';
+export { portalThemePresets } from './shared/themes/portalPresets';
+export { MockFactory } from './mocks/MockFactory';