@backtest-kit/cli 7.0.0 → 7.2.0

package/types.d.ts

@@ -1,5 +1,11 @@
 import * as functools_kit from 'functools-kit';
+import * as BacktestKit from 'backtest-kit';
 import { CandleInterval, TrailingTakeCommit, TrailingStopCommit, BreakevenCommit, PartialProfitCommit, PartialLossCommit, IStrategyTickResultScheduled, IStrategyTickResultCancelled, IStrategyTickResultOpened, IStrategyTickResultClosed, RiskContract, AverageBuyCommit, SignalOpenContract, SignalCloseContract, CancelScheduledCommit, ClosePendingCommit } from 'backtest-kit';
+import * as BacktestKitUi from '@backtest-kit/ui';
+import * as BacktestKitGraph from '@backtest-kit/graph';
+import * as BacktestKitOllama from '@backtest-kit/ollama';
+import * as BacktestKitPinets from '@backtest-kit/pinets';
+import * as BacktestKitSignals from '@backtest-kit/signals';
 import { Input } from 'telegraf';
 
 interface ILogger {
@@ -21,6 +27,7 @@ declare class LoggerService implements ILogger {
 declare class PaperMainService {
     private loggerService;
     private resolveService;
+    private configService;
     private exchangeSchemaService;
     private symbolSchemaService;
     private frontendProviderService;
@@ -32,13 +39,20 @@ declare class PaperMainService {
         strategy: string;
         exchange: string;
         verbose: boolean;
-    }) => Promise<void>) & functools_kit.ISingleshotClearable;
-    connect: (() => Promise<void>) & functools_kit.ISingleshotClearable;
+    }) => Promise<void>) & functools_kit.ISingleshotClearable<(payload: {
+        entryPoint: string;
+        symbol: string;
+        strategy: string;
+        exchange: string;
+        verbose: boolean;
+    }) => Promise<void>>;
+    connect: (() => Promise<void>) & functools_kit.ISingleshotClearable<() => Promise<void>>;
 }
 
 declare class LiveMainService {
     private loggerService;
     private resolveService;
+    private configService;
     private exchangeSchemaService;
     private symbolSchemaService;
     private frontendProviderService;
@@ -50,13 +64,20 @@ declare class LiveMainService {
         strategy: string;
         exchange: string;
         verbose: boolean;
-    }) => Promise<void>) & functools_kit.ISingleshotClearable;
-    connect: (() => Promise<void>) & functools_kit.ISingleshotClearable;
+    }) => Promise<void>) & functools_kit.ISingleshotClearable<(payload: {
+        entryPoint: string;
+        symbol: string;
+        strategy: string;
+        exchange: string;
+        verbose: boolean;
+    }) => Promise<void>>;
+    connect: (() => Promise<void>) & functools_kit.ISingleshotClearable<() => Promise<void>>;
 }
 
 declare class BacktestMainService {
     private loggerService;
     private resolveService;
+    private configService;
     private exchangeSchemaService;
     private frameSchemaService;
     private symbolSchemaService;
@@ -73,13 +94,23 @@ declare class BacktestMainService {
         cacheInterval: string[];
         verbose: boolean;
         noCache: boolean;
-    }) => Promise<void>) & functools_kit.ISingleshotClearable;
-    connect: (() => Promise<void>) & functools_kit.ISingleshotClearable;
+    }) => Promise<void>) & functools_kit.ISingleshotClearable<(payload: {
+        entryPoint: string;
+        symbol: string;
+        strategy: string;
+        exchange: string;
+        frame: string;
+        cacheInterval: string[];
+        verbose: boolean;
+        noCache: boolean;
+    }) => Promise<void>>;
+    connect: (() => Promise<void>) & functools_kit.ISingleshotClearable<() => Promise<void>>;
 }
 
 declare class WalkerMainService {
     private loggerService;
     private resolveService;
+    private configService;
     private exchangeSchemaService;
     private symbolSchemaService;
     private cacheLogicService;
@@ -93,27 +124,36 @@ declare class WalkerMainService {
         markdown: boolean;
         verbose: boolean;
         noCache: boolean;
-    }) => Promise<void>) & functools_kit.ISingleshotClearable;
-    connect: (() => Promise<void>) & functools_kit.ISingleshotClearable;
+    }) => Promise<void>) & functools_kit.ISingleshotClearable<(payload: {
+        entryPoints: string[];
+        symbol: string;
+        output: string;
+        cacheInterval: CandleInterval[];
+        json: boolean;
+        markdown: boolean;
+        verbose: boolean;
+        noCache: boolean;
+    }) => Promise<void>>;
+    connect: (() => Promise<void>) & functools_kit.ISingleshotClearable<() => Promise<void>>;
 }
 
 declare class ExchangeSchemaService {
     readonly loggerService: LoggerService;
-    addSchema: (() => Promise<void>) & functools_kit.ISingleshotClearable;
+    addSchema: (() => Promise<void>) & functools_kit.ISingleshotClearable<() => Promise<void>>;
 }
 
 declare class FrameSchemaService {
     readonly loggerService: LoggerService;
-    addSchema: (() => Promise<void>) & functools_kit.ISingleshotClearable;
+    addSchema: (() => Promise<void>) & functools_kit.ISingleshotClearable<() => Promise<void>>;
 }
 
-declare class LoaderService {
-    private readonly babelService;
-    private readonly loggerService;
-    private readonly resolveService;
-    private getInstance;
-    import: (filePath: string, basePath?: string) => any;
-    check: (filePath: string, basePath?: string) => Promise<boolean>;
+interface IBabel {
+    transpile(code: string): string;
+}
+
+declare class BabelService implements IBabel {
+    readonly loggerService: LoggerService;
+    transpile: (code: string) => any;
 }
 
 interface IResolve {
@@ -124,13 +164,59 @@ interface IResolve {
     PROJECT_ROOT_DIR: string;
 }
 
+interface ILoaderParams {
+    path: string;
+    logger: ILogger;
+    babel: IBabel;
+    resolve: IResolve;
+}
+interface ILoader {
+    import(filePath: string): any;
+    check(filePath: string): boolean;
+}
+
+declare const BacktestKitCli: {};
+declare global {
+    interface Window {
+        BacktestKit: typeof BacktestKit;
+        BacktestKitCli: typeof BacktestKitCli;
+        BacktestKitUi: typeof BacktestKitUi;
+        BacktestKitGraph: typeof BacktestKitGraph;
+        BacktestKitOllama: typeof BacktestKitOllama;
+        BacktestKitPinets: typeof BacktestKitPinets;
+        BacktestKitSignals: typeof BacktestKitSignals;
+    }
+}
+declare class ClientLoader implements ILoader {
+    readonly params: ILoaderParams;
+    __filename: string;
+    __dirname: string;
+    baseRequire: (() => NodeRequire) & functools_kit.ISingleshotClearable<() => NodeRequire>;
+    constructor(params: ILoaderParams);
+    fork(basePath: string): ClientLoader;
+    import(filePath: string, seen?: Set<string>): any;
+    check(filePath: string): boolean;
+}
+
+declare class LoaderService {
+    readonly babelService: BabelService;
+    readonly loggerService: LoggerService;
+    readonly resolveService: ResolveService;
+    getInstance: ((basePath: string) => ClientLoader) & functools_kit.IClearableMemoize<string> & functools_kit.IControlMemoize<string, ClientLoader>;
+    import: (filePath: string, basePath?: string) => any;
+    check: (filePath: string, basePath?: string) => Promise<boolean>;
+    init: (() => void) & functools_kit.ISingleshotClearable<() => void>;
+}
+
 declare class ResolveService implements IResolve {
     readonly loggerService: LoggerService;
     readonly loaderService: LoaderService;
     readonly DEFAULT_TEMPLATE_DIR: string;
     readonly DEFAULT_MODULES_DIR: string;
+    readonly DEFAULT_CONFIG_DIR: string;
     readonly OVERRIDE_TEMPLATE_DIR: string;
     readonly OVERRIDE_MODULES_DIR: string;
+    readonly OVERRIDE_CONFIG_DIR: string;
     readonly PROJECT_ROOT_DIR: string;
     getIsLaunched: () => boolean;
     attachPine: (pinePath: string) => Promise<string>;
@@ -141,28 +227,41 @@ declare class ResolveService implements IResolve {
 declare class ErrorService {
     handleGlobalError: (error: Error) => Promise<void>;
     private _listenForError;
-    protected init: (() => void) & functools_kit.ISingleshotClearable;
+    protected init: (() => void) & functools_kit.ISingleshotClearable<() => void>;
 }
 
 declare class SymbolSchemaService {
     readonly loggerService: LoggerService;
-    addSchema: (() => Promise<void>) & functools_kit.ISingleshotClearable;
+    addSchema: (() => Promise<void>) & functools_kit.ISingleshotClearable<() => Promise<void>>;
+}
+
+type ModuleExports = {
+    [key: string]: any;
+    default?: any;
+};
+
+declare class ConfigConnectionService {
+    readonly loggerService: LoggerService;
+    readonly resolveService: ResolveService;
+    readonly loaderService: LoaderService;
+    loadConfig: (fileName: string) => Promise<ModuleExports>;
 }
 
 declare class FrontendProviderService {
-    private readonly loggerService;
-    private readonly resolveService;
-    enable: (() => () => void) & functools_kit.ISingleshotClearable;
+    readonly loggerService: LoggerService;
+    readonly resolveService: ResolveService;
+    readonly configConnectionService: ConfigConnectionService;
+    enable: (() => () => void) & functools_kit.ISingleshotClearable<() => () => void>;
     disable: () => void;
-    connect: (() => Promise<() => void>) & functools_kit.ISingleshotClearable;
+    connect: (() => Promise<() => void>) & functools_kit.ISingleshotClearable<() => Promise<() => void>>;
 }
 
 declare class TelegramProviderService {
     private readonly loggerService;
     private readonly telegramLogicService;
-    enable: (() => () => void) & functools_kit.ISingleshotClearable;
+    enable: (() => () => void) & functools_kit.ISingleshotClearable<() => () => void>;
     disable: () => void;
-    connect: (() => Promise<() => void>) & functools_kit.ISingleshotClearable;
+    connect: (() => Promise<() => void>) & functools_kit.ISingleshotClearable<() => Promise<() => void>>;
 }
 
 declare class CacheLogicService {
@@ -214,7 +313,7 @@ declare class TelegramLogicService {
     private notifySignalClose;
     private notifyCancelScheduled;
     private notifyClosePending;
-    connect: (() => () => void) & functools_kit.ISingleshotClearable;
+    connect: (() => () => void) & functools_kit.ISingleshotClearable<() => () => void>;
 }
 
 declare class TelegramTemplateService {
@@ -244,13 +343,25 @@ declare class ModuleConnectionService {
     loadModule: (fileName: string) => Promise<boolean>;
 }
 
-interface IBabel {
-    transpile(code: string): string;
+interface NotificationConfig {
+    signal: boolean;
+    risk: boolean;
+    info: boolean;
+    breakeven: boolean;
+    common_error: boolean;
+    critical_error: boolean;
+    validation_error: boolean;
+    partial_loss: boolean;
+    partial_profit: boolean;
+    signal_sync: boolean;
+    strategy_commit: boolean;
 }
 
-declare class BabelService implements IBabel {
+declare class ConfigService {
     readonly loggerService: LoggerService;
-    transpile: (code: string) => any;
+    readonly configConnectionService: ConfigConnectionService;
+    getNotificationConfig: (() => NotificationConfig) & functools_kit.ISingleshotClearable<() => NotificationConfig>;
+    waitForInit: (() => Promise<void>) & functools_kit.ISingleshotClearable<() => Promise<void>>;
 }
 
 declare const cli: {
@@ -268,26 +379,23 @@ declare const cli: {
     paperMainService: PaperMainService;
     liveMainService: LiveMainService;
     moduleConnectionService: ModuleConnectionService;
-    errorService: ErrorService;
-    loggerService: LoggerService;
+    configConnectionService: ConfigConnectionService;
     resolveService: ResolveService;
     loaderService: LoaderService;
+    configService: ConfigService;
     babelService: BabelService;
+    errorService: ErrorService;
+    loggerService: LoggerService;
     telegramApiService: TelegramApiService;
     quickchartApiService: QuickchartApiService;
 };
 
 declare class SetupUtils {
-    enable: (() => void) & functools_kit.ISingleshotClearable;
+    enable: (() => void) & functools_kit.ISingleshotClearable<() => void>;
     clear: () => void;
 }
 declare const Setup: SetupUtils;
 
-interface ILoader {
-    import(filePath: string): any;
-    check(filePath: string): boolean;
-}
-
 declare enum ExchangeName {
     DefaultExchange = "default_exchange"
 }