@finatic/client 0.0.131

package/dist/index.d.ts

@@ -0,0 +1,2037 @@
+/**
+ * API-related types for Finatic Connect SDK
+ */
+interface SessionInitResponse {
+    success: boolean;
+    message: string;
+    data: {
+        one_time_token: string;
+        expires_at: string;
+    };
+}
+interface SessionResponseData {
+    session_id: string;
+    company_id: string;
+    status: 'pending';
+    expires_at: string;
+}
+interface SessionStartResponse {
+    data: SessionResponseData;
+    message: 'Session started successfully';
+}
+interface OtpRequestResponse {
+    success: boolean;
+    message: string;
+    data: boolean;
+}
+interface OtpVerifyResponse {
+    success: boolean;
+    message: string;
+    data: {
+        access_token: string;
+        refresh_token: string;
+        user_id: string;
+        expires_in: number;
+        scope: string;
+        token_type: 'Bearer';
+    };
+}
+interface PortalUrlResponse {
+    success: boolean;
+    message: string;
+    data: {
+        portal_url: string;
+    };
+}
+interface UserToken {
+    accessToken: string;
+    refreshToken: string;
+    expiresIn: number;
+    user_id: string;
+    tokenType: string;
+    scope: string;
+}
+interface ApiConfig {
+    baseUrl: string;
+    apiKey?: string;
+    sandbox?: boolean;
+}
+interface RequestHeaders {
+    'Content-Type': string;
+    'X-API-Key'?: string;
+    Authorization?: string;
+    'X-CSRF-Token'?: string;
+    token?: string;
+    'User-Agent'?: string;
+    'X-Device-Info'?: string;
+    'X-Request-ID'?: string;
+    'X-Request-Timestamp'?: string;
+    'X-Request-Signature'?: string;
+    [key: string]: string | undefined;
+}
+declare enum SessionState {
+    PENDING = "PENDING",
+    AUTHENTICATING = "AUTHENTICATING",
+    ACTIVE = "ACTIVE",
+    COMPLETED = "COMPLETED",
+    EXPIRED = "EXPIRED"
+}
+type SessionStatus = SessionState;
+interface ApiResponse<T> {
+    data: T;
+    error?: string;
+    status: number;
+}
+interface Order {
+    symbol: string;
+    side: 'buy' | 'sell';
+    quantity: number;
+    type_: 'market' | 'limit' | 'stop' | 'stop_limit';
+    price?: number;
+    stopPrice?: number;
+    timeInForce: 'day' | 'gtc' | 'opg' | 'cls' | 'ioc' | 'fok';
+}
+interface OptionsOrder extends Order {
+    optionType: 'call' | 'put';
+    strikePrice: number;
+    expirationDate: string;
+}
+interface BrokerAccount {
+    id: string;
+    user_broker_connection_id: string;
+    broker_provided_account_id: string;
+    account_name: string;
+    account_type: string;
+    currency: string;
+    cash_balance: number;
+    buying_power: number;
+    status: string;
+    /** ISO 8601 timestamp with timezone information */
+    created_at: string;
+    /** ISO 8601 timestamp with timezone information */
+    updated_at: string;
+    /** ISO 8601 timestamp with timezone information */
+    last_synced_at: string;
+}
+interface BrokerOrder {
+    id: string;
+    user_broker_connection_id: string;
+    broker_provided_account_id: string;
+    order_id: string;
+    symbol: string;
+    order_type: string;
+    side: 'buy' | 'sell';
+    quantity: number;
+    price: number;
+    status: string;
+    /** ISO 8601 timestamp with timezone information */
+    created_at: string;
+    /** ISO 8601 timestamp with timezone information */
+    updated_at: string;
+    /** ISO 8601 timestamp with timezone information, null if not filled */
+    filled_at: string | null;
+    filled_quantity: number;
+    filled_avg_price: number;
+}
+interface BrokerPosition {
+    id: string;
+    user_broker_connection_id: string;
+    broker_provided_account_id: string;
+    symbol: string;
+    asset_type: string;
+    quantity: number;
+    average_price: number;
+    market_value: number;
+    cost_basis: number;
+    unrealized_gain_loss: number;
+    unrealized_gain_loss_percent: number;
+    current_price: number;
+    last_price: number;
+    /** ISO 8601 timestamp with timezone information */
+    last_price_updated_at: string;
+    /** ISO 8601 timestamp with timezone information */
+    created_at: string;
+    /** ISO 8601 timestamp with timezone information */
+    updated_at: string;
+}
+interface BrokerDataOptions {
+    broker_name?: string;
+    account_id?: string;
+    symbol?: string;
+}
+interface PortfolioSnapshot {
+    timestamp: string;
+    totalValue: number;
+    cash: number;
+    equity: number;
+    positions: {
+        symbol: string;
+        quantity: number;
+        averagePrice: number;
+        currentPrice: number;
+        marketValue: number;
+        unrealizedPnL: number;
+    }[];
+}
+interface PerformanceMetrics {
+    totalReturn: number;
+    dailyReturn: number;
+    weeklyReturn: number;
+    monthlyReturn: number;
+    yearlyReturn: number;
+    maxDrawdown: number;
+    sharpeRatio: number;
+    beta: number;
+    alpha: number;
+}
+interface Holding {
+    symbol: string;
+    quantity: number;
+    averagePrice: number;
+    currentPrice: number;
+    marketValue: number;
+    unrealizedPnL: number;
+    realizedPnL: number;
+    costBasis: number;
+    currency: string;
+}
+interface Portfolio {
+    id: string;
+    name: string;
+    type: string;
+    status: string;
+    cash: number;
+    buyingPower: number;
+    equity: number;
+    longMarketValue: number;
+    shortMarketValue: number;
+    initialMargin: number;
+    maintenanceMargin: number;
+    lastEquity: number;
+    positions: Holding[];
+    performance: PerformanceMetrics;
+}
+interface PortalResponse {
+    portalUrl: string;
+    token: string;
+    expiresIn: number;
+}
+interface SessionValidationResponse {
+    valid: boolean;
+    company_id: string;
+    status: string;
+}
+interface SessionAuthenticateResponse {
+    success: boolean;
+    message: string;
+    data: {
+        access_token: string;
+        refresh_token: string;
+    };
+}
+interface RefreshTokenRequest {
+    refresh_token: string;
+}
+interface RefreshTokenResponse {
+    success: boolean;
+    response_data: {
+        access_token: string;
+        refresh_token: string;
+        expires_at: string;
+        company_id: string;
+        company_name: string;
+        email_verified: boolean;
+    };
+    message: string;
+}
+interface TokenInfo {
+    accessToken: string;
+    refreshToken: string;
+    expiresAt: string;
+    userId?: string;
+}
+interface SessionResponse {
+    data: {
+        session_id: string;
+        state: SessionState;
+        device_info?: Record<string, string>;
+        company_id?: string;
+        status?: string;
+        expires_at?: string;
+        user_id?: string | null;
+        auto_login?: boolean;
+        access_token?: string;
+        refresh_token?: string;
+        expires_in?: number;
+        token_type?: string;
+        scope?: string;
+    };
+    message: string;
+}
+interface BrokerInfo {
+    id: string;
+    name: string;
+    display_name: string;
+    description: string;
+    website: string;
+    features: string[];
+    auth_type: 'oauth' | 'api_key';
+    logo_path: string;
+    is_active: boolean;
+}
+interface DeviceInfo$1 {
+    ip_address: string;
+    user_agent: string;
+    fingerprint: string;
+}
+interface BrokerOrderParams {
+    broker: 'robinhood' | 'tasty_trade' | 'ninja_trader';
+    accountNumber: string;
+    symbol: string;
+    orderQty: number;
+    action: 'Buy' | 'Sell';
+    orderType: 'Market' | 'Limit' | 'Stop' | 'TrailingStop';
+    assetType: 'Stock' | 'Option' | 'Crypto' | 'Futures';
+    timeInForce: 'day' | 'gtc' | 'gtd' | 'ioc' | 'fok';
+    price?: number;
+    stopPrice?: number;
+}
+interface BrokerExtras {
+    robinhood?: {
+        extendedHours?: boolean;
+        marketHours?: 'regular_hours' | 'extended_hours';
+        trailType?: 'percentage' | 'amount';
+    };
+    ninjaTrader?: {
+        accountSpec?: string;
+        isAutomated?: boolean;
+        activationTime?: string;
+        text?: string;
+        pegDifference?: number;
+        expireTime?: string;
+    };
+    tastyTrade?: {
+        automatedSource?: boolean;
+        priceEffect?: 'Debit' | 'Credit';
+        externalIdentifier?: string;
+        partitionKey?: string;
+        preflightId?: string;
+        source?: string;
+        valueEffect?: 'Debit' | 'Credit';
+    };
+}
+interface CryptoOrderOptions {
+    quantity?: number;
+    notional?: number;
+}
+interface OptionsOrderOptions {
+    strikePrice: number;
+    expirationDate: string;
+    optionType: 'call' | 'put';
+    contractSize?: number;
+}
+interface OrderResponse {
+    success: boolean;
+    response_data: {
+        orderId: string;
+        status: string;
+        broker?: string;
+        accountNumber?: string;
+    };
+    message: string;
+    status_code: number;
+}
+interface TradingContext {
+    broker?: string;
+    accountNumber?: string;
+    accountId?: string;
+}
+interface BrokerConnection {
+    id: string;
+    broker_id: string;
+    user_id: string;
+    company_id: string;
+    status: 'connected' | 'disconnected' | 'error';
+    connected_at: string;
+    last_synced_at: string | null;
+    permissions: {
+        read: boolean;
+        write: boolean;
+    };
+    metadata: {
+        nickname?: string;
+        [key: string]: any;
+    };
+    needs_reauth: boolean;
+}
+interface OrdersFilter {
+    broker_id?: string;
+    connection_id?: string;
+    account_id?: string;
+    symbol?: string;
+    status?: 'filled' | 'pending' | 'cancelled' | 'rejected' | 'partially_filled';
+    side?: 'buy' | 'sell';
+    asset_type?: 'stock' | 'option' | 'crypto' | 'future';
+    limit?: number;
+    offset?: number;
+    created_after?: string;
+    created_before?: string;
+    with_metadata?: boolean;
+}
+interface PositionsFilter {
+    broker_id?: string;
+    connection_id?: string;
+    account_id?: string;
+    symbol?: string;
+    side?: 'long' | 'short';
+    asset_type?: 'stock' | 'option' | 'crypto' | 'future';
+    position_status?: 'open' | 'closed';
+    limit?: number;
+    offset?: number;
+    updated_after?: string;
+    updated_before?: string;
+    with_metadata?: boolean;
+}
+interface AccountsFilter {
+    broker_id?: string;
+    connection_id?: string;
+    account_type?: 'margin' | 'cash' | 'crypto_wallet' | 'live' | 'sim';
+    status?: 'active' | 'inactive';
+    currency?: string;
+    limit?: number;
+    offset?: number;
+    with_metadata?: boolean;
+}
+interface BrokerDataOrder {
+    id: string;
+    broker_id: string;
+    connection_id: string;
+    account_id: string;
+    order_id: string;
+    symbol: string;
+    order_type: string;
+    side: 'buy' | 'sell';
+    quantity: number;
+    price: number;
+    status: 'filled' | 'pending' | 'cancelled' | 'rejected' | 'partially_filled';
+    asset_type: 'stock' | 'option' | 'crypto' | 'future';
+    created_at: string;
+    updated_at: string;
+    filled_at?: string;
+    filled_quantity: number;
+    filled_avg_price: number;
+    metadata?: Record<string, any>;
+}
+interface BrokerDataPosition {
+    id: string;
+    broker_id: string;
+    connection_id: string;
+    account_id: string;
+    symbol: string;
+    asset_type: 'stock' | 'option' | 'crypto' | 'future';
+    side: 'long' | 'short';
+    quantity: number;
+    average_price: number;
+    market_value: number;
+    cost_basis: number;
+    unrealized_gain_loss: number;
+    unrealized_gain_loss_percent: number;
+    current_price: number;
+    last_price: number;
+    last_price_updated_at: string;
+    position_status: 'open' | 'closed';
+    created_at: string;
+    updated_at: string;
+    metadata?: Record<string, any>;
+}
+interface BrokerDataAccount {
+    id: string;
+    broker_id: string;
+    connection_id: string;
+    account_id: string;
+    account_name: string;
+    account_type: 'margin' | 'cash' | 'crypto_wallet' | 'live' | 'sim';
+    status: 'active' | 'inactive';
+    currency: string;
+    cash_balance: number;
+    buying_power: number;
+    equity: number;
+    created_at: string;
+    updated_at: string;
+    last_synced_at: string;
+    metadata?: Record<string, any>;
+}
+interface FilteredOrdersResponse {
+    orders: BrokerDataOrder[];
+    total: number;
+    limit: number;
+    offset: number;
+}
+interface FilteredPositionsResponse {
+    positions: BrokerDataPosition[];
+    total: number;
+    limit: number;
+    offset: number;
+}
+interface FilteredAccountsResponse {
+    accounts: BrokerDataAccount[];
+    total: number;
+    limit: number;
+    offset: number;
+}
+
+interface Theme {
+    mode: 'light' | 'dark';
+    primaryColor: string;
+    colors: {
+        primary: string;
+        secondary: string;
+        background: {
+            primary: string;
+            secondary: string;
+            tertiary: string;
+        };
+        text: {
+            primary: string;
+            secondary: string;
+            disabled: string;
+            error: string;
+            success: string;
+            warning: string;
+        };
+        border: {
+            light: string;
+            medium: string;
+            dark: string;
+        };
+        status: {
+            active: string;
+            inactive: string;
+            pending: string;
+            error: string;
+            success: string;
+        };
+    };
+    typography: {
+        fontFamily: string;
+        fontSize: {
+            xs: string;
+            sm: string;
+            base: string;
+            lg: string;
+            xl: string;
+            '2xl': string;
+        };
+        fontWeight: {
+            light: number;
+            normal: number;
+            medium: number;
+            semibold: number;
+            bold: number;
+        };
+        lineHeight: {
+            none: number;
+            tight: number;
+            normal: number;
+            relaxed: number;
+        };
+    };
+    spacing: {
+        xs: string;
+        sm: string;
+        md: string;
+        lg: string;
+        xl: string;
+        '2xl': string;
+    };
+    animation: {
+        duration: {
+            fast: string;
+            normal: string;
+            slow: string;
+        };
+        easing: {
+            linear: string;
+            easeIn: string;
+            easeOut: string;
+            easeInOut: string;
+        };
+    };
+    components: {
+        button: {
+            borderRadius: string;
+            padding: string;
+            fontSize: string;
+            fontWeight: number;
+        };
+        input: {
+            borderRadius: string;
+            padding: string;
+            fontSize: string;
+        };
+        card: {
+            borderRadius: string;
+            padding: string;
+            shadow: string;
+        };
+        modal: {
+            borderRadius: string;
+            padding: string;
+            backdrop: string;
+        };
+    };
+}
+
+interface SDKConfig {
+    token: string;
+    theme?: Theme;
+    sandbox?: boolean;
+}
+interface PortalConfig$1 {
+    companyId: string;
+    theme?: Theme;
+}
+
+interface PortalConfig {
+    width?: string;
+    height?: string;
+    position?: 'center' | 'top' | 'bottom';
+    zIndex?: number;
+}
+interface PortalThemeConfig {
+    mode: 'dark' | 'light' | 'auto';
+    colors: {
+        background: {
+            primary: string;
+            secondary: string;
+            tertiary: string;
+            accent: string;
+            glass: string;
+        };
+        status: {
+            connected: string;
+            disconnected: string;
+            warning: string;
+            pending: string;
+            error: string;
+            success: string;
+        };
+        text: {
+            primary: string;
+            secondary: string;
+            muted: string;
+            inverse: string;
+        };
+        border: {
+            primary: string;
+            secondary: string;
+            hover: string;
+            focus: string;
+            accent: string;
+        };
+        input: {
+            background: string;
+            border: string;
+            borderFocus: string;
+            text: string;
+            placeholder: string;
+        };
+        button: {
+            primary: {
+                background: string;
+                text: string;
+                hover: string;
+                active: string;
+            };
+            secondary: {
+                background: string;
+                text: string;
+                border: string;
+                hover: string;
+                active: string;
+            };
+        };
+    };
+    branding?: {
+        primaryColor?: string;
+    };
+}
+type PortalThemePreset = 'dark' | 'light' | 'corporateBlue' | 'purple' | 'green' | 'orange';
+interface PortalTheme {
+    preset?: PortalThemePreset;
+    custom?: PortalThemeConfig;
+}
+interface PortalProps {
+    config: PortalConfig;
+    onClose?: () => void;
+    onReady?: () => void;
+    onError?: (error: Error) => void;
+}
+
+interface FinaticConnectOptions {
+    /** The portal token from your backend */
+    token: string;
+    /** Optional base URL for API requests */
+    baseUrl?: string;
+    /** Optional origin for the portal */
+    origin?: string;
+    /** Callback when user successfully connects */
+    onSuccess?: (tokens: UserToken) => void;
+    /** Callback when an error occurs */
+    onError?: (error: Error) => void;
+    /** Callback when the portal is closed */
+    onClose?: () => void;
+    /** Optional theme configuration */
+    theme?: Theme;
+    /** Callback when tokens are received */
+    onTokensReceived?: (tokens: {
+        access_token?: string;
+        refresh_token?: string;
+    }) => void;
+}
+interface FinaticUserToken {
+    accessToken: string;
+    refreshToken: string;
+    userId: string;
+    companyId: string;
+    expiresAt: Date;
+}
+interface PortalMessage {
+    type: 'success' | 'error' | 'close' | 'resize';
+    userId?: string;
+    error?: string;
+    height?: number;
+    access_token?: string;
+    refresh_token?: string;
+}
+interface PortalOptions {
+    /** Callback when user successfully connects */
+    onSuccess?: (userId: string) => void;
+    /** Callback when an error occurs */
+    onError?: (error: Error) => void;
+    /** Callback when the portal is closed */
+    onClose?: () => void;
+    /** Callback when portal events occur */
+    onEvent?: (type: string, data: any) => void;
+    /** Optional theme configuration for the portal */
+    theme?: PortalTheme;
+}
+
+/**
+ * Error-related types for Finatic Connect SDK
+ */
+interface BaseError$1 {
+    code: string;
+    message: string;
+    details?: Record<string, any>;
+}
+interface ApiError$1 extends BaseError$1 {
+    status: number;
+    headers?: Record<string, string>;
+}
+interface SessionError extends BaseError$1 {
+    sessionId?: string;
+    status?: string;
+}
+interface AuthenticationError extends BaseError$1 {
+    userId?: string;
+    tokenType?: string;
+}
+interface AuthorizationError extends BaseError$1 {
+    resource?: string;
+    permission?: string;
+}
+interface RateLimitError extends BaseError$1 {
+    retryAfter?: number;
+    limit?: number;
+    remaining?: number;
+}
+interface TokenError extends BaseError$1 {
+    tokenType?: string;
+    expiresAt?: string;
+}
+interface ValidationError extends BaseError$1 {
+    field?: string;
+    value?: any;
+    constraints?: string[];
+}
+interface NetworkError extends BaseError$1 {
+    url?: string;
+    method?: string;
+    status?: number;
+}
+interface SecurityError extends BaseError$1 {
+    securityContext?: Record<string, any>;
+    validationResult?: Record<string, any>;
+}
+
+interface ApiPaginationInfo {
+    has_more: boolean;
+    next_offset: number;
+    current_offset: number;
+    limit: number;
+}
+interface PaginationMetadata {
+    hasMore: boolean;
+    nextOffset: number;
+    currentOffset: number;
+    limit: number;
+    currentPage: number;
+    hasNext: boolean;
+    hasPrevious: boolean;
+}
+declare class PaginatedResult<T> {
+    readonly data: T;
+    readonly metadata: PaginationMetadata;
+    private navigationCallback?;
+    constructor(data: T, paginationInfo: ApiPaginationInfo, navigationCallback?: (offset: number, limit: number) => Promise<PaginatedResult<T>>);
+    get hasNext(): boolean;
+    get hasPrevious(): boolean;
+    get currentPage(): number;
+    /**
+     * Navigate to the next page
+     * @returns Promise<PaginatedResult<T> | null> - Next page result or null if no next page
+     */
+    nextPage(): Promise<PaginatedResult<T> | null>;
+    /**
+     * Navigate to the previous page
+     * @returns Promise<PaginatedResult<T> | null> - Previous page result or null if no previous page
+     */
+    previousPage(): Promise<PaginatedResult<T> | null>;
+    /**
+     * Navigate to a specific page
+     * @param pageNumber - The page number to navigate to (1-based)
+     * @returns Promise<PaginatedResult<T> | null> - Page result or null if page doesn't exist
+     */
+    goToPage(pageNumber: number): Promise<PaginatedResult<T> | null>;
+    /**
+     * Get the first page
+     * @returns Promise<PaginatedResult<T> | null> - First page result or null if error
+     */
+    firstPage(): Promise<PaginatedResult<T> | null>;
+    /**
+     * Get the last page (this is a best effort - we don't know the total count)
+     * @returns Promise<PaginatedResult<T> | null> - Last page result or null if error
+     */
+    lastPage(): Promise<PaginatedResult<T> | null>;
+    /**
+     * Get pagination info as a string
+     * @returns string - Human readable pagination info
+     */
+    getPaginationInfo(): string;
+}
+
+declare class BaseError extends Error {
+    readonly code: string;
+    constructor(message: string, code?: string);
+}
+declare class ApiError extends BaseError {
+    readonly status: number;
+    readonly details?: Record<string, any> | undefined;
+    constructor(status: number, message: string, details?: Record<string, any> | undefined);
+}
+declare class CompanyAccessError extends ApiError {
+    constructor(message: string, details?: Record<string, any>);
+}
+declare class OrderError extends ApiError {
+    constructor(message: string, details?: Record<string, any>);
+}
+declare class OrderValidationError extends ApiError {
+    constructor(message: string, details?: Record<string, any>);
+}
+
+declare class ApiClient$1 {
+    private readonly baseUrl;
+    protected readonly deviceInfo?: DeviceInfo$1;
+    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$1);
+    /**
+     * 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;
+}
+
+type EventCallback = (...args: any[]) => void;
+declare class EventEmitter {
+    private events;
+    on(event: string, callback: EventCallback): void;
+    off(event: string, callback: EventCallback): void;
+    once(event: string, callback: EventCallback): void;
+    emit(event: string, ...args: any[]): void;
+    removeAllListeners(event?: string): void;
+    listenerCount(event: string): number;
+    listeners(event: string): EventCallback[];
+}
+
+interface DeviceInfo {
+    ip_address: string;
+    user_agent: string;
+    fingerprint: string;
+}
+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;
+}
+
+declare class ApiClient {
+    private baseUrl;
+    private apiKey;
+    private accessToken?;
+    private refreshToken?;
+    private isSandbox;
+    constructor(config: ApiConfig);
+    private getBaseUrl;
+    private request;
+    getPortalContent(): Promise<ApiResponse<{
+        content: string;
+    }>>;
+    getInitToken(): Promise<ApiResponse<{
+        token: string;
+    }>>;
+    login(otp: string): Promise<ApiResponse<{
+        success: boolean;
+    }>>;
+    verifyOTP(otp: string): Promise<ApiResponse<{
+        userId: string;
+        connectionIds: string[];
+    }>>;
+    getUserProfile(): Promise<ApiResponse<{
+        profile: any;
+        brokers: any[];
+    }>>;
+    getConnectionComplete(): Promise<ApiResponse<{
+        userId: string;
+        connectionIds: string[];
+    }>>;
+    getUserToken(userId: string): Promise<ApiResponse<{
+        accessToken: string;
+        refreshToken: string;
+    }>>;
+    refreshAccessToken(): Promise<ApiResponse<{
+        accessToken: string;
+        refreshToken: string;
+    }>>;
+    revokeTokens(): Promise<ApiResponse<{
+        success: boolean;
+    }>>;
+    connectBroker(brokerId: string): Promise<ApiResponse<{
+        success: boolean;
+    }>>;
+    disconnectBroker(brokerId: string): Promise<ApiResponse<{
+        success: boolean;
+    }>>;
+    getBrokerAccounts(): Promise<ApiResponse<{
+        accounts: any[];
+    }>>;
+    getConnections(): Promise<ApiResponse<{
+        connections: any[];
+    }>>;
+    getConnectionDetails(connectionId: string): Promise<ApiResponse<{
+        connection: any;
+    }>>;
+    getAccounts(filter?: AccountsFilter): Promise<ApiResponse<{
+        accounts: any[];
+    }>>;
+    getHoldings(): Promise<ApiResponse<{
+        holdings: any[];
+    }>>;
+    getBalances(): Promise<ApiResponse<{
+        balances: any;
+    }>>;
+    getTransactions(): Promise<ApiResponse<{
+        transactions: any[];
+    }>>;
+    getPerformance(): Promise<ApiResponse<{
+        performance: any;
+    }>>;
+    getOrders(filter?: OrdersFilter): Promise<ApiResponse<{
+        orders: any[];
+    }>>;
+    getTrades(): Promise<ApiResponse<{
+        trades: any[];
+    }>>;
+    placeOrder(order: any): Promise<ApiResponse<{
+        orderId: string;
+    }>>;
+    cancelOrder(orderId: string): Promise<ApiResponse<{
+        success: boolean;
+    }>>;
+    getOrderStatus(orderId: string): Promise<ApiResponse<{
+        status: string;
+    }>>;
+    getOptionsChain(symbol: string): Promise<ApiResponse<{
+        chain: any[];
+    }>>;
+    getOptionQuote(symbol: string, strike: number, expiry: string): Promise<ApiResponse<{
+        quote: any;
+    }>>;
+    placeOptionsOrder(order: any): Promise<ApiResponse<{
+        orderId: string;
+    }>>;
+    getDailyHistory(): Promise<ApiResponse<{
+        history: any[];
+    }>>;
+    getWeeklySnapshots(): Promise<ApiResponse<{
+        snapshots: any[];
+    }>>;
+    getPortfolioDeltas(): Promise<ApiResponse<{
+        deltas: any[];
+    }>>;
+    getUserLogs(userId: string): Promise<ApiResponse<{
+        logs: any[];
+    }>>;
+    getBrokerOrders(filter?: OrdersFilter): Promise<ApiResponse<FilteredOrdersResponse>>;
+    getBrokerPositions(filter?: PositionsFilter): Promise<ApiResponse<FilteredPositionsResponse>>;
+    getBrokerDataAccounts(filter?: AccountsFilter): Promise<ApiResponse<FilteredAccountsResponse>>;
+    testWebhook(): Promise<ApiResponse<{
+        success: boolean;
+    }>>;
+    private buildQueryParams;
+    getBrokerOrdersPage(page?: number, perPage?: number, filters?: OrdersFilter): Promise<PaginatedResult<any[]>>;
+    getBrokerAccountsPage(page?: number, perPage?: number, filters?: AccountsFilter): Promise<PaginatedResult<any[]>>;
+    getBrokerPositionsPage(page?: number, perPage?: number, filters?: PositionsFilter): Promise<PaginatedResult<any[]>>;
+    getNextPage<T>(previousResult: PaginatedResult<T>, fetchFunction: (offset: number, limit: number) => Promise<PaginatedResult<T>>): Promise<PaginatedResult<T> | null>;
+}
+
+interface ITradingService {
+    getAccounts(filter?: AccountsFilter): Promise<BrokerDataAccount[]>;
+    getOrders(filter?: OrdersFilter): Promise<BrokerDataOrder[]>;
+    getPositions(filter?: PositionsFilter): Promise<BrokerDataPosition[]>;
+    placeOrder(order: Order): Promise<string>;
+    cancelOrder(orderId: string): Promise<boolean>;
+    placeOptionsOrder(order: OptionsOrder): Promise<string>;
+    getAccountsPage(page?: number, perPage?: number, filter?: AccountsFilter): Promise<PaginatedResult<BrokerDataAccount[]>>;
+    getOrdersPage(page?: number, perPage?: number, filter?: OrdersFilter): Promise<PaginatedResult<BrokerDataOrder[]>>;
+    getPositionsPage(page?: number, perPage?: number, filter?: PositionsFilter): Promise<PaginatedResult<BrokerDataPosition[]>>;
+    getNextAccountsPage(previousResult: PaginatedResult<BrokerDataAccount[]>): Promise<PaginatedResult<BrokerDataAccount[]> | null>;
+    getNextOrdersPage(previousResult: PaginatedResult<BrokerDataOrder[]>): Promise<PaginatedResult<BrokerDataOrder[]> | null>;
+    getNextPositionsPage(previousResult: PaginatedResult<BrokerDataPosition[]>): Promise<PaginatedResult<BrokerDataPosition[]> | null>;
+    getAllAccounts(filter?: AccountsFilter): Promise<BrokerDataAccount[]>;
+    getAllOrders(filter?: OrdersFilter): Promise<BrokerDataOrder[]>;
+    getAllPositions(filter?: PositionsFilter): Promise<BrokerDataPosition[]>;
+    getOpenPositions(): Promise<BrokerDataPosition[]>;
+    getFilledOrders(): Promise<BrokerDataOrder[]>;
+    getPendingOrders(): Promise<BrokerDataOrder[]>;
+    getActiveAccounts(): Promise<BrokerDataAccount[]>;
+    getOrdersBySymbol(symbol: string): Promise<BrokerDataOrder[]>;
+    getPositionsBySymbol(symbol: string): Promise<BrokerDataPosition[]>;
+    getOrdersByBroker(brokerId: string): Promise<BrokerDataOrder[]>;
+    getPositionsByBroker(brokerId: string): Promise<BrokerDataPosition[]>;
+}
+declare class CoreTradingService implements ITradingService {
+    private apiClient;
+    constructor(apiClient: ApiClient);
+    getAccounts(filter?: AccountsFilter): Promise<BrokerDataAccount[]>;
+    getOrders(filter?: OrdersFilter): Promise<BrokerDataOrder[]>;
+    getPositions(filter?: PositionsFilter): Promise<BrokerDataPosition[]>;
+    placeOrder(order: Order): Promise<string>;
+    cancelOrder(orderId: string): Promise<boolean>;
+    placeOptionsOrder(order: OptionsOrder): Promise<string>;
+    getAccountsPage(page?: number, perPage?: number, filter?: AccountsFilter): Promise<PaginatedResult<BrokerDataAccount[]>>;
+    getOrdersPage(page?: number, perPage?: number, filter?: OrdersFilter): Promise<PaginatedResult<BrokerDataOrder[]>>;
+    getPositionsPage(page?: number, perPage?: number, filter?: PositionsFilter): Promise<PaginatedResult<BrokerDataPosition[]>>;
+    getNextAccountsPage(previousResult: PaginatedResult<BrokerDataAccount[]>): Promise<PaginatedResult<BrokerDataAccount[]> | null>;
+    getNextOrdersPage(previousResult: PaginatedResult<BrokerDataOrder[]>): Promise<PaginatedResult<BrokerDataOrder[]> | null>;
+    getNextPositionsPage(previousResult: PaginatedResult<BrokerDataPosition[]>): Promise<PaginatedResult<BrokerDataPosition[]> | null>;
+    getAllAccounts(filter?: AccountsFilter): Promise<BrokerDataAccount[]>;
+    getAllOrders(filter?: OrdersFilter): Promise<BrokerDataOrder[]>;
+    getAllPositions(filter?: PositionsFilter): Promise<BrokerDataPosition[]>;
+    getOpenPositions(): Promise<BrokerDataPosition[]>;
+    getFilledOrders(): Promise<BrokerDataOrder[]>;
+    getPendingOrders(): Promise<BrokerDataOrder[]>;
+    getActiveAccounts(): Promise<BrokerDataAccount[]>;
+    getOrdersBySymbol(symbol: string): Promise<BrokerDataOrder[]>;
+    getPositionsBySymbol(symbol: string): Promise<BrokerDataPosition[]>;
+    getOrdersByBroker(brokerId: string): Promise<BrokerDataOrder[]>;
+    getPositionsByBroker(brokerId: string): Promise<BrokerDataPosition[]>;
+}
+
+interface IAnalyticsService {
+    getPerformance(): Promise<PerformanceMetrics>;
+    getDailyHistory(): Promise<any[]>;
+    getWeeklySnapshots(): Promise<PortfolioSnapshot[]>;
+    getPortfolioDeltas(): Promise<any[]>;
+    getUserLogs(userId: string): Promise<any[]>;
+}
+declare class CoreAnalyticsService implements IAnalyticsService {
+    private apiClient;
+    constructor(apiClient: ApiClient);
+    getPerformance(): Promise<PerformanceMetrics>;
+    getDailyHistory(): Promise<any[]>;
+    getWeeklySnapshots(): Promise<PortfolioSnapshot[]>;
+    getPortfolioDeltas(): Promise<any[]>;
+    getUserLogs(userId: string): Promise<any[]>;
+}
+
+interface IPortalService {
+    createPortal(config: PortalConfig): Promise<void>;
+    closePortal(): Promise<void>;
+    updateTheme(theme: Theme): Promise<void>;
+    getBrokerAccounts(): Promise<any[]>;
+    linkBrokerAccount(brokerId: string): Promise<void>;
+    unlinkBrokerAccount(brokerId: string): Promise<void>;
+}
+declare class CorePortalService implements IPortalService {
+    private apiClient;
+    private iframe;
+    constructor(apiClient: ApiClient);
+    createPortal(config: PortalConfig): Promise<void>;
+    closePortal(): Promise<void>;
+    updateTheme(theme: Theme): Promise<void>;
+    getBrokerAccounts(): Promise<any[]>;
+    linkBrokerAccount(brokerId: string): Promise<void>;
+    unlinkBrokerAccount(brokerId: string): Promise<void>;
+    private positionIframe;
+    private styleIframe;
+}
+
+/**
+ * Generate a portal URL with theme parameters
+ * @param baseUrl The base portal URL
+ * @param theme The theme configuration
+ * @returns The portal URL with theme parameters
+ */
+declare function generatePortalThemeURL(baseUrl: string, theme?: PortalTheme): string;
+/**
+ * Generate a portal URL with theme parameters, appending to existing query params
+ * @param baseUrl The base portal URL (may already have query parameters)
+ * @param theme The theme configuration
+ * @returns The portal URL with theme parameters appended
+ */
+declare function appendThemeToURL(baseUrl: string, theme?: PortalTheme): string;
+/**
+ * Get a theme configuration by preset name
+ * @param preset The preset theme name
+ * @returns The theme configuration or undefined if not found
+ */
+declare function getThemePreset(preset: string): PortalThemeConfig | undefined;
+/**
+ * Validate a custom theme configuration
+ * @param theme The theme configuration to validate
+ * @returns True if valid, false otherwise
+ */
+declare function validateCustomTheme(theme: PortalThemeConfig): boolean;
+/**
+ * Create a custom theme from a preset with modifications
+ * @param preset The base preset theme
+ * @param modifications Partial theme modifications
+ * @returns The modified theme configuration
+ */
+declare function createCustomThemeFromPreset(preset: string, modifications: Partial<PortalThemeConfig>): PortalThemeConfig | null;
+
+declare const portalThemePresets: Record<string, PortalThemeConfig>;
+
+/**
+ * Configuration for mock behavior
+ */
+interface MockConfig {
+    delay?: number;
+    scenario?: MockScenario;
+    customData?: Record<string, any>;
+    mockApiOnly?: boolean;
+}
+/**
+ * Different mock scenarios for testing
+ */
+type MockScenario = 'success' | 'error' | 'network_error' | 'rate_limit' | 'auth_failure';
+/**
+ * Mock data provider for Finatic API endpoints
+ */
+declare class MockDataProvider {
+    private config;
+    private sessionData;
+    private userTokens;
+    constructor(config?: MockConfig);
+    /**
+     * Get a random delay between min and max milliseconds
+     */
+    private getRandomDelay;
+    /**
+     * Simulate network delay
+     */
+    simulateDelay(): Promise<void>;
+    /**
+     * Generate a realistic session ID
+     */
+    private generateSessionId;
+    /**
+     * Generate a realistic user ID
+     */
+    private generateUserId;
+    /**
+     * Generate a realistic company ID
+     */
+    private generateCompanyId;
+    /**
+     * Generate mock tokens
+     */
+    private generateTokens;
+    mockStartSession(token: string, userId?: string): Promise<SessionResponse>;
+    mockRequestOtp(sessionId: string, email: string): Promise<OtpRequestResponse>;
+    mockVerifyOtp(sessionId: string, otp: string): Promise<OtpVerifyResponse>;
+    mockAuthenticateDirectly(sessionId: string, userId: string): Promise<SessionAuthenticateResponse>;
+    mockGetPortalUrl(sessionId: string): Promise<PortalUrlResponse>;
+    mockValidatePortalSession(sessionId: string, signature: string): Promise<SessionValidationResponse>;
+    mockCompletePortalSession(sessionId: string): Promise<PortalUrlResponse>;
+    mockRefreshToken(refreshToken: string): Promise<RefreshTokenResponse>;
+    mockGetBrokerList(): Promise<{
+        _id: string;
+        response_data: BrokerInfo[];
+        message: string;
+        status_code: number;
+        warnings: null;
+        errors: null;
+    }>;
+    mockGetBrokerAccounts(): Promise<{
+        _id: string;
+        response_data: BrokerAccount[];
+        message: string;
+        status_code: number;
+        warnings: null;
+        errors: null;
+    }>;
+    mockGetBrokerConnections(): Promise<{
+        _id: string;
+        response_data: BrokerConnection[];
+        message: string;
+        status_code: number;
+        warnings: null;
+        errors: null;
+    }>;
+    mockGetHoldings(): Promise<{
+        data: Holding[];
+    }>;
+    mockGetPortfolio(): Promise<{
+        data: Portfolio;
+    }>;
+    mockGetOrders(filter?: OrdersFilter): Promise<{
+        data: Order[];
+    }>;
+    mockGetBrokerOrders(filter?: OrdersFilter): Promise<{
+        data: BrokerDataOrder[];
+    }>;
+    mockGetBrokerPositions(filter?: PositionsFilter): Promise<{
+        data: BrokerDataPosition[];
+    }>;
+    mockGetBrokerDataAccounts(filter?: AccountsFilter): Promise<{
+        data: BrokerDataAccount[];
+    }>;
+    mockPlaceOrder(order: Order): Promise<OrderResponse>;
+    /**
+     * Get stored session data
+     */
+    getSessionData(sessionId: string): any;
+    /**
+     * Get stored user token
+     */
+    getUserToken(userId: string): UserToken | undefined;
+    /**
+     * Clear all stored data
+     */
+    clearData(): void;
+    /**
+     * Update configuration
+     */
+    updateConfig(config: Partial<MockConfig>): void;
+    setScenario(scenario: MockScenario): void;
+    getScenario(): MockScenario;
+    private applyOrderFilters;
+    private applyBrokerOrderFilters;
+    private applyBrokerPositionFilters;
+    private applyBrokerAccountFilters;
+    /**
+     * Generate mock orders with diverse data
+     */
+    private generateMockOrders;
+    /**
+     * Generate mock positions with diverse data
+     */
+    private generateMockPositions;
+    /**
+     * Generate mock accounts with diverse data
+     */
+    private generateMockAccounts;
+}
+
+/**
+ * Mock API Client that implements the same interface as the real ApiClient
+ * but returns mock data instead of making HTTP requests
+ */
+declare class MockApiClient {
+    private readonly baseUrl;
+    protected readonly deviceInfo?: DeviceInfo$1;
+    protected currentSessionState: SessionState | null;
+    protected currentSessionId: string | null;
+    private tradingContext;
+    private tokenInfo;
+    private refreshPromise;
+    private readonly REFRESH_BUFFER_MINUTES;
+    private companyId;
+    private csrfToken;
+    private mockDataProvider;
+    private readonly mockApiOnly;
+    constructor(baseUrl: string, deviceInfo?: DeviceInfo$1, mockConfig?: MockConfig);
+    /**
+     * 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;
+    /**
+     * 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;
+    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>;
+    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, filter?: OrdersFilter): 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>;
+    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;
+    }>;
+    getBrokerOrdersWithFilter(filter?: OrdersFilter): Promise<{
+        data: BrokerDataOrder[];
+    }>;
+    getBrokerPositionsWithFilter(filter?: PositionsFilter): Promise<{
+        data: BrokerDataPosition[];
+    }>;
+    getBrokerDataAccountsWithFilter(filter?: AccountsFilter): Promise<{
+        data: BrokerDataAccount[];
+    }>;
+    getBrokerOrdersPage(page?: number, perPage?: number, filters?: OrdersFilter): Promise<PaginatedResult<any[]>>;
+    getBrokerAccountsPage(page?: number, perPage?: number, filters?: AccountsFilter): Promise<PaginatedResult<any[]>>;
+    getBrokerPositionsPage(page?: number, perPage?: number, filters?: PositionsFilter): Promise<PaginatedResult<any[]>>;
+    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>;
+    getMockDataProvider(): MockDataProvider;
+    clearMockData(): void;
+    /**
+     * Check if this is a mock client
+     * @returns true if this is a mock client
+     */
+    isMockClient(): boolean;
+}
+
+/**
+ * Factory class for creating API clients (real or mock)
+ */
+declare class MockFactory {
+    /**
+     * Create an API client based on environment configuration
+     * @param baseUrl - The base URL for the API
+     * @param deviceInfo - Optional device information
+     * @param mockConfig - Optional mock configuration (only used if mocks are enabled)
+     * @returns ApiClient or MockApiClient instance
+     */
+    static createApiClient(baseUrl: string, deviceInfo?: DeviceInfo$1, mockConfig?: MockConfig): ApiClient$1 | MockApiClient;
+    /**
+     * Force create a mock API client regardless of environment settings
+     * @param baseUrl - The base URL for the API
+     * @param deviceInfo - Optional device information
+     * @param mockConfig - Optional mock configuration
+     * @returns MockApiClient instance
+     */
+    static createMockApiClient(baseUrl: string, deviceInfo?: DeviceInfo$1, mockConfig?: MockConfig): MockApiClient;
+    /**
+     * Force create a real API client regardless of environment settings
+     * @param baseUrl - The base URL for the API
+     * @param deviceInfo - Optional device information
+     * @returns ApiClient instance
+     */
+    static createRealApiClient(baseUrl: string, deviceInfo?: DeviceInfo$1): ApiClient$1;
+    /**
+     * Check if mocks are currently enabled
+     * @returns boolean indicating if mocks are enabled
+     */
+    static isMockMode(): boolean;
+    /**
+     * Get current mock configuration
+     * @returns Mock configuration object
+     */
+    static getMockConfig(): {
+        enabled: boolean;
+        delay?: number;
+    };
+}
+
+export { ApiClient$1 as ApiClient, CompanyAccessError, CoreAnalyticsService, CorePortalService, CoreTradingService, EventEmitter, FinaticConnect, MockFactory, OrderError, OrderValidationError, PaginatedResult, appendThemeToURL, createCustomThemeFromPreset, generatePortalThemeURL, getThemePreset, portalThemePresets, validateCustomTheme };
+export type { AccountsFilter, ApiConfig, ApiError$1 as ApiError, ApiResponse, AuthenticationError, AuthorizationError, BaseError$1 as BaseError, BrokerAccount, BrokerConnection, BrokerDataAccount, BrokerDataOptions, BrokerDataOrder, BrokerDataPosition, BrokerExtras, BrokerInfo, BrokerOrder, BrokerOrderParams, BrokerPosition, CryptoOrderOptions, DeviceInfo$1 as DeviceInfo, FilteredAccountsResponse, FilteredOrdersResponse, FilteredPositionsResponse, FinaticConnectOptions, FinaticUserToken, Holding, NetworkError, OptionsOrder, OptionsOrderOptions, Order, OrderResponse, OrdersFilter, OtpRequestResponse, OtpVerifyResponse, PerformanceMetrics, PortalConfig$1 as PortalConfig, PortalMessage, PortalProps, PortalResponse, PortalTheme, PortalThemeConfig, PortalThemePreset, PortalUrlResponse, Portfolio, PortfolioSnapshot, PositionsFilter, RateLimitError, RefreshTokenRequest, RefreshTokenResponse, RequestHeaders, SDKConfig, SecurityError, SessionAuthenticateResponse, SessionError, SessionInitResponse, SessionStartResponse, SessionStatus, SessionValidationResponse, Theme, TokenError, TokenInfo, TradingContext, UserToken, ValidationError };