@guihz/trading-vue-editor-tes 0.0.301 → 0.1.1

package/lib/components/editor/v4/parseScript/buildInConstants.d.ts

@@ -0,0 +1,308 @@
+import { VPlotDisplay, VExtend, VDividends, VFormatType, VHlineStyle, VLabelStyle, VLineStyle, VLocation, VPlotStyle, VPosition, VAdjustment, VAlert, VScale, VSession, VShape, VSize, VStrategy, VCommission, VDirection, VOca, VText, VXloc, VYloc, VEarnings, VInputType } from './enum';
+export declare const COLOR_BUILD_IN: {
+    aqua: string;
+    black: string;
+    blue: string;
+    fuchsia: string;
+    gray: string;
+    green: string;
+    lime: string;
+    maroon: string;
+    navy: string;
+    olive: string;
+    orange: string;
+    purple: string;
+    red: string;
+    silver: string;
+    teal: string;
+    white: string;
+    yellow: string;
+};
+export declare const CURRENCY_BUILD_IN: {
+    AUD: string;
+    BTC: string;
+    CAD: string;
+    CHF: string;
+    ETH: string;
+    EUR: string;
+    GBP: string;
+    HKD: string;
+    INR: string;
+    JPY: string;
+    KRW: string;
+    MYR: string;
+    NOK: string;
+    NONE: string;
+    NZD: string;
+    RUB: string;
+    SEK: string;
+    SGD: string;
+    TRY: string;
+    USD: string;
+    USDT: string;
+    ZAR: string;
+};
+export declare const DISPLAY_BUILD_IN: {
+    all: VPlotDisplay[];
+    none: never[];
+};
+export declare class BuildInConstants {
+    adjustment: {
+        dividends: VAdjustment;
+        none: VAdjustment;
+        splits: VAdjustment;
+    };
+    alert: {
+        freq_all: VAlert;
+        freq_once_per_bar: VAlert;
+        freq_once_per_bar_close: VAlert;
+    };
+    barmerge: {
+        gaps_off: boolean;
+        gaps_on: boolean;
+        lookahead_off: boolean;
+        lookahead_on: boolean;
+    };
+    color: {
+        aqua: string;
+        black: string;
+        blue: string;
+        fuchsia: string;
+        gray: string;
+        green: string;
+        lime: string;
+        maroon: string;
+        navy: string;
+        olive: string;
+        orange: string;
+        purple: string;
+        red: string;
+        silver: string;
+        teal: string;
+        white: string;
+        yellow: string;
+    };
+    currency: {
+        AUD: string;
+        BTC: string;
+        CAD: string;
+        CHF: string;
+        ETH: string;
+        EUR: string;
+        GBP: string;
+        HKD: string;
+        INR: string;
+        JPY: string;
+        KRW: string;
+        MYR: string;
+        NOK: string;
+        NONE: string;
+        NZD: string;
+        RUB: string;
+        SEK: string;
+        SGD: string;
+        TRY: string;
+        USD: string;
+        USDT: string;
+        ZAR: string;
+    };
+    dayofweek: {
+        friday: number;
+        monday: number;
+        saturday: number;
+        sunday: number;
+        thursday: number;
+        tuesday: number;
+        wednesday: number;
+    };
+    earnings: {
+        actual: VEarnings;
+        estimate: VEarnings;
+    };
+    display: {
+        all: VPlotDisplay[];
+        none: never[];
+    };
+    dividends: {
+        gross: VDividends;
+        net: VDividends;
+    };
+    extend: {
+        both: VExtend;
+        left: VExtend;
+        none: VExtend;
+        right: VExtend;
+    };
+    format: {
+        inherit: VFormatType;
+        mintick: VFormatType;
+        percent: VFormatType;
+        price: VFormatType;
+        volume: VFormatType;
+    };
+    hline: {
+        style_solid: VHlineStyle;
+        style_dashed: VHlineStyle;
+        style_dotted: VHlineStyle;
+    };
+    input: {
+        bool: VInputType;
+        color: VInputType;
+        float: VInputType;
+        integer: VInputType;
+        string: VInputType;
+        symbol: VInputType;
+        price: VInputType;
+        time: VInputType;
+        session: VInputType;
+        resolution: VInputType;
+        source: VInputType;
+    };
+    label: {
+        style_arrowdown: VLabelStyle;
+        style_arrowup: VLabelStyle;
+        style_circle: VLabelStyle;
+        style_cross: VLabelStyle;
+        style_diamond: VLabelStyle;
+        style_flag: VLabelStyle;
+        style_label_center: VLabelStyle;
+        style_label_down: VLabelStyle;
+        style_label_left: VLabelStyle;
+        style_label_lower_left: VLabelStyle;
+        style_label_lower_right: VLabelStyle;
+        style_label_right: VLabelStyle;
+        style_label_up: VLabelStyle;
+        style_label_upper_left: VLabelStyle;
+        style_label_upper_right: VLabelStyle;
+        style_none: VLabelStyle;
+        style_square: VLabelStyle;
+        style_text_outline: VLabelStyle;
+        style_triangledown: VLabelStyle;
+        style_triangleup: VLabelStyle;
+        style_xcross: VLabelStyle;
+    };
+    line: {
+        style_arrow_both: VLineStyle;
+        style_arrow_left: VLineStyle;
+        style_arrow_right: VLineStyle;
+        style_dashed: VLineStyle;
+        style_dotted: VLineStyle;
+        style_solid: VLineStyle;
+    };
+    location: {
+        abovebar: VLocation;
+        absolute: VLocation;
+        belowbar: VLocation;
+        bottom: VLocation;
+        top: VLocation;
+    };
+    math: {
+        e: number;
+        phi: number;
+        pi: number;
+        rphi: number;
+    };
+    order: {
+        ascending: boolean;
+        descending: boolean;
+    };
+    plot: {
+        style_area: VPlotStyle;
+        style_areabr: VPlotStyle;
+        style_circles: VPlotStyle;
+        style_columns: VPlotStyle;
+        style_cross: VPlotStyle;
+        style_histogram: VPlotStyle;
+        style_line: VPlotStyle;
+        style_linebr: VPlotStyle;
+        style_stepline: VPlotStyle;
+        style_stepline_diamond: VPlotStyle;
+        style_steplinebr: VPlotStyle;
+    };
+    position: {
+        bottom_center: VPosition;
+        bottom_left: VPosition;
+        bottom_right: VPosition;
+        middle_center: VPosition;
+        middle_left: VPosition;
+        middle_right: VPosition;
+        top_center: VPosition;
+        top_left: VPosition;
+        top_right: VPosition;
+    };
+    scale: {
+        left: VScale;
+        none: VScale;
+        right: VScale;
+    };
+    session: {
+        extended: VSession;
+        regular: VSession;
+    };
+    shape: {
+        arrowdown: VShape;
+        arrowup: VShape;
+        circle: VShape;
+        cross: VShape;
+        diamond: VShape;
+        flag: VShape;
+        labeldown: VShape;
+        labelup: VShape;
+        square: VShape;
+        triangledown: VShape;
+        triangleup: VShape;
+        xcross: VShape;
+    };
+    size: {
+        auto: VSize;
+        huge: VSize;
+        large: VSize;
+        normal: VSize;
+        small: VSize;
+        tiny: VSize;
+    };
+    splits: {
+        denominator: string;
+        numerator: string;
+    };
+    strategy: {
+        cash: VStrategy;
+        fixed: VStrategy;
+        percent_of_equity: VStrategy;
+        long: boolean;
+        short: boolean;
+        commission: {
+            cash_per_contract: VCommission;
+            cash_per_order: VCommission;
+            percent: VCommission;
+        };
+        direction: {
+            all: VDirection;
+            long: VDirection;
+            short: VDirection;
+        };
+        oca: {
+            cancel: VOca;
+            none: VOca;
+            reduce: VOca;
+        };
+    };
+    text: {
+        align_bottom: VText;
+        align_center: VText;
+        align_left: VText;
+        align_right: VText;
+        align_top: VText;
+    };
+    xloc: {
+        bar_index: VXloc;
+        bar_time: VXloc;
+    };
+    yloc: {
+        abovebar: VYloc;
+        belowbar: VYloc;
+        price: VYloc;
+    };
+    true: boolean;
+    false: boolean;
+}

package/lib/components/editor/v4/parseScript/buildInFuncNamespace/array.d.ts

@@ -0,0 +1,84 @@
+import { VInsType } from "../enum";
+import { TccErrorListener } from ".";
+interface IArrayArgs {
+    id?: IPseudoArray;
+    id1?: IPseudoArray;
+    id2?: IPseudoArray;
+    size?: number;
+    initial_value?: any;
+    index_from?: number;
+    index_to?: number;
+    val?: number;
+    biased?: boolean;
+    value?: any;
+    index?: number;
+    separator?: string;
+    nth?: number;
+    percentage?: number;
+    order?: boolean;
+    type?: string;
+}
+export default class BuildInArray {
+    private _errorListener;
+    constructor(errorListener: TccErrorListener);
+    new_float({ size, initial_value }?: IArrayArgs): IPseudoArray;
+    new_int({ size, initial_value }?: IArrayArgs): IPseudoArray;
+    new_color({ size, initial_value }?: IArrayArgs): IPseudoArray;
+    new_bool({ size, initial_value }?: IArrayArgs): IPseudoArray;
+    new_string({ size, initial_value }?: IArrayArgs): IPseudoArray;
+    new_line({ size, initial_value }?: IArrayArgs): IPseudoArray;
+    new_box({ size, initial_value }?: IArrayArgs): IPseudoArray;
+    new_table({ size, initial_value }?: IArrayArgs): IPseudoArray;
+    new_label({ size, initial_value }?: IArrayArgs): IPseudoArray;
+    copy({ id }: IArrayArgs): IPseudoArray | undefined;
+    slice({ id, index_from, index_to }: IArrayArgs): IPseudoArray | undefined;
+    size({ id }: IArrayArgs): number | undefined;
+    avg({ id }: IArrayArgs, posStr: string): number | undefined;
+    clear({ id }: IArrayArgs): void;
+    concat({ id1, id2 }: IArrayArgs): IPseudoArray | undefined;
+    covariance({ id1, id2 }: IArrayArgs, posStr: string): number | undefined;
+    from(_: any, arrVals: any[]): IPseudoArray;
+    fill({ id, value, index_from, index_to }: IArrayArgs): void;
+    get({ id, index }: IArrayArgs): any;
+    includes({ id, value }: IArrayArgs): boolean | undefined;
+    indexof({ id, value }: IArrayArgs): number | undefined;
+    insert({ id, index, value }: IArrayArgs): void;
+    join({ id, separator }: IArrayArgs, posStr: string): string | undefined;
+    lastindexof({ id, value }: IArrayArgs): number | undefined;
+    max(arg: IArrayArgs, posStr: string): number | undefined;
+    median({ id }: IArrayArgs, posStr: string): number | undefined;
+    min({ id }: IArrayArgs, posStr: string): number | undefined;
+    mode({ id }: IArrayArgs, posStr: string): number | undefined;
+    pop({ id }: IArrayArgs): any;
+    push({ id, value }: IArrayArgs): void;
+    range({ id }: IArrayArgs, posStr: string): number | undefined;
+    remove({ id, index }: IArrayArgs): any;
+    reverse({ id }: IArrayArgs): void;
+    set({ id, index, value }: IArrayArgs): void;
+    shift({ id }: IArrayArgs): any;
+    sort({ id, order }: IArrayArgs, posStr: string): void;
+    standardize({ id }: IArrayArgs, posStr: string): IPseudoArray | undefined;
+    stdev({ id }: IArrayArgs, posStr: string): number | undefined;
+    sum({ id }: IArrayArgs, posStr: string): any;
+    unshift({ id, value }: IArrayArgs): void;
+    variance({ id }: IArrayArgs, posStr: string): number | undefined;
+    private _calculateVariances;
+    private _calculateStandardDeviations;
+    private _standardizeArray;
+    private _mode;
+    private _median;
+    private _minNth;
+    private _maxNth;
+    private _setElements;
+    private _covariance;
+    private _verifySimpleType;
+}
+export interface IPseudoArray {
+    isArray: boolean;
+    typeName?: string;
+    type: VInsType;
+    _isNumber: boolean;
+    _value: any[];
+}
+export declare function createPseudoArray(size?: number, initialValue?: any, type?: string): IPseudoArray;
+export {};

package/lib/components/editor/v4/parseScript/buildInFuncNamespace/box.d.ts

@@ -0,0 +1,60 @@
+import { IKeyObjectValue } from "../../../type";
+import { BuiltInVariables } from "../buildInVariables";
+import { VExtend, VLineStyle, VXloc } from "../enum";
+import { IDrawComponent } from "../type";
+import { TccErrorListener } from "./index";
+export interface IBoxArgs {
+    id?: string;
+    left?: number;
+    top?: number;
+    right?: number;
+    bottom?: number;
+    border_color?: string;
+    border_width?: number;
+    border_style?: VLineStyle;
+    style?: VLineStyle;
+    xloc?: VXloc;
+    bgcolor?: string;
+    extend?: VExtend;
+    color?: string;
+    width?: number;
+    bar_index?: number;
+}
+type VBoxArgs = Omit<IBoxArgs, 'id'> & {
+    id: IDrawComponent;
+};
+export default class BuildInBox {
+    private _variables;
+    private _errorListener;
+    private _updateIds;
+    private _defaultBox;
+    constructor(variables: BuiltInVariables, errorListener: TccErrorListener);
+    get updateIds(): string[];
+    box({ x }: {
+        x?: IDrawComponent;
+    }): IDrawComponent | undefined;
+    new(args: IBoxArgs, posStr: string): IDrawComponent;
+    private _verfiyArgs;
+    private _paramVerfiy;
+    updateId(box: IDrawComponent): string;
+    copy({ id }: VBoxArgs, posStr: string): IDrawComponent | undefined;
+    delete({ id }: VBoxArgs, posStr: string): void;
+    get_top({ id }: VBoxArgs, posStr: string): any;
+    get_bottom({ id }: VBoxArgs, posStr: string): any;
+    get_left({ id }: VBoxArgs, posStr: string): any;
+    get_right({ id }: VBoxArgs, posStr: string): any;
+    set_top({ id, top }: VBoxArgs, posStr: string): void;
+    set_bottom({ id, bottom }: VBoxArgs, posStr: string): void;
+    set_left({ id, left }: VBoxArgs, posStr: string): void;
+    set_right({ id, right }: VBoxArgs, posStr: string): void;
+    set_extend({ id, extend }: VBoxArgs, posStr: string): void;
+    set_bgcolor({ id, color }: VBoxArgs, posStr: string): void;
+    set_border_color({ id, color }: VBoxArgs, posStr: string): void;
+    set_border_width({ id, width }: VBoxArgs, posStr: string): void;
+    set_border_style({ id, style }: VBoxArgs, posStr: string): void;
+    set_lefttop({ id, left, top }: VBoxArgs, posStr: string): void;
+    set_rightbottom({ id, right, bottom }: VBoxArgs, posStr: string): void;
+    private _getBox;
+}
+export declare function createBox(key: string, data: IKeyObjectValue): IDrawComponent;
+export {};

package/lib/components/editor/v4/parseScript/buildInFuncNamespace/errorListener.d.ts

@@ -0,0 +1,9 @@
+import { IError, VMarkerSeverity } from '../type';
+export declare class TccErrorListener {
+    private _errors;
+    constructor();
+    clear(): void;
+    get errors(): IError[];
+    setErrors(errors: IError[], key: string): void;
+    addError(message: string, posStr: string, type: VMarkerSeverity, length?: number): void;
+}

package/lib/components/editor/v4/parseScript/buildInFuncNamespace/index.d.ts

@@ -0,0 +1,17 @@
+import BuildInArray, { createPseudoArray } from "./array";
+import BuildInMath from "./math";
+import BuildInTa from "./ta";
+import BuildInInput from "./input";
+import BuildInColor from "./color";
+import BuildInTimeframe from "./timeframe";
+import BuildInStr from "./string";
+import BuildInLabel, { PartialLabelArgs } from "./label";
+import BuildInLine, { ILineArgs, ILine } from "./line";
+import BuildInBox, { IBoxArgs } from "./box";
+import BuildInTable, { ITableArgs } from "./table";
+import Strategy, { IOrder, IStrategy } from './strategy';
+import Request from './request';
+export { TccErrorListener } from './errorListener';
+export type { IColorArgs } from './color';
+export { BuildInArray, BuildInMath, BuildInTa, BuildInInput, BuildInColor, BuildInTimeframe, BuildInStr, createPseudoArray, BuildInLabel, BuildInLine, BuildInBox, BuildInTable, Strategy, Request };
+export type { PartialLabelArgs, ILineArgs, IBoxArgs, ITableArgs, IOrder, IStrategy, ILine };

package/lib/components/editor/v4/parseScript/buildInFuncNamespace/input.d.ts

@@ -0,0 +1,44 @@
+import { BuildInTa } from ".";
+import { BuiltInVariables } from "../buildInVariables";
+import { VInputType, VPlotDisplay } from "../enum";
+import { TccErrorListener } from "./errorListener";
+type TSimpleType = string | number | boolean;
+interface IInputArgs {
+    id: string;
+    defval: TSimpleType;
+    title?: string;
+    tooltip?: string;
+    inline?: string;
+    type?: VInputType;
+    group?: string;
+    display?: VPlotDisplay[];
+    sourceTypeName?: string;
+    isModify?: boolean;
+    options?: TSimpleType[];
+    confirm?: boolean;
+    minval?: number;
+    maxval?: number;
+    step?: number;
+    inputType?: VInputType;
+    index?: number;
+    modifyDefval?: TSimpleType;
+}
+interface ICacheData {
+    [key: string]: IInputArgs;
+}
+declare class Input extends BuildInTa {
+    private _inputCacheDataLoc;
+    protected _errorListener: TccErrorListener;
+    private _historyInputs;
+    private _name;
+    private _newCacheData;
+    constructor(variables: BuiltInVariables, id: string);
+    get _inputCacheData(): ICacheData;
+    set _inputCacheData(data: ICacheData);
+    updateInput(vals?: IInputArgs[]): void;
+    input(args: IInputArgs, posStr: string): TSimpleType;
+    private _cacheHandle;
+    private _verifyMaxOrMin;
+    getInputs(): IInputArgs[];
+}
+export default Input;

package/lib/components/editor/v4/parseScript/buildInFuncNamespace/label.d.ts

@@ -0,0 +1,61 @@
+import { IKeyObjectValue } from "../../../type";
+import { BuiltInVariables } from "../buildInVariables";
+import { VLabelStyle, VSize, VText, VXloc, VYloc } from "../enum";
+import { IDrawComponent } from "../type";
+import { TccErrorListener } from "./index";
+interface ILabelArgs {
+    id: string;
+    text: string;
+    x: number;
+    y: number;
+    xloc: VXloc;
+    yloc: VYloc;
+    color: string;
+    size: VSize;
+    style: VLabelStyle;
+    textalign: VText;
+    textcolor: string;
+    tooltip: string;
+    text_font_family: string;
+    force_overlay: boolean;
+}
+export type PartialLabelArgs = Partial<ILabelArgs>;
+type TLabelArgs = Omit<PartialLabelArgs, 'id'> & {
+    id: IDrawComponent;
+};
+export default class BuildInLabel {
+    private _variables;
+    private _errorListener;
+    private _updateIds;
+    private _defaultLabel;
+    constructor(variables: BuiltInVariables, errorListener: TccErrorListener);
+    get updateIds(): string[];
+    new(args: PartialLabelArgs, posStr: string): IDrawComponent;
+    private _paramVerfiyHandle;
+    private _verfiyArgs;
+    private _paramVerfiy;
+    updateId(id: IDrawComponent): string;
+    label(args: {
+        x?: IDrawComponent;
+    }): IDrawComponent | undefined;
+    copy({ id }: TLabelArgs, posStr: string): IDrawComponent | undefined;
+    get_x({ id }: TLabelArgs, posStr: string): any;
+    get_y({ id }: TLabelArgs, posStr: string): any;
+    set_x({ id, x }: TLabelArgs, posStr: string): void;
+    set_y({ id, y }: TLabelArgs, posStr: string): void;
+    delete({ id }: TLabelArgs, posStr: string): void;
+    get_text({ id }: TLabelArgs, posStr: string): any;
+    set_xy({ id, x, y }: TLabelArgs, posStr: string): void;
+    set_size({ id, size }: TLabelArgs, posStr: string): void;
+    set_xloc({ id, x, xloc }: TLabelArgs, posStr: string): void;
+    set_yloc({ id, yloc }: TLabelArgs, posStr: string): void;
+    set_style({ id, style }: TLabelArgs, posStr: string): void;
+    set_color({ id, ...args }: TLabelArgs, posStr: string): void;
+    set_tooltip({ id, tooltip }: TLabelArgs, posStr: string): void;
+    set_text({ id, text }: TLabelArgs, posStr: string): void;
+    set_textcolor({ id, ...args }: TLabelArgs, posStr: string): void;
+    set_textalign({ id, textalign }: TLabelArgs, posStr: string): void;
+    private _getLabel;
+}
+export declare function createLabel(key: string, data: IKeyObjectValue): IDrawComponent;
+export {};

package/lib/components/editor/v4/parseScript/buildInFuncNamespace/line.d.ts

@@ -0,0 +1,62 @@
+import { IKeyObjectValue } from "../../../type";
+import { BuiltInVariables } from "../buildInVariables";
+import { VExtend, VLineStyle, VXloc } from "../enum";
+import { IDrawComponent } from "../type";
+import { TccErrorListener } from "./index";
+export interface ILineArgs {
+    id?: string;
+    x?: number;
+    y?: number;
+    x1?: number;
+    y1?: number;
+    x2?: number;
+    y2?: number;
+    xloc?: VXloc;
+    extend?: VExtend;
+    color?: string;
+    style?: VLineStyle;
+    width?: number;
+    bar_index?: number;
+    isVar?: boolean;
+}
+type LineArgs = Omit<ILineArgs, 'id'> & {
+    id: ILine;
+};
+export default class BuildInLine {
+    private _variables;
+    private _errorListener;
+    private _updateIds;
+    private _defaultLine;
+    constructor(variables: BuiltInVariables, errorListener: TccErrorListener);
+    get updateIds(): string[];
+    new(args: ILineArgs, posStr: string): ILine;
+    private _verfiyArgs;
+    private _paramVerfiy;
+    updateId(id: ILine): string;
+    line(args: {
+        x?: ILine;
+    }): ILine | undefined;
+    copy({ id }: LineArgs, posStr: string): ILine | undefined;
+    delete({ id }: LineArgs, posStr: string): void;
+    get_x1({ id }: LineArgs, posStr: string): any;
+    get_x2({ id }: LineArgs, posStr: string): any;
+    get_y1({ id }: LineArgs, posStr: string): any;
+    get_y2({ id }: LineArgs, posStr: string): any;
+    set_x1({ id, x }: LineArgs, posStr: string): void;
+    set_x2({ id, x }: LineArgs, posStr: string): void;
+    set_y1({ id, y }: LineArgs, posStr: string): void;
+    set_y2({ id, y }: LineArgs, posStr: string): void;
+    set_xy1({ id, x, y }: LineArgs, posStr: string): void;
+    set_xy2({ id, x, y }: LineArgs, posStr: string): void;
+    set_xloc({ id, xloc, x1, x2 }: LineArgs, posStr: string): void;
+    get_price({ id, x }: LineArgs, posStr: string): any;
+    set_color({ id, ...args }: LineArgs, posStr: string): void;
+    set_style({ id, style }: LineArgs, posStr: string): void;
+    set_width({ id, width }: LineArgs, posStr: string): void;
+    set_extend({ id, extend }: LineArgs, posStr: string): void;
+    private _getLine;
+}
+export interface ILine extends IDrawComponent {
+}
+export declare function createLine(key: string, data: IKeyObjectValue): ILine;
+export {};

package/lib/components/editor/v4/parseScript/buildInFuncNamespace/math.d.ts

@@ -0,0 +1,50 @@
+import { IKeyObjectValue } from "../../../type";
+interface IMathArgs {
+    number?: number;
+    x?: number;
+    angle?: number;
+    base?: number;
+    exponent?: number;
+    min?: number;
+    max?: number;
+    seed?: number;
+    precision?: number;
+    source?: number;
+    length?: number;
+    radians?: number;
+    degrees?: number;
+}
+export default class BuildInMath {
+    private _mintick;
+    private _mathCacheDataLoc;
+    private _barIndex;
+    constructor(mintick: number);
+    get _mathCacheData(): IKeyObjectValue;
+    set _mathCacheData(val: IKeyObjectValue);
+    updateMath(barIndex: number): void;
+    abs({ x }: IMathArgs): number;
+    acos({ x }: IMathArgs): number;
+    asin({ x }: IMathArgs): number;
+    atan({ x }: IMathArgs): number;
+    avg(_: IMathArgs, numbers: number[]): number;
+    ceil({ x }: IMathArgs): number;
+    floor({ x }: IMathArgs): number;
+    cos({ x }: IMathArgs): number;
+    sin({ x }: IMathArgs): number;
+    tan({ x }: IMathArgs): number;
+    exp({ x }: IMathArgs): number;
+    log({ x }: IMathArgs): number;
+    log10({ x }: IMathArgs): number;
+    max(_: IMathArgs, numbers: number[]): number | undefined;
+    min(_: IMathArgs, numbers: number[]): number | undefined;
+    pow({ base, exponent }: IMathArgs): number;
+    random({ min, max, seed }: IMathArgs): number;
+    round({ x, number, precision }: IMathArgs): number;
+    round_to_mintick({ x }: IMathArgs): number;
+    sign({ x }: IMathArgs): number | undefined;
+    sqrt({ x }: IMathArgs): number;
+    sum({ source, length }: IMathArgs, posStr: string): number | undefined;
+    todegrees({ radians }: IMathArgs): number;
+    toradians({ degrees }: IMathArgs): number;
+}
+export {};