@finatic/client 0.0.131

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

@@ -0,0 +1,121 @@
+import { ApiConfig, ApiResponse, OrdersFilter, PositionsFilter, AccountsFilter, FilteredOrdersResponse, FilteredPositionsResponse, FilteredAccountsResponse } from '../types/api';
+import { PaginatedResult } from '../types';
+export 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>;
+}

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

@@ -0,0 +1,24 @@
+import { ApiClient } from './ApiClient';
+import { PortalConfig } from '../types/portal';
+import { Theme } from '../types/theme';
+export 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>;
+}
+export 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;
+}

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

@@ -0,0 +1,55 @@
+import { ApiClient } from './ApiClient';
+import { Order, OptionsOrder, OrdersFilter, PositionsFilter, AccountsFilter, BrokerDataOrder, BrokerDataPosition, BrokerDataAccount } from '../types/api';
+import { PaginatedResult } from '../types';
+export 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[]>;
+}
+export 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[]>;
+}

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

@@ -0,0 +1,23 @@
+import { ApiConfig, ApiResponse } from '../types/api';
+export declare class ApiService {
+    private config;
+    private accessToken?;
+    private deviceInfo?;
+    constructor(config: ApiConfig);
+    setAccessToken(token: string): void;
+    setDeviceInfo(deviceInfo: string): void;
+    private request;
+    get<T>(path: string, options?: {
+        headers?: Record<string, string>;
+        params?: Record<string, string>;
+    }): Promise<ApiResponse<T>>;
+    post<T>(path: string, body: any, options?: {
+        headers?: Record<string, string>;
+    }): Promise<ApiResponse<T>>;
+    put<T>(path: string, body: any, options?: {
+        headers?: Record<string, string>;
+    }): Promise<ApiResponse<T>>;
+    delete<T>(path: string, options?: {
+        headers?: Record<string, string>;
+    }): Promise<ApiResponse<T>>;
+}

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

@@ -0,0 +1,9 @@
+import { ApiService } from './api';
+import { UserToken, PortalResponse } from '../types/api';
+export declare class AuthService {
+    private api;
+    constructor(api: ApiService);
+    getPortalToken(companyId: string): Promise<PortalResponse>;
+    getUserToken(token: string, companyId: string, userId: string): Promise<UserToken>;
+    revokeToken(accessToken: string): Promise<void>;
+}

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

@@ -0,0 +1,4 @@
+export * from './api';
+export * from './auth';
+export * from './portfolio';
+export * from './PortalService';

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

@@ -0,0 +1,10 @@
+import { ApiService } from './api';
+import { Holding, Portfolio, PortfolioSnapshot, PerformanceMetrics } from '../types/api';
+export declare class PortfolioService {
+    private api;
+    constructor(api: ApiService);
+    getHoldings(accessToken: string): Promise<Holding[]>;
+    getPortfolio(accessToken: string): Promise<Portfolio>;
+    getPortfolioSnapshot(accessToken: string): Promise<PortfolioSnapshot>;
+    getPerformanceMetrics(accessToken: string): Promise<PerformanceMetrics>;
+}

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

@@ -0,0 +1,10 @@
+import { ApiService } from './api';
+import { Order, OptionsOrder } from '../types/api';
+export declare class TradingService {
+    private api;
+    constructor(api: ApiService);
+    placeOrder(accessToken: string, order: Order): Promise<void>;
+    placeOptionsOrder(accessToken: string, order: OptionsOrder): Promise<void>;
+    cancelOrder(accessToken: string, orderId: string): Promise<void>;
+    getOrders(accessToken: string): Promise<Order[]>;
+}

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

@@ -0,0 +1,2 @@
+export * from './types';
+export * from './themes';

package/dist/types/shared/themes/index.d.ts

@@ -0,0 +1,2 @@
+export * from './presets';
+export * from './system';

package/dist/types/shared/themes/portalPresets.d.ts

@@ -0,0 +1,8 @@
+import { PortalThemeConfig } from '../../types/portal';
+export declare const darkTheme: PortalThemeConfig;
+export declare const lightTheme: PortalThemeConfig;
+export declare const corporateBlueTheme: PortalThemeConfig;
+export declare const purpleTheme: PortalThemeConfig;
+export declare const greenTheme: PortalThemeConfig;
+export declare const orangeTheme: PortalThemeConfig;
+export declare const portalThemePresets: Record<string, PortalThemeConfig>;

package/dist/types/shared/themes/presets.d.ts

@@ -0,0 +1,3 @@
+import { Theme } from '../types';
+export declare const lightTheme: Theme;
+export declare const darkTheme: Theme;

package/dist/types/shared/themes/system.d.ts

@@ -0,0 +1,2 @@
+import { Theme } from '../types';
+export declare const systemTheme: Theme;

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

@@ -0,0 +1,110 @@
+export interface BrokerAccount {
+    id: string;
+    name: string;
+    type: string;
+    status: 'active' | 'inactive' | 'pending';
+    balance?: {
+        total: number;
+        available: number;
+        currency: string;
+    };
+}
+export interface Theme {
+    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;
+        };
+    };
+}