skayn-trading-sdk/index.d.ts

Professional Bitcoin trading strategy backtesting framework with institutional-grade architecture

// TypeScript definitions for Skayn Trading SDK

export interface TradingSignal {
  action: 'BUY' | 'SELL' | 'HOLD';
  confidence: number;
  quantity?: number;
  strategy?: string;
  reasons?: string[];
}

export interface MarketData {
  timestamp: number;
  open: number;
  high: number;
  low: number;
  close: number;
  volume: number;
}

export interface Portfolio {
  balance: number;
  positions: any[];
  totalValue: number;
}

export interface BacktestResults {
  initialBalance?: number;
  finalBalance?: number;
  totalReturn?: number;
  totalTrades?: number;
  winRate?: number;
  maxDrawdown?: number;
  trades?: any[];
}

export interface BacktestConfig {
  startDate?: string;
  endDate?: string;
  initialBalance?: number;
  symbol?: string;
  interval?: string;
}

export interface StrategyMetadata {
  name: string;
  version: string;
  description: string;
}

export interface Strategy {
  analyze(data: MarketData[], portfolio: Portfolio): Promise<TradingSignal>;
  getRequiredWarmupPeriods(): number;
  getStrategyMetadata(): StrategyMetadata;
}

export interface DataProvider {
  getData(startDate: string, endDate: string, interval?: string, symbol?: string): Promise<MarketData[]>;
}

export interface BacktestEngine {
  runBacktest(config: BacktestConfig): Promise<BacktestResults>;
  setStrategy(strategy: Strategy): void;
  setDataProvider(dataProvider: DataProvider): void;
}

export class SkaynTradingSDK {
  constructor(config?: any);
  strategy(strategy: Strategy): SkaynTradingSDK;
  dataProvider(provider: DataProvider): SkaynTradingSDK;
  exchange(exchange: any): SkaynTradingSDK;
  backtestEngine(engine: BacktestEngine): SkaynTradingSDK;
  backtest(config?: BacktestConfig): Promise<BacktestResults>;
  live(config?: any): Promise<void>;
}

export interface SDKFactory {
  create(config?: any): SkaynTradingSDK;
  strategy(analyzeFunction: (data: MarketData[], portfolio: Portfolio) => Promise<TradingSignal>, metadata?: Partial<StrategyMetadata>): Strategy;
  dataProvider(getDataFunction: (startDate: string, endDate: string, interval?: string, symbol?: string) => Promise<MarketData[]>, metadata?: any): DataProvider;
  backtestEngine(runBacktestFunction: (config: BacktestConfig) => Promise<BacktestResults>, metadata?: any): BacktestEngine;
}

export const SDK: SDKFactory;

// Base interfaces for extending
export { Strategy as IStrategy };
export { DataProvider as IDataProvider };
export { BacktestEngine as IBacktestEngine };

// Framework components
export class TradingFramework {
  constructor(config?: any);
  use(type: string, nameOrInstance: string | any, config?: any): TradingFramework;
  get(type: string): any;
  initialize(): Promise<TradingFramework>;
  runBacktest(config?: BacktestConfig): Promise<BacktestResults>;
  startTrading(config?: any): Promise<void>;
  stopTrading(): Promise<void>;
}

export class PluginRegistry {
  constructor();
  registerPlugin(type: string, name: string, pluginClass: any, metadata?: any): void;
  getInstance(type: string, name: string, config?: any): any;
}

export class ErrorHandler {
  static handle(error: Error): void;
}