@finatic/client 0.0.131

package/dist/types/mocks/MockApiClient.d.ts

@@ -0,0 +1,228 @@
+import { SessionResponse, OtpRequestResponse, OtpVerifyResponse, PortalUrlResponse, SessionValidationResponse, SessionAuthenticateResponse, UserToken, Holding, Order, Portfolio, BrokerInfo, BrokerAccount, BrokerOrder, BrokerPosition, BrokerConnection, BrokerDataOptions, SessionState, BrokerOrderParams, BrokerExtras, CryptoOrderOptions, OptionsOrderOptions, OrderResponse, TradingContext, TokenInfo, OrdersFilter, PositionsFilter, AccountsFilter, BrokerDataOrder, BrokerDataPosition, BrokerDataAccount } from '../types/api';
+import { DeviceInfo } from '../types/api';
+import { PaginatedResult } from '../types';
+import { MockDataProvider, MockConfig } from './MockDataProvider';
+/**
+ * Mock API Client that implements the same interface as the real ApiClient
+ * but returns mock data instead of making HTTP requests
+ */
+export declare class MockApiClient {
+    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;
+    private mockDataProvider;
+    private readonly mockApiOnly;
+    constructor(baseUrl: string, deviceInfo?: DeviceInfo, 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;
+}

package/dist/types/mocks/MockDataProvider.d.ts

@@ -0,0 +1,132 @@
+import { SessionResponse, OtpRequestResponse, OtpVerifyResponse, PortalUrlResponse, SessionValidationResponse, SessionAuthenticateResponse, UserToken, Holding, Order, Portfolio, BrokerInfo, BrokerAccount, BrokerConnection, OrderResponse, RefreshTokenResponse, OrdersFilter, PositionsFilter, AccountsFilter, BrokerDataOrder, BrokerDataPosition, BrokerDataAccount } from '../types/api';
+/**
+ * Configuration for mock behavior
+ */
+export interface MockConfig {
+    delay?: number;
+    scenario?: MockScenario;
+    customData?: Record<string, any>;
+    mockApiOnly?: boolean;
+}
+/**
+ * Different mock scenarios for testing
+ */
+export type MockScenario = 'success' | 'error' | 'network_error' | 'rate_limit' | 'auth_failure';
+/**
+ * Mock data provider for Finatic API endpoints
+ */
+export 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;
+}

package/dist/types/mocks/MockFactory.d.ts

@@ -0,0 +1,53 @@
+import { ApiClient } from '../client/ApiClient';
+import { MockApiClient } from './MockApiClient';
+import { MockConfig } from './MockDataProvider';
+import { DeviceInfo } from '../types/api';
+/**
+ * Factory class for creating API clients (real or mock)
+ */
+export 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, mockConfig?: MockConfig): ApiClient | 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, 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): ApiClient;
+    /**
+     * 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;
+    };
+}
+/**
+ * Convenience function to create an API client
+ * @param baseUrl - The base URL for the API
+ * @param deviceInfo - Optional device information
+ * @param mockConfig - Optional mock configuration
+ * @returns ApiClient or MockApiClient instance
+ */
+export declare function createMockApiClient(baseUrl: string, deviceInfo?: DeviceInfo, mockConfig?: MockConfig): ApiClient | MockApiClient;

package/dist/types/mocks/index.d.ts

@@ -0,0 +1,5 @@
+export { MockApiClient } from './MockApiClient';
+export { MockDataProvider } from './MockDataProvider';
+export { MockFactory, createMockApiClient } from './MockFactory';
+export type { MockConfig, MockScenario } from './MockDataProvider';
+export { shouldUseMocks, setMockMode, getMockConfig } from './utils';

package/dist/types/mocks/utils.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Utility functions for mock system environment detection
+ */
+declare global {
+    var process: {
+        env: Record<string, string | undefined>;
+    } | undefined;
+}
+/**
+ * Check if mocks should be used based on environment variables
+ * Supports both browser and Node.js environments
+ */
+export declare function shouldUseMocks(): boolean;
+/**
+ * Set mock mode in the current environment
+ */
+export declare function setMockMode(enabled: boolean): void;
+/**
+ * Check if only API should be mocked (but portal should use real URL)
+ */
+export declare function shouldMockApiOnly(): boolean;
+/**
+ * Get mock configuration from environment
+ */
+export declare function getMockConfig(): {
+    enabled: boolean;
+    delay?: number;
+    mockApiOnly?: boolean;
+};

package/dist/types/portal/PortalUI.d.ts

@@ -0,0 +1,38 @@
+import { UserToken } from '../types/api';
+export declare class PortalUI {
+    private iframe;
+    private container;
+    private messageHandler;
+    private sessionId;
+    private portalOrigin;
+    private options?;
+    private userToken;
+    private originalBodyStyle;
+    constructor(portalUrl: string);
+    private createContainer;
+    /**
+     * Lock background scrolling by setting overflow: hidden on body
+     */
+    private lockScroll;
+    /**
+     * Unlock background scrolling by restoring original body style
+     */
+    private unlockScroll;
+    show(url: string, sessionId: string, options?: {
+        onSuccess?: (userId: string) => void;
+        onError?: (error: Error) => void;
+        onClose?: () => void;
+        onEvent?: (type: string, data: any) => void;
+    }): void;
+    hide(): void;
+    private handleMessage;
+    private handlePortalSuccess;
+    private handlePortalError;
+    private handlePortalClose;
+    private handleGenericEvent;
+    private handleSuccess;
+    private handleError;
+    private handleClose;
+    private handleResize;
+    getTokens(): UserToken | null;
+}

package/dist/types/security/ApiSecurity.d.ts

@@ -0,0 +1,24 @@
+export interface SecurityHeaders {
+    'X-Request-ID': string;
+    'X-Request-Timestamp': string;
+    'X-Request-Signature': string;
+    'X-Device-Fingerprint': string;
+    'User-Agent': string;
+}
+export declare class ApiSecurity {
+    private static instance;
+    private readonly runtimeSecurity;
+    private readonly requestTimeout;
+    private deviceFingerprint;
+    private userAgent;
+    private constructor();
+    static getInstance(): ApiSecurity;
+    generateRequestHeaders(): SecurityHeaders;
+    setDeviceFingerprint(fingerprint: string): void;
+    private generateDeviceFingerprint;
+    private generateRequestSignature;
+    validateResponse(): boolean;
+    isRequestValid(headers: SecurityHeaders): boolean;
+    private validateDeviceFingerprint;
+    private validateRequestSignature;
+}

package/dist/types/security/RuntimeSecurity.d.ts

@@ -0,0 +1,28 @@
+export interface IRuntimeSecurity {
+    isSecure(): boolean;
+    validateEnvironment(): boolean;
+    getEnvironmentInfo(): Record<string, any>;
+    getClientIp(): string;
+    generateFingerprint(): string;
+}
+export declare class RuntimeSecurity implements IRuntimeSecurity {
+    private static instance;
+    private readonly runtimeKey;
+    private readonly integrityChecks;
+    private isDebuggerAttached;
+    private constructor();
+    static getInstance(): RuntimeSecurity;
+    private setupAntiDebugging;
+    private setupIntegrityChecks;
+    addIntegrityCheck(name: string, check: () => boolean): void;
+    verifyIntegrity(): boolean;
+    signRequest(data: any): string;
+    validateEnvironment(): boolean;
+    private handleSecurityViolation;
+    private clearSensitiveData;
+    private reportSecurityViolation;
+    isSecure(): boolean;
+    getClientIp(): string;
+    generateFingerprint(): string;
+    getEnvironmentInfo(): Record<string, any>;
+}

package/dist/types/security/SecurityUtils.d.ts

@@ -0,0 +1,21 @@
+export interface DeviceFingerprint {
+    userAgent: string;
+    ip: string;
+    screenResolution: string;
+    timezone: string;
+    language: string;
+    platform: string;
+}
+export declare class SecurityUtils {
+    private static readonly TOKEN_REGEX;
+    static generateDeviceFingerprint(): DeviceFingerprint;
+    static validateToken(token: string): boolean;
+    static validateDeviceFingerprint(fingerprint: string): boolean;
+    static generateRequestSignature(): string;
+    static validateResponseSignature(): boolean;
+    static secureStorage: {
+        set(key: string, value: string): void;
+        get(key: string): string | null;
+        remove(key: string): void;
+    };
+}

package/dist/types/security/index.d.ts

@@ -0,0 +1,2 @@
+export { RuntimeSecurity } from './RuntimeSecurity';
+export type { IRuntimeSecurity } from './RuntimeSecurity';

package/dist/types/services/AnalyticsService.d.ts

@@ -0,0 +1,18 @@
+import { ApiClient } from './ApiClient';
+import { PerformanceMetrics, PortfolioSnapshot } from '../types/api';
+export interface IAnalyticsService {
+    getPerformance(): Promise<PerformanceMetrics>;
+    getDailyHistory(): Promise<any[]>;
+    getWeeklySnapshots(): Promise<PortfolioSnapshot[]>;
+    getPortfolioDeltas(): Promise<any[]>;
+    getUserLogs(userId: string): Promise<any[]>;
+}
+export 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[]>;
+}