@livefolio/sdk 0.2.12 → 0.3.0

package/dist/index.d.ts

@@ -1,23 +1,397 @@
-export * as auth from './auth';
-export * as market from './market';
-export * as strategy from './strategy';
-export * as portfolio from './portfolio';
-export type { TypedSupabaseClient } from './types';
-export type { AuthModule } from './auth';
-export type { MarketModule } from './market';
-export type { StrategyModule } from './strategy';
-export type { PortfolioModule } from './portfolio';
-import type { TypedSupabaseClient } from './types';
-import type { AuthModule } from './auth';
-import type { MarketModule } from './market';
-import type { StrategyModule } from './strategy';
-import type { PortfolioModule } from './portfolio';
-export interface LivefolioClient {
-    readonly supabase: TypedSupabaseClient;
-    readonly auth: AuthModule;
-    readonly market: MarketModule;
-    readonly strategy: StrategyModule;
-    readonly portfolio: PortfolioModule;
-}
-export declare function createLivefolioClient(supabase: TypedSupabaseClient): LivefolioClient;
-//# sourceMappingURL=index.d.ts.map
+interface MarketProvider {
+    fetchBars(symbol: string, from?: string): Promise<DailyBar[]>;
+}
+
+type IndicatorType = 'Price' | 'SMA' | 'EMA' | 'RSI' | 'Return' | 'Volatility' | 'Drawdown' | 'VIX' | 'VIX3M' | 'T3M' | 'T6M' | 'T1Y' | 'T2Y' | 'T3Y' | 'T5Y' | 'T7Y' | 'T10Y' | 'T20Y' | 'T30Y' | 'Month' | 'Day of Week' | 'Day of Month' | 'Day of Year' | 'Threshold';
+type TradingFreq = 'Daily' | 'Weekly' | 'Monthly' | 'Bi-monthly' | 'Quarterly' | 'Every 4 Months' | 'Semiannually' | 'Yearly';
+type Comparison = '>' | '<' | '=';
+type Unit = '%' | 'bps' | 'std';
+interface StrategySeriesEntry {
+    date: string;
+    allocationId: number;
+}
+interface StrategyRuleDefinition {
+    signalIds?: number[];
+    allocationId: number;
+}
+interface StrategyDefinition {
+    linkId: string;
+    name: string;
+    freq: TradingFreq;
+    offset: number;
+    rules: StrategyRuleDefinition[];
+}
+interface StrategyReferenceData {
+    id: number;
+    name: string;
+    freq: TradingFreq;
+    offset: number;
+    rules: {
+        signals: {
+            id: number;
+            indicatorId1: number;
+            indicatorId2: number;
+            comparison: Comparison;
+            tolerance: number;
+        }[];
+        allocations: {
+            id: number;
+            holdings: Record<string, number>;
+        }[];
+        indicators: {
+            id: number;
+            type: IndicatorType;
+            tickerId: number | null;
+            lookback: number;
+            delay: number;
+            unit: Unit | null;
+            threshold: number | null;
+        }[];
+        tickers: {
+            id: number;
+            symbol: string;
+            leverage: number;
+        }[];
+        definition: StrategyRuleDefinition[];
+    };
+}
+
+declare class TickerHandle {
+    readonly symbol: string;
+    readonly leverage: number;
+    private _storage;
+    private _resolvedId;
+    private _resolving;
+    constructor(storage: StorageProvider, symbol: string, leverage?: number);
+    get id(): number;
+    resolve(): Promise<{
+        id: number;
+    }>;
+    static fromResolved(storage: StorageProvider, id: number, symbol: string, leverage: number): TickerHandle;
+    private _doResolve;
+}
+
+interface DailyBar {
+    date: string;
+    value: number;
+}
+interface IndicatorIdentity {
+    type: IndicatorType;
+    ticker: TickerHandle | null;
+    lookback: number;
+    delay: number;
+    unit: Unit | null;
+    threshold: number | null;
+}
+interface DateRange {
+    from?: string;
+    to?: string;
+}
+declare class IndicatorHandle {
+    readonly type: IndicatorType;
+    readonly ticker: TickerHandle | null;
+    readonly lookback: number;
+    readonly delay: number;
+    readonly unit: Unit | null;
+    readonly threshold: number | null;
+    private _storage;
+    private _market;
+    private _resolvedId;
+    private _resolving;
+    private _cachedSeries;
+    private _cachedAsOf;
+    private _syncing;
+    constructor(storage: StorageProvider, market: MarketProvider, identity: IndicatorIdentity);
+    get id(): number;
+    resolve(): Promise<{
+        id: number;
+    }>;
+    static fromResolved(storage: StorageProvider, market: MarketProvider, id: number, identity: IndicatorIdentity): IndicatorHandle;
+    private _doResolve;
+    private _getLatestClosedTradingDay;
+    private _getLatestSeriesDate;
+    private _ensureFresh;
+    private _sync;
+    private _upsertSeries;
+    private _querySeriesFromDb;
+    series(range?: DateRange): Promise<DailyBar[]>;
+    private _syntheticThresholdSeries;
+    value(date?: string): Promise<number | null>;
+}
+
+interface StorageProvider {
+    tickers: {
+        upsert(symbol: string, leverage: number): Promise<{
+            id: number;
+        }>;
+        findOrCreate(symbol: string, leverage: number): Promise<{
+            id: number;
+        }>;
+    };
+    indicators: {
+        upsert(identity: {
+            type: string;
+            tickerId: number | null;
+            lookback: number;
+            delay: number;
+            unit: string | null;
+            threshold: number | null;
+        }): Promise<{
+            id: number;
+        }>;
+        findOrCreate(identity: {
+            type: string;
+            tickerId: number | null;
+            lookback: number;
+            delay: number;
+            unit: string | null;
+            threshold: number | null;
+        }): Promise<{
+            id: number;
+        }>;
+        getSeries(indicatorId: number, range?: DateRange): Promise<DailyBar[]>;
+        writeSeries(indicatorId: number, bars: DailyBar[]): Promise<void>;
+        getLatestSeriesDate(indicatorId: number): Promise<string | null>;
+        getValue(indicatorId: number, date?: string): Promise<number | null>;
+    };
+    signals: {
+        upsert(identity: {
+            indicatorId1: number;
+            indicatorId2: number;
+            comparison: string;
+            tolerance: number;
+        }): Promise<{
+            id: number;
+        }>;
+        findOrCreate(identity: {
+            indicatorId1: number;
+            indicatorId2: number;
+            comparison: string;
+            tolerance: number;
+        }): Promise<{
+            id: number;
+        }>;
+        getSeries(signalId: number, range?: DateRange): Promise<DailyBar[]>;
+        writeSeries(signalId: number, bars: DailyBar[]): Promise<void>;
+        getLatestSeriesDate(signalId: number): Promise<string | null>;
+        getLastValue(signalId: number): Promise<number | null>;
+    };
+    allocations: {
+        findOrCreate(holdings: Record<string, number>): Promise<{
+            id: number;
+        }>;
+    };
+    strategies: {
+        create(definition: StrategyDefinition): Promise<{
+            id: number;
+        }>;
+        getSeries(strategyId: number, range?: DateRange): Promise<StrategySeriesEntry[]>;
+        writeSeries(strategyId: number, entries: StrategySeriesEntry[]): Promise<void>;
+        getLatestSeriesDate(strategyId: number): Promise<string | null>;
+        resolveReference(linkId: string): Promise<StrategyReferenceData>;
+    };
+    tradingDays: {
+        getRange(range?: DateRange): Promise<string[]>;
+        getLatestClosed(): Promise<string | null>;
+    };
+}
+
+interface SignalIdentity {
+    indicator1: IndicatorHandle;
+    indicator2: IndicatorHandle;
+    comparison: Comparison;
+    tolerance: number;
+}
+declare class SignalHandle {
+    readonly indicator1: IndicatorHandle;
+    readonly indicator2: IndicatorHandle;
+    readonly comparison: Comparison;
+    readonly tolerance: number;
+    private _storage;
+    private _market;
+    private _resolvedId;
+    private _resolving;
+    private _cachedSeries;
+    private _cachedAsOf;
+    private _syncing;
+    constructor(storage: StorageProvider, market: MarketProvider, identity: SignalIdentity);
+    get id(): number;
+    resolve(): Promise<{
+        id: number;
+    }>;
+    static fromResolved(storage: StorageProvider, market: MarketProvider, id: number, identity: SignalIdentity): SignalHandle;
+    private _doResolve;
+    private _getLatestClosedTradingDay;
+    private _getLatestSignalSeriesDate;
+    private _getLastSignalValue;
+    private _ensureFresh;
+    private _sync;
+    private _upsertSeries;
+    private _querySeriesFromDb;
+    series(range?: DateRange): Promise<DailyBar[]>;
+    value(date?: string): Promise<number | null>;
+}
+
+declare class AllocationHandle {
+    readonly holdings: [TickerHandle, number][];
+    private _storage;
+    private _resolvedId;
+    private _resolving;
+    constructor(storage: StorageProvider, holdings: [TickerHandle, number][]);
+    get id(): number;
+    resolve(): Promise<{
+        id: number;
+    }>;
+    static fromResolved(storage: StorageProvider, id: number, holdings: [TickerHandle, number][]): AllocationHandle;
+    private _doResolve;
+}
+
+declare class PortfolioHandle {
+    readonly holdings: [TickerHandle, number][];
+    constructor(holdings: [TickerHandle, number][]);
+    private _priceMap;
+    private _priceFor;
+    value(prices: [TickerHandle, number][]): number;
+    weights(prices: [TickerHandle, number][]): [TickerHandle, number][];
+    trades(target: AllocationHandle, prices: [TickerHandle, number][], date: string): Trade[];
+}
+
+interface SimulateOptions {
+    from: string;
+    to: string;
+    portfolio: PortfolioHandle;
+}
+interface Trade {
+    date: string;
+    symbol: string;
+    quantity: number;
+    price: number;
+    action: 'buy' | 'sell';
+}
+interface PortfolioSnapshot {
+    value: number;
+    holdings: [TickerHandle, number][];
+    weights: [TickerHandle, number][];
+    pendingTrades: Trade[];
+}
+interface FinalState {
+    portfolio: PortfolioHandle;
+    allocation: AllocationHandle;
+    closePrices: Record<string, number>;
+    leveragedPrices: Record<string, number>;
+}
+declare class SimulationHandle {
+    readonly series: DailyBar[];
+    readonly trades: Trade[];
+    readonly startingPortfolio: PortfolioHandle;
+    private _portfolio;
+    private _currentAllocation;
+    private _lastClosePrices;
+    private _lastLeveragedPrices;
+    private _currentLeveragedPrices;
+    private _lastDate;
+    constructor(series: DailyBar[], trades: Trade[], startingPortfolio: PortfolioHandle, finalState?: FinalState);
+    push(...prices: [TickerHandle, number][]): PortfolioSnapshot;
+}
+
+interface StrategyRule {
+    when?: SignalHandle[];
+    hold: AllocationHandle;
+}
+interface StrategyBar {
+    date: string;
+    allocation: AllocationHandle;
+}
+interface StrategyOptions {
+    name: string;
+    freq?: TradingFreq;
+    offset?: number;
+    rules: StrategyRule[];
+}
+declare class StrategyHandle {
+    private _linkId;
+    private _name;
+    private _freq;
+    private _offset;
+    private _rules;
+    private _storage;
+    private _market;
+    private _resolvedId;
+    private _resolvedLinkId;
+    private _resolving;
+    private _allocationMap;
+    private _cache;
+    private _cachedAsOf;
+    private _syncing;
+    constructor(storage: StorageProvider, market: MarketProvider, optionsOrLinkId: StrategyOptions | string);
+    get id(): number;
+    get link(): string;
+    get name(): string | null;
+    get freq(): TradingFreq;
+    get offset(): number;
+    get rules(): StrategyRule[];
+    resolve(): Promise<{
+        id: number;
+    }>;
+    private _doResolveCreate;
+    private _doResolveReference;
+    private _getLatestClosedTradingDay;
+    private _getLatestStrategySeriesDate;
+    private _ensureFresh;
+    private _sync;
+    private _querySeriesFromDb;
+    series(range?: DateRange): Promise<StrategyBar[]>;
+    value(date?: string): Promise<AllocationHandle | null>;
+    simulate(options: SimulateOptions): Promise<SimulationHandle>;
+    private _fetchPricesForTickers;
+    private _fetchRawClosePrices;
+}
+
+type TreasuryTenor = Extract<IndicatorType, 'T3M' | 'T6M' | 'T1Y' | 'T2Y' | 'T3Y' | 'T5Y' | 'T7Y' | 'T10Y' | 'T20Y' | 'T30Y'>;
+type CalendarPeriod = Extract<IndicatorType, 'Month' | 'Day of Week' | 'Day of Month' | 'Day of Year'>;
+interface IndicatorOpts {
+    delay?: number;
+}
+interface LivefolioClient {
+    ticker(symbol: string, leverage?: number): TickerHandle;
+    sma(ticker: TickerHandle, lookback: number, opts?: IndicatorOpts): IndicatorHandle;
+    ema(ticker: TickerHandle, lookback: number, opts?: IndicatorOpts): IndicatorHandle;
+    price(ticker: TickerHandle, opts?: IndicatorOpts): IndicatorHandle;
+    returns(ticker: TickerHandle, lookback: number, opts?: IndicatorOpts): IndicatorHandle;
+    volatility(ticker: TickerHandle, lookback: number, opts?: IndicatorOpts): IndicatorHandle;
+    drawdown(ticker: TickerHandle, lookback: number, opts?: IndicatorOpts): IndicatorHandle;
+    rsi(ticker: TickerHandle, lookback: number, opts?: IndicatorOpts): IndicatorHandle;
+    vix(opts?: IndicatorOpts): IndicatorHandle;
+    vix3m(opts?: IndicatorOpts): IndicatorHandle;
+    treasury(tenor: TreasuryTenor, opts?: IndicatorOpts): IndicatorHandle;
+    calendar(period: CalendarPeriod, opts?: IndicatorOpts): IndicatorHandle;
+    threshold(value: number, unit?: Unit): IndicatorHandle;
+    gt(ind1: IndicatorHandle, ind2: IndicatorHandle, tolerance?: number): SignalHandle;
+    lt(ind1: IndicatorHandle, ind2: IndicatorHandle, tolerance?: number): SignalHandle;
+    eq(ind1: IndicatorHandle, ind2: IndicatorHandle, tolerance?: number): SignalHandle;
+    allocation(...holdings: [TickerHandle, number][]): AllocationHandle;
+    portfolio(...holdings: [TickerHandle, number][]): PortfolioHandle;
+    strategy(linkId: string): StrategyHandle;
+    strategy(options: StrategyOptions): StrategyHandle;
+    strategy(optionsOrLinkId: string | StrategyOptions): StrategyHandle;
+}
+interface LivefolioClientOptions {
+    storage: StorageProvider;
+    market: MarketProvider;
+}
+declare function createClient(options: LivefolioClientOptions): LivefolioClient;
+
+type StreamStatus = 'connected' | 'disconnected' | 'reconnecting';
+interface PriceStream {
+    subscribe(...symbols: string[]): void;
+    unsubscribe(...symbols: string[]): void;
+    on(event: 'tick', cb: (symbol: string, price: number, time: string) => void): void;
+    on(event: 'status', cb: (status: StreamStatus) => void): void;
+    on(event: 'error', cb: (error: Error) => void): void;
+    off(event: 'tick', cb: (symbol: string, price: number, time: string) => void): void;
+    off(event: 'status', cb: (status: StreamStatus) => void): void;
+    off(event: 'error', cb: (error: Error) => void): void;
+    close(): void;
+}
+
+export { AllocationHandle, type Comparison, type DailyBar, type DateRange, IndicatorHandle, type IndicatorIdentity, type IndicatorType, type LivefolioClient, type LivefolioClientOptions, type MarketProvider, PortfolioHandle, type PortfolioSnapshot, type PriceStream, SignalHandle, type SignalIdentity, type SimulateOptions, SimulationHandle, type StorageProvider, type StrategyBar, type StrategyDefinition, StrategyHandle, type StrategyOptions, type StrategyReferenceData, type StrategyRule, type StrategyRuleDefinition, type StrategySeriesEntry, type StreamStatus, TickerHandle, type Trade, type TradingFreq, type Unit, createClient };