@guihz/trading-vue-editor-tes 0.1.20 → 0.1.21

package/lib/components/editor/v6/parseScript/buildInFuncNamespace/runtime.d.ts

@@ -0,0 +1,10 @@
+import { TccErrorListener } from "./index";
+interface IRuntimeArgs {
+    message: string;
+}
+export declare class Runtime {
+    private _errorListener;
+    constructor(errorListener: TccErrorListener);
+    error({ message }: IRuntimeArgs, posStr: string): void;
+}
+export {};

package/lib/components/editor/v6/parseScript/buildInFuncNamespace/strategy.d.ts

@@ -0,0 +1,279 @@
+import { TccErrorListener } from ".";
+import { IKeyObjectValue } from "../../../type";
+import { BuiltInVariables } from "../buildInVariables";
+import { VCommission, VDirection, VFormatType, VOca, VScale, VStrategy } from "../enum";
+import { Closedtrdes, Opentrades, Risk } from '../strategyNamespace';
+export interface IStrategy {
+    title?: string;
+    shorttitle?: string;
+    overlay?: boolean;
+    format?: VFormatType;
+    precision?: number;
+    scale?: VScale;
+    pyramiding?: number;
+    calc_on_order_fills?: boolean;
+    calc_on_every_tick?: boolean;
+    max_bars_back?: number;
+    backtest_fill_limits_assumption?: number;
+    default_qty_type?: VStrategy;
+    default_qty_value?: number;
+    initial_capital: number;
+    currency?: string;
+    slippage?: number;
+    commission_type?: VCommission;
+    commission_value?: number;
+    process_orders_on_close?: boolean;
+    close_entries_rule?: CloseEntriesRuleType;
+    margin_long?: number;
+    margin_short?: number;
+    explicit_plot_zorder?: boolean;
+    max_lines_count?: number;
+    max_labels_count?: number;
+    max_boxes_count?: number;
+    calc_bars_count?: number;
+    risk_free_rate?: number;
+    use_bar_magnifier?: boolean;
+    fill_orders_on_standard_ohlc?: boolean;
+    max_polylines_count?: number;
+    scriptType?: string;
+    direction_short_long?: boolean;
+}
+interface IArgs {
+    value?: number;
+    fill_price?: number;
+}
+interface IOrderArgs {
+    id: string;
+    direction: VDirection;
+    from_entry?: string;
+    qty?: number;
+    limit?: number;
+    loss?: number;
+    stop?: number;
+    oca_name?: string;
+    oca_type?: VOca;
+    comment?: string;
+    alert_message?: string;
+    disable_alert?: false;
+    qty_percent?: number;
+    immediately?: boolean;
+    trail_price?: number;
+    trail_points?: number;
+    trail_offset?: number;
+    profit?: number;
+    comment_profit?: string;
+    comment_loss?: string;
+    comment_trailing?: string;
+    last_commission?: number;
+    createTime?: number;
+}
+type PlaceOrderType = 'order' | 'entry' | 'exit' | 'close' | 'close_all' | 'close_all_short' | 'close_all_long';
+export interface IOrder extends IOrderArgs {
+    isMarketPrice?: boolean;
+    out_id?: string;
+    in_index?: number;
+    out_index?: number;
+    in_price: number;
+    out_price?: number;
+    in_time?: number;
+    out_time?: number;
+    out_qty?: number;
+    out_comment?: string;
+    total_profit?: number;
+    max_profit?: number;
+    trading_loss?: number;
+    place_order_type?: PlaceOrderType;
+    position_close_type?: PlaceOrderType;
+    isDeal?: boolean;
+    exitIds?: string[];
+    active_price?: number;
+    trail_stop_price?: number;
+    hasOrder?: boolean;
+    isMarketPriceLimit?: boolean;
+    isMarketPriceStop?: boolean;
+    isCancel?: boolean;
+    close_qty?: number;
+    profit_percent?: number;
+    max_profit_percent?: number;
+    trading_loss_percent?: number;
+    commission?: number;
+    original_qty?: number;
+    in_low?: number;
+    in_high?: number;
+    out_low?: number;
+    out_high?: number;
+    isTiggerClose?: boolean;
+    entry_time?: number;
+    unid?: string;
+    realQty?: number;
+    isPartClose?: boolean;
+    occupancyQty?: number;
+    exitOrder?: IKeyObjectValue;
+    isEnd?: boolean;
+}
+interface IRisk {
+    allow_entry_in?: VDirection;
+    max_cons_loss_days?: number;
+    max_drawdown?: number;
+    max_drawdown_type?: VStrategy;
+    max_intraday_filled_orders?: number;
+    max_intraday_loss?: number;
+    max_intraday_loss_type?: VStrategy;
+    max_position_size?: number;
+    isDisabledOpen?: boolean;
+    lossDays?: number;
+    totalProfit?: number;
+    intradayOrders?: number;
+    isTemporaryBan?: boolean;
+    preNetprofit?: number;
+}
+interface IData {
+    close: number;
+    high: number;
+    low: number;
+    open: number;
+}
+interface IFillsData {
+    data?: IData;
+    tradeData?: IData;
+    index: number;
+    currentData?: IData;
+}
+type CloseEntriesRuleType = 'FIFO' | 'ANY';
+export default class Strategy {
+    private _variables;
+    private _options;
+    private _totalChangeCapital;
+    private _historyOrder;
+    private _orders;
+    private _exitOrders;
+    private _pendingOrders;
+    private _mintick;
+    private _funcOptions;
+    private _pendingCloseOrders;
+    private _errorListener;
+    private _risk;
+    private _opentrades;
+    private _closedtrades;
+    private _riskNamespace;
+    private _updateOptions;
+    private _id;
+    private _maxDrawdownVerifyIndex;
+    calcOnOrderFillsData: IFillsData;
+    private _cacheArgs;
+    private _useSetArgs;
+    private _closeOrderList;
+    private _historyOrdersShard;
+    private _notCloseHistoryOrders;
+    private _historyOrderLen;
+    constructor(variables: BuiltInVariables, options: IKeyObjectValue, mintick: number, errorListener: TccErrorListener, id: string);
+    get _strategyCacheData(): IKeyObjectValue;
+    set _strategyCacheData(val: IKeyObjectValue);
+    get orders(): IOrder[];
+    get historyOrders(): IOrder[];
+    get _freezeCapital(): number;
+    get opentrades(): Opentrades;
+    get closedtrades(): Closedtrdes;
+    get risk(): Risk;
+    get isCalcOnEveryTick(): boolean | undefined;
+    getFirstIndex(): number;
+    updateOptions(options?: IStrategy): void;
+    update(): void;
+    calcCurrentOrder(): void;
+    updateRisk(risk: IRisk): void;
+    endExecution(): void;
+    private _maxIntradayLoss;
+    private _maxIntradayFilledOrdersVerify;
+    private _maxConsLossDaysVerify;
+    private _maxDrawdownVerify;
+    private _riskTouchOff;
+    strategy(args: IKeyObjectValue, posStr: string): void;
+    private _updateArgToOptions;
+    order(args: IOrderArgs, posStr: string): void;
+    entry(args: IOrderArgs, posStr: string): void;
+    close(args: IOrder, posStr: string): void;
+    close_all(args: IOrder, posStr: string): void;
+    close_all_long(args: IOrder, posStr: string): void;
+    close_all_short(args: IOrder, posStr: string): void;
+    cancel({ id }: {
+        id: string;
+    }, posStr: string): void;
+    cancel_all(posStr: string): void;
+    exit(args: IOrderArgs, posStr: string): void;
+    convert_to_account({ value }: IArgs, posStr: string): number | undefined;
+    convert_to_symbol({ value }: IArgs, posStr: string): number | undefined;
+    default_entry_qty({ fill_price }: IArgs, posStr: string): number;
+    private _calcDefaultQty;
+    private _calcExitQty;
+    private _getCommQty;
+    private _getLen;
+    private _getCapital;
+    private _calcProfitAndLoss;
+    private _calcProfitAndLossHandle;
+    private _calcOrderPercent;
+    private _calcLiquidate;
+    private _marginCallOrders;
+    private _orderHandle;
+    private _orderOnCloseHandle;
+    private _judgeCapitalEnough;
+    private _getOrderProfit;
+    private _ocaGroupVerify;
+    private _processOrders;
+    private _addPendingOrders;
+    private _orderArgsParse;
+    private _entryHandle;
+    private _entryOnCloseHandle;
+    private _getOrders;
+    private _entryOrder;
+    private _getAvailablePositionSize;
+    private _getEntryOrders;
+    private _addPendingEntry;
+    private _closeAllOrders;
+    private _closeAllPartOrders;
+    private _closeOrders;
+    private _closeOrder;
+    private _exitOrdersHandle;
+    private _updateExitOrders;
+    private _orderInExitHandle;
+    private _executesSort;
+    private _getLimitPrice;
+    private _getStopPrice;
+    private _getTrailStopPrice;
+    private _ordersHandle;
+    private _calcTrailStopPrice;
+    private _pendingOrderHandle;
+    private _pendingOrderSort;
+    private _pendingCloseOrderHandle;
+    private _onCloseOrderHandle;
+    private _entryOrderHandle;
+    private _orderOrderHandle;
+    private _getHisOrderSurplusQty;
+    private _getCloseOrders;
+    private _closeOrderHandle;
+    private _processCloseOrdersFIFO;
+    private _processCloseOrders;
+    private _exitOrderHandle;
+    private _getUnCloseOrders;
+    private _exit;
+    private _updateExitOrder;
+    private _calcUpdateExitOrderQty;
+    private _calcExitOrderQty;
+    private _ordersToExit;
+    private _calcLimitPrice;
+    private _calcStopPrice;
+    private _calcActivePrice;
+    private _stopProfit;
+    private _stopLoss;
+    private _trailStopLoss;
+    private _processExitOnClose;
+    private _processExitOrders;
+    private _processOrder;
+    private _calcPercent;
+    private _getCommission;
+    private _calcCurrentOrder;
+    private _calcOrderFillsHandle;
+    private _isNaN;
+    private _paramVerfiy;
+    _verfiyRequestFunc(posStr: string, name: string): void;
+}
+export {};

package/lib/components/editor/v6/parseScript/buildInFuncNamespace/string.d.ts

@@ -0,0 +1,55 @@
+import { TccErrorListener } from ".";
+import { BuiltInVariables } from "../buildInVariables";
+interface IStrArgs {
+    source?: string;
+    str?: string;
+    regex?: string;
+    string?: string;
+    separator?: string;
+    formatString?: string;
+    repeat?: number;
+    target?: string;
+    replacement?: string;
+    occurrence?: number;
+    value?: any;
+    format?: string;
+    begin_pos?: number;
+    end_pos?: number;
+    time?: number;
+    timezone?: string;
+}
+export default class BuildInStr {
+    private _errorListener;
+    private _intlNumberFormatter;
+    private _precision;
+    private _intlFormat;
+    private _variables;
+    constructor(errorListener: TccErrorListener, precision: number, variables: BuiltInVariables);
+    pos({ source, str }: IStrArgs): number;
+    trim({ source }: IStrArgs): string;
+    lower({ source }: IStrArgs): string;
+    match({ source, regex }: IStrArgs): string;
+    split({ string, separator }: IStrArgs): import("./array").IPseudoArray;
+    upper({ source }: IStrArgs): string;
+    format({ formatString }: IStrArgs, args: any[]): string;
+    length({ string }: IStrArgs): number;
+    repeat({ source, repeat, separator }: IStrArgs, posStr: string): string | undefined;
+    replace({ source, target, replacement, occurrence }: IStrArgs): string;
+    contains({ source, str }: IStrArgs): boolean;
+    endswith({ source, str }: IStrArgs): boolean;
+    tonumber({ string }: IStrArgs): number;
+    tostring({ value, format }: IStrArgs): string | undefined;
+    private _arrToStr;
+    substring({ source, begin_pos, end_pos }: IStrArgs): string;
+    startswith({ source, str }: IStrArgs): boolean;
+    format_time({ time, format, timezone }: IStrArgs): string;
+    replace_all({ source, target, replacement }: IStrArgs): string;
+    private _toStringFormat;
+    private _numberDef;
+    private _formatOthers;
+    private _formatNumber;
+    strformat({ formatString }: IStrArgs, args: any[], isFormat?: boolean): string;
+    private _parseObjectStr;
+    private _strFormat;
+}
+export {};

package/lib/components/editor/v6/parseScript/buildInFuncNamespace/syminfo.d.ts

@@ -0,0 +1,9 @@
+interface ISyminfoArgs {
+    symbol: string;
+}
+export default class Syminfo {
+    constructor();
+    prefix(args: ISyminfoArgs): string;
+    ticker(args: ISyminfoArgs): string;
+}
+export {};

package/lib/components/editor/v6/parseScript/buildInFuncNamespace/ta.d.ts

@@ -0,0 +1,125 @@
+import { IKeyObjectValue } from "../../../type";
+import { BuiltInVariables } from "../buildInVariables";
+import BuildInTimeframe from "./timeframe";
+import BuildInMath from "./math";
+interface ITaArgs {
+    series?: number;
+    length?: number;
+    offset?: number;
+    sigma?: number;
+    floor?: boolean;
+    source?: number;
+    condition?: boolean;
+    biased?: boolean;
+    mult?: number;
+    source1?: number;
+    source2?: number;
+    diLength?: number;
+    adxSmoothing?: number;
+    useTrueRange?: boolean;
+    fastlen?: number;
+    slowlen?: number;
+    siglen?: number;
+    percentage?: number;
+    type?: string;
+    anchor?: boolean;
+    developing?: boolean;
+    leftbars?: number;
+    rightbars?: number;
+    start?: number;
+    inc?: number;
+    max?: number;
+    high?: number;
+    low?: number;
+    factor?: number;
+    atrPeriod?: number;
+    handle_na?: boolean;
+    short_length?: number;
+    long_length?: number;
+    occurrence?: number;
+    stdev_mult?: number;
+    isSeriesLen?: boolean;
+}
+export default class BuildInTa {
+    private _cacheData;
+    private _variables;
+    private _math;
+    private _timeframe;
+    constructor(variables: BuiltInVariables, math: BuildInMath, timeframe: BuildInTimeframe);
+    get _taCacheData(): IKeyObjectValue;
+    set _taCacheData(data: IKeyObjectValue);
+    alma({ series, length, offset, sigma, floor, isSeriesLen }: ITaArgs, posStr: string): number | undefined;
+    sma({ source, length, isSeriesLen }: ITaArgs, posStr: string): number | undefined;
+    rma({ source, length, isSeriesLen }: ITaArgs, posStr: string): any;
+    atr({ length, isSeriesLen }: ITaArgs, posStr: string): any;
+    barssince({ condition }: ITaArgs, posStr: string): any;
+    stdev({ source, length, biased, isSeriesLen }: ITaArgs, posStr: string): number | undefined;
+    private _sum;
+    bb({ series, length, mult, isSeriesLen }: ITaArgs, posStr: string): number[];
+    bbw({ series, length, mult, isSeriesLen }: ITaArgs, posStr: string): number | undefined;
+    cci({ source, length, isSeriesLen }: ITaArgs, posStr: string): number | undefined;
+    change({ source, length, isSeriesLen }: ITaArgs, posStr: string): any;
+    cmo({ series, length }: ITaArgs, posStr: string): number | undefined;
+    cog({ source, length, isSeriesLen }: ITaArgs, posStr: string): number | undefined;
+    correlation({ source1, source2, length, isSeriesLen }: ITaArgs, posStr: string): number | undefined;
+    cross({ source1, source2 }: ITaArgs, posStr: string): any;
+    crossover({ source1, source2 }: ITaArgs, posStr: string): any;
+    crossunder({ source1, source2 }: ITaArgs, posStr: string): any;
+    cum({ source }: ITaArgs, posStr: string): any;
+    dev({ source, length, isSeriesLen }: ITaArgs, posStr: string): number | undefined;
+    dmi({ diLength, adxSmoothing }: ITaArgs, posStr: string): any;
+    ema({ source, length, isSeriesLen }: ITaArgs, posStr: string): any;
+    falling({ source, length }: ITaArgs, posStr: string): any;
+    rising({ source, length }: ITaArgs, posStr: string): any;
+    highest(args: ITaArgs, posStr: string): number | undefined;
+    highestbars(args: ITaArgs, posStr: string): number | undefined;
+    wma({ source, length, isSeriesLen }: ITaArgs, posStr: string): number | undefined;
+    hma({ source, length, isSeriesLen }: ITaArgs, posStr: string): number | undefined;
+    kc({ series, length, mult, useTrueRange, isSeriesLen }: ITaArgs, posStr: string): any[];
+    kcw({ series, length, mult, useTrueRange, isSeriesLen }: ITaArgs, posStr: string): number | undefined;
+    linreg({ source, length, offset, isSeriesLen }: ITaArgs, posStr: string): number | undefined;
+    lowest(args: ITaArgs, posStr: string): number | undefined;
+    lowestbars(args: ITaArgs, posStr: string): number | undefined;
+    macd({ source, fastlen, slowlen, siglen }: ITaArgs, posStr: string): any[];
+    max({ source }: ITaArgs, posStr: string): any;
+    min({ source }: ITaArgs, posStr: string): any;
+    median({ source, length, isSeriesLen }: ITaArgs, posStr: string): any;
+    mfi({ series, length }: ITaArgs, posStr: string): number | undefined;
+    mode({ source, length, isSeriesLen }: ITaArgs, posStr: string): any;
+    mom({ source, length, isSeriesLen }: ITaArgs, posStr: string): any;
+    percentile_linear_interpolation({ source, length, percentage, isSeriesLen }: ITaArgs, posStr: string): number | undefined;
+    percentile_nearest_rank({ source, length, percentage, isSeriesLen }: ITaArgs, posStr: string): number | undefined;
+    percentrank({ source, length, isSeriesLen }: ITaArgs, posStr: string): number | undefined;
+    pivot_point_levels({ type, anchor, developing }: ITaArgs, posStr: string): import("./array").IPseudoArray;
+    private _getPivotPointLevels;
+    private _traditional;
+    private _fibonacci;
+    private _woodie;
+    private _classic;
+    private _DM;
+    private _camarilla;
+    pivothigh(args: ITaArgs, posStr: string): any;
+    pivotlow(args: ITaArgs, posStr: string): any;
+    range({ source, length }: ITaArgs, posStr: string): number | undefined;
+    roc({ source, length, isSeriesLen }: ITaArgs, posStr: string): number | undefined;
+    rsi({ source, length, isSeriesLen }: ITaArgs, posStr: string): any;
+    sar({ start, inc, max }: ITaArgs, posStr: string): any;
+    stoch({ source, high, low, length, isSeriesLen }: ITaArgs, posStr: string): number | undefined;
+    supertrend({ factor, atrPeriod }: ITaArgs, posStr: string): any;
+    swma({ source }: ITaArgs, posStr: string): any;
+    tr({ handle_na }: ITaArgs, posStr: string): any;
+    tsi({ source, short_length, long_length }: ITaArgs, posStr: string): number | undefined;
+    private _doubleSmooth;
+    valuewhen({ condition, source, occurrence }: ITaArgs, posStr: string): any;
+    variance({ source, length, biased, isSeriesLen }: ITaArgs, posStr: string): number | undefined;
+    vwap({ source, anchor, stdev_mult }: ITaArgs, posStr: string): any;
+    private _computeBands;
+    vwma({ source, length, isSeriesLen }: ITaArgs, posStr: string): number | undefined;
+    wpr({ length, isSeriesLen }: ITaArgs, posStr: string): number | undefined;
+    private _sort;
+    private _cacheDataList;
+    private _getCacheData;
+    private _cacheDataHandle;
+    private _verifyCacheData;
+}
+export {};

package/lib/components/editor/v6/parseScript/buildInFuncNamespace/table.d.ts

@@ -0,0 +1,89 @@
+import { IKeyObjectValue } from "../../../type";
+import { BuiltInVariables } from "../buildInVariables";
+import { VPosition, VSize, VText } from "../enum";
+import { IDrawComponent } from "../type";
+import { TccErrorListener } from "./errorListener";
+export interface ITableArgs {
+    id?: string;
+    table_id?: IDrawComponent;
+    position?: VPosition;
+    columns?: number;
+    rows?: number;
+    bgcolor?: string;
+    frame_color?: string;
+    frame_width?: number;
+    border_color?: string;
+    border_width?: number;
+    cell?: (ITableCellArgs | undefined)[][];
+    start_column?: number;
+    start_row?: number;
+    end_column?: number;
+    end_row?: number;
+    merge_cells?: IMergeCell[];
+    merge_cell_ids?: IKeyObjectValue;
+}
+interface IMergeCell {
+    start_column?: number;
+    start_row?: number;
+    end_column?: number;
+    end_row?: number;
+}
+interface ITableCellArgs {
+    table_id?: IDrawComponent;
+    column?: number;
+    row?: number;
+    text?: string;
+    width?: number;
+    height?: number;
+    text_color?: string;
+    text_halign?: VText;
+    text_valign?: VText;
+    text_size?: VSize;
+    bgcolor?: string;
+    tooltip?: string;
+    text_font_family?: string;
+    isMerge?: boolean;
+    merge_columns?: number;
+    merge_rows?: number;
+}
+export default class BuildInTable {
+    private _variables;
+    private _errorListener;
+    private _updateIds;
+    private _defaultCell;
+    private _defaultTable;
+    constructor(variables: BuiltInVariables, errorListener: TccErrorListener);
+    get updateIds(): string[];
+    table({ x }: {
+        x?: IDrawComponent;
+    }): IDrawComponent | undefined;
+    new(args: ITableArgs, posStr: string): IDrawComponent;
+    private _paramVerfiy;
+    updateId(id: IDrawComponent): string;
+    cell({ table_id, ...args }: ITableCellArgs, posStr: string): void;
+    cell_set_bgcolor({ table_id, column, row, bgcolor }: ITableCellArgs, posStr: string): void;
+    cell_set_height({ table_id, column, row, height }: ITableCellArgs, posStr: string): void;
+    cell_set_text({ table_id, column, row, text }: ITableCellArgs, posStr: string): void;
+    cell_set_text_color({ table_id, column, row, text_color }: ITableCellArgs, posStr: string): void;
+    cell_set_text_font_family({ table_id, column, row, text_font_family }: ITableCellArgs, posStr: string): void;
+    cell_set_text_halign({ table_id, column, row, text_halign }: ITableCellArgs, posStr: string): void;
+    cell_set_text_valign({ table_id, column, row, text_valign }: ITableCellArgs, posStr: string): void;
+    cell_set_text_size({ table_id, column, row, text_size }: ITableCellArgs, posStr: string): void;
+    cell_set_tooltip({ table_id, column, row, tooltip }: ITableCellArgs, posStr: string): void;
+    cell_set_width({ table_id, column, row, width }: ITableCellArgs, posStr: string): void;
+    clear({ table_id, start_column, start_row, end_column, end_row }: ITableArgs, posStr: string): void;
+    delete({ table_id }: ITableArgs, posStr: string): void;
+    merge_cells({ table_id, start_column, start_row, end_column, end_row }: ITableArgs, posStr: string): void;
+    set_bgcolor({ table_id, bgcolor }: ITableArgs, posStr: string): void;
+    set_border_color({ table_id, border_color }: ITableArgs, posStr: string): void;
+    set_border_width({ table_id, border_width }: ITableArgs, posStr: string): void;
+    set_frame_color({ table_id, frame_color }: ITableArgs, posStr: string): void;
+    set_frame_width({ table_id, frame_width }: ITableArgs, posStr: string): void;
+    set_position({ table_id, position }: ITableArgs, posStr: string): void;
+    private _getTableItem;
+    private _getTable;
+    private _verfiyRequestFunc;
+    private _rowColToInt;
+}
+export declare function createTable(key: string, data: IKeyObjectValue): IDrawComponent;
+export {};

package/lib/components/editor/v6/parseScript/buildInFuncNamespace/timeframe.d.ts

@@ -0,0 +1,22 @@
+import { IKeyObjectValue } from "../../../type";
+import { BuiltInVariables } from "../buildInVariables";
+interface ITimeArgs {
+    timeframe?: string;
+    session?: string;
+    timezone?: string;
+    bars_back?: number;
+    time?: number;
+    seconds?: number;
+}
+export default class BuildInTimeframe {
+    private _variables;
+    private _cacheData;
+    constructor(variables: BuiltInVariables);
+    get _timeframeCacheData(): IKeyObjectValue;
+    set _timeframeCacheData(data: IKeyObjectValue);
+    change({ timeframe }: ITimeArgs, posStr: string): any;
+    in_seconds({ timeframe }?: ITimeArgs): number;
+    from_seconds({ seconds }: ITimeArgs): string;
+    private _calcTimeOffset;
+}
+export {};

package/lib/components/editor/v6/parseScript/buildInVarNamespace/barstate.d.ts

@@ -0,0 +1,22 @@
+import { IKeyObjectValue } from "../../../type";
+export declare class Barstate {
+    private _isMarketOpen;
+    private _currentBarIndex;
+    private _totalBarIndex;
+    private _isRealTimeBar;
+    private _preBarIndex;
+    private _preIsRealTimeBar;
+    private _isFirstRun;
+    constructor();
+    update(currentBarIndex: number, totalBarIndex: number, isRealTimeBar: boolean, isMarketOpen: boolean): void;
+    get _barstateCacheData(): IKeyObjectValue;
+    set _barstateCacheData(val: IKeyObjectValue);
+    set isFirstRun(status: boolean);
+    get isnew(): boolean;
+    get islast(): boolean;
+    get isfirst(): boolean;
+    get ishistory(): boolean;
+    get isrealtime(): boolean;
+    get isconfirmed(): boolean;
+    get islastconfirmedhistory(): boolean;
+}

package/lib/components/editor/v6/parseScript/buildInVarNamespace/chart.d.ts

@@ -0,0 +1,21 @@
+import { IKeyObjectValue } from "../../../type";
+export declare class Chart {
+    private _bgColor?;
+    private _fgColor?;
+    isUseBgColor: boolean;
+    updateOptions(options: IKeyObjectValue): void;
+    get bg_color(): string | undefined;
+    get fg_color(): string | undefined;
+    get is_heikinashi(): boolean;
+    get is_kagi(): boolean;
+    get is_linebreak(): boolean;
+    get is_pnf(): boolean;
+    get is_range(): boolean;
+    get is_renko(): boolean;
+    get is_standard(): boolean;
+    get left_visible_bar_time(): undefined;
+    get right_visible_bar_time(): undefined;
+    private _parseColor;
+    private _parserRgbColor;
+    private _contrastColor;
+}

package/lib/components/editor/v6/parseScript/buildInVarNamespace/dividends.d.ts

@@ -0,0 +1,8 @@
+import { BuiltInVariables } from "../buildInVariables";
+export declare class Dividends {
+    private _variables;
+    constructor(variables: BuiltInVariables);
+    get future_amount(): undefined;
+    get future_ex_date(): undefined;
+    get future_pay_date(): undefined;
+}

package/lib/components/editor/v6/parseScript/buildInVarNamespace/earnings.d.ts

@@ -0,0 +1,9 @@
+import { BuiltInVariables } from "../buildInVariables";
+export declare class Earnings {
+    private _variables;
+    constructor(variables: BuiltInVariables);
+    get future_eps(): undefined;
+    get future_period_end_time(): undefined;
+    get future_revenue(): undefined;
+    get future_time(): undefined;
+}

package/lib/components/editor/v6/parseScript/buildInVarNamespace/index.d.ts

@@ -0,0 +1,9 @@
+export { Barstate } from './barstate';
+export { Session } from './session';
+export { Strategy } from './strategy';
+export { Ta } from './ta';
+export { Timeframe } from './timeframe';
+export { Chart } from './chart';
+export { Syminfo } from './syminfo';
+export { Dividends } from './dividends';
+export { Earnings } from './earnings';

package/lib/components/editor/v6/parseScript/buildInVarNamespace/session.d.ts

@@ -0,0 +1,12 @@
+import { BuiltInVariables } from "../buildInVariables";
+export declare class Session {
+    private _variables;
+    constructor(variables: BuiltInVariables);
+    get isfirstbar(): boolean;
+    get isfirstbar_regular(): boolean;
+    get islastbar(): boolean;
+    get islastbar_regular(): boolean;
+    get ismarket(): boolean;
+    get ispostmarket(): boolean;
+    get ispremarket(): boolean;
+}