trading-signals/dist/index.d.ts

Technical indicators to run technical analysis with JavaScript / TypeScript.

import * as Big$1 from 'big.js';
import Big__default, { BigSource, Big as Big$2 } from 'big.js';
export { default as Big, BigSource } from 'big.js';

type Nullable<Result> = Result | null;
interface Indicator<Result = Big, Input = BigSource> {
    isStable: boolean;
    add(input: Input): Nullable<Result>;
    getResult(): Nullable<Result>;
    getResultOrThrow(): Result;
    replace(input: Input): Nullable<Result>;
    update(input: Input, replace: boolean): Nullable<Result>;
    updates(input: Input[], replace: boolean): Nullable<Result>[];
}
declare abstract class TechnicalIndicator<Result, Input> implements Indicator<Result, Input> {
    protected result: Result | undefined;
    getResult(): (Result & {}) | null;
    getResultOrThrow(): Result & ({} | null);
    get isStable(): boolean;
    add(input: Input): Result | null;
    replace(input: Input): Result | null;
    abstract update(input: Input, replace: boolean): Result | null;
    updates(inputs: readonly Input[], replace?: boolean): (Result | null)[];
}
declare abstract class BaseIndicatorSeries<Result, Input> extends TechnicalIndicator<Result, Input> {
    protected previousHighest?: Result;
    highest?: Result;
    protected previousLowest?: Result;
    lowest?: Result;
    protected previousResult?: Result;
    protected abstract setResult(value: Result, replace: boolean): Result;
}
declare abstract class BigIndicatorSeries<Input = BigSource> extends BaseIndicatorSeries<Big, Input> {
    protected setResult(value: Big, replace: boolean): Big;
}
declare abstract class NumberIndicatorSeries<Input = number> extends BaseIndicatorSeries<number, Input> {
    protected setResult(value: number, replace: boolean): number;
}

declare abstract class MovingAverage extends BigIndicatorSeries {
    readonly interval: number;
    constructor(interval: number);
}
declare abstract class FasterMovingAverage extends NumberIndicatorSeries {
    readonly interval: number;
    constructor(interval: number);
}

declare class EMA extends MovingAverage {
    readonly interval: number;
    private pricesCounter;
    private readonly weightFactor;
    constructor(interval: number);
    update(_price: BigSource, replace: boolean): Big__default;
    getResultOrThrow(): Big__default;
    get isStable(): boolean;
}
declare class FasterEMA extends FasterMovingAverage {
    readonly interval: number;
    private pricesCounter;
    private readonly weightFactor;
    constructor(interval: number);
    update(price: number, replace: boolean): number;
    getResultOrThrow(): number;
    get isStable(): boolean;
}

declare class WSMA extends MovingAverage {
    readonly interval: number;
    private readonly indicator;
    private readonly smoothingFactor;
    constructor(interval: number);
    update(price: BigSource, replace: boolean): Big__default.Big | null;
}
declare class FasterWSMA extends NumberIndicatorSeries {
    readonly interval: number;
    private readonly indicator;
    private readonly smoothingFactor;
    constructor(interval: number);
    update(price: number, replace: boolean): number | null;
}

declare class SMA extends MovingAverage {
    readonly prices: BigSource[];
    update(price: BigSource, replace: boolean): Big$1.Big | null;
}
declare class FasterSMA extends FasterMovingAverage {
    readonly prices: number[];
    update(price: number, replace: boolean): number | null;
}

declare class WMA extends MovingAverage {
    readonly interval: number;
    readonly prices: BigSource[];
    constructor(interval: number);
    update(price: BigSource, replace: boolean): Big__default.Big | null;
}
declare class FasterWMA extends FasterMovingAverage {
    readonly interval: number;
    readonly prices: number[];
    constructor(interval: number);
    update(price: number, replace: boolean): number | null;
}

declare class RMA extends MovingAverage {
    readonly interval: number;
    private pricesCounter;
    private readonly weightFactor;
    constructor(interval: number);
    update(_price: BigSource, replace: boolean): Big__default;
    getResultOrThrow(): Big__default;
    get isStable(): boolean;
}
declare class FasterRMA extends FasterMovingAverage {
    readonly interval: number;
    private pricesCounter;
    private readonly weightFactor;
    constructor(interval: number);
    update(price: number, replace: boolean): number;
    getResultOrThrow(): number;
    get isStable(): boolean;
}

type MovingAverageTypes = typeof EMA | typeof RMA | typeof SMA | typeof WMA | typeof WSMA;
type FasterMovingAverageTypes = typeof FasterEMA | typeof FasterRMA | typeof FasterSMA | typeof FasterWMA | typeof FasterWSMA;

interface BandsResult {
    lower: Big$2;
    middle: Big$2;
    upper: Big$2;
}
interface FasterBandsResult {
    lower: number;
    middle: number;
    upper: number;
}

declare function getAverage(values: BigSource[]): Big__default;
declare function getFasterAverage(values: number[]): number;

declare function getMaximum(values: BigSource[]): Big__default;

declare function getMinimum(values: BigSource[]): Big__default;

declare function getStandardDeviation(values: BigSource[], average?: BigSource): Big__default;
declare function getFasterStandardDeviation(values: number[], average?: number): number;

type Streak = {
    length: number;
    percentage: number;
};
declare function getStreaks(prices: number[], keepSide: 'up' | 'down'): Streak[];

type HighLow = {
    high: BigSource;
    low: BigSource;
};
type HighLowClose = HighLow & {
    close: BigSource;
};
type OpenHighLowClose = HighLowClose & {
    open: BigSource;
};
type OpenHighLowCloseVolume = OpenHighLowClose & {
    volume: BigSource;
};
type HighLowNumber = {
    high: number;
    low: number;
};
type HighLowCloseNumber = HighLowNumber & {
    close: number;
};
type OpenHighLowCloseNumber = HighLowCloseNumber & {
    open: number;
};
type OpenHighLowCloseVolumeNumber = OpenHighLowCloseNumber & {
    volume: number;
};

interface PeriodResult {
    highest: Big__default;
    lowest: Big__default;
}
interface FasterPeriodResult {
    highest: number;
    lowest: number;
}
declare class Period extends TechnicalIndicator<PeriodResult, BigSource> {
    readonly interval: number;
    private readonly values;
    private _highest?;
    private _lowest?;
    get highest(): Big__default.Big | undefined;
    get lowest(): Big__default.Big | undefined;
    constructor(interval: number);
    update(value: BigSource, replace: boolean): {
        highest: Big__default.Big;
        lowest: Big__default.Big;
    } | null;
}
declare class FasterPeriod extends TechnicalIndicator<FasterPeriodResult, number> {
    readonly interval: number;
    values: number[];
    private _highest?;
    private _lowest?;
    get highest(): number | undefined;
    get lowest(): number | undefined;
    constructor(interval: number);
    update(value: number, replace: boolean): {
        highest: number;
        lowest: number;
    } | null;
}

declare function pushUpdate<T>(array: T[], replace: boolean, item: T, maxLength: number): T | null | undefined;

declare class AccelerationBands extends TechnicalIndicator<BandsResult, HighLowClose> {
    readonly interval: number;
    readonly width: number;
    private readonly lowerBand;
    private readonly middleBand;
    private readonly upperBand;
    constructor(interval: number, width: number, SmoothingIndicator?: MovingAverageTypes);
    get isStable(): boolean;
    update({ high, low, close }: HighLowClose, replace: boolean): {
        lower: Big__default.Big;
        middle: Big__default.Big;
        upper: Big__default.Big;
    } | null;
}
declare class FasterAccelerationBands extends TechnicalIndicator<FasterBandsResult, HighLowCloseNumber> {
    readonly interval: number;
    readonly width: number;
    private readonly lowerBand;
    private readonly middleBand;
    private readonly upperBand;
    constructor(interval: number, width: number, SmoothingIndicator?: FasterMovingAverageTypes);
    update({ high, low, close }: HighLowCloseNumber, replace: boolean): {
        lower: number;
        middle: number;
        upper: number;
    } | null;
    get isStable(): boolean;
}

declare class AO extends BigIndicatorSeries<HighLow> {
    readonly shortInterval: number;
    readonly longInterval: number;
    readonly long: MovingAverage;
    readonly short: MovingAverage;
    constructor(shortInterval: number, longInterval: number, SmoothingIndicator?: MovingAverageTypes);
    update({ low, high }: HighLow, replace: boolean): Big__default.Big | null;
}
declare class FasterAO extends NumberIndicatorSeries<HighLowNumber> {
    readonly shortInterval: number;
    readonly longInterval: number;
    readonly long: FasterMovingAverage;
    readonly short: FasterMovingAverage;
    constructor(shortInterval: number, longInterval: number, SmoothingIndicator?: FasterMovingAverageTypes);
    update({ low, high }: HighLowNumber, replace: boolean): number | null;
}

declare class MOM extends BigIndicatorSeries {
    readonly interval: number;
    private readonly history;
    private readonly historyLength;
    constructor(interval: number);
    update(value: BigSource, replace: boolean): Big__default.Big | null;
}
declare class FasterMOM extends NumberIndicatorSeries {
    readonly interval: number;
    private readonly history;
    private readonly historyLength;
    constructor(interval: number);
    update(value: number, replace: boolean): number | null;
}

declare class AC extends BigIndicatorSeries<HighLow> {
    readonly shortAO: number;
    readonly longAO: number;
    readonly signalInterval: number;
    readonly ao: AO;
    readonly momentum: MOM;
    readonly signal: SMA;
    constructor(shortAO: number, longAO: number, signalInterval: number);
    update(input: HighLow, replace: boolean): Big$1.Big | null;
}
declare class FasterAC extends NumberIndicatorSeries<HighLowNumber> {
    readonly shortAO: number;
    readonly longAO: number;
    readonly signalInterval: number;
    readonly ao: FasterAO;
    readonly momentum: FasterMOM;
    readonly signal: FasterSMA;
    constructor(shortAO: number, longAO: number, signalInterval: number);
    update(input: HighLowNumber, replace: boolean): number | null;
}

declare class ADX extends BigIndicatorSeries<HighLowClose> {
    readonly interval: number;
    private readonly dx;
    private readonly smoothed;
    constructor(interval: number, SmoothingIndicator?: MovingAverageTypes);
    get mdi(): Big$1.Big | undefined;
    get pdi(): Big$1.Big | undefined;
    update(candle: HighLowClose, replace: boolean): Big$1.Big | null;
}
declare class FasterADX extends NumberIndicatorSeries<HighLowCloseNumber> {
    readonly interval: number;
    private readonly dx;
    private readonly smoothed;
    constructor(interval: number, SmoothingIndicator?: FasterMovingAverageTypes);
    get mdi(): number | void;
    get pdi(): number | void;
    update(candle: HighLowCloseNumber, replace: boolean): number | null;
}

declare class ATR extends BigIndicatorSeries<HighLowClose> {
    readonly interval: number;
    private readonly tr;
    private readonly smoothing;
    constructor(interval: number, SmoothingIndicator?: MovingAverageTypes);
    update(candle: HighLowClose, replace: boolean): Big$1.Big | null;
}
declare class FasterATR extends NumberIndicatorSeries<HighLowCloseNumber> {
    readonly interval: number;
    private readonly tr;
    private readonly smoothing;
    constructor(interval: number, SmoothingIndicator?: FasterMovingAverageTypes);
    update(candle: HighLowCloseNumber, replace: boolean): number | null;
}

declare class BollingerBands extends TechnicalIndicator<BandsResult, BigSource> {
    readonly interval: number;
    readonly deviationMultiplier: number;
    readonly prices: Big__default[];
    constructor(interval: number, deviationMultiplier?: number);
    update(price: BigSource, replace: boolean): {
        lower: Big__default.Big;
        middle: Big__default.Big;
        upper: Big__default.Big;
    } | null;
}
declare class FasterBollingerBands extends TechnicalIndicator<FasterBandsResult, BigSource> {
    readonly interval: number;
    readonly deviationMultiplier: number;
    readonly prices: number[];
    constructor(interval: number, deviationMultiplier?: number);
    update(price: number, replace: boolean): {
        lower: number;
        middle: number;
        upper: number;
    } | null;
}

declare class BollingerBandsWidth extends BigIndicatorSeries {
    readonly bollingerBands: BollingerBands;
    constructor(bollingerBands: BollingerBands);
    update(price: BigSource, replace: boolean): Big$1.Big | null;
}
declare class FasterBollingerBandsWidth extends NumberIndicatorSeries {
    readonly bollingerBands: FasterBollingerBands;
    constructor(bollingerBands: FasterBollingerBands);
    update(price: number, replace: boolean): number | null;
}

declare class CCI extends BigIndicatorSeries<HighLowClose> {
    readonly interval: number;
    private readonly sma;
    private readonly typicalPrices;
    constructor(interval: number);
    update(candle: HighLowClose, replace: boolean): Big__default.Big | null;
    private cacheTypicalPrice;
}
declare class FasterCCI extends NumberIndicatorSeries<HighLowCloseNumber> {
    readonly interval: number;
    private readonly sma;
    private readonly typicalPrices;
    constructor(interval: number);
    update(candle: HighLowCloseNumber, replace: boolean): number | null;
    private cacheTypicalPrice;
}

declare class CG extends BigIndicatorSeries {
    readonly interval: number;
    readonly signalInterval: number;
    signal: SMA;
    readonly prices: Big__default[];
    get isStable(): boolean;
    constructor(interval: number, signalInterval: number);
    update(price: BigSource, replace: boolean): Big__default.Big | null;
}
declare class FasterCG extends NumberIndicatorSeries {
    readonly interval: number;
    readonly signalInterval: number;
    signal: FasterSMA;
    readonly prices: number[];
    get isStable(): boolean;
    constructor(interval: number, signalInterval: number);
    update(price: number, replace: boolean): number | null;
}

declare class DEMA extends BigIndicatorSeries {
    readonly interval: number;
    private readonly inner;
    private readonly outer;
    constructor(interval: number);
    update(price: BigSource, replace: boolean): Big;
    get isStable(): boolean;
}
declare class FasterDEMA extends NumberIndicatorSeries {
    readonly interval: number;
    private readonly inner;
    private readonly outer;
    constructor(interval: number);
    update(price: number, replace: boolean): number;
    get isStable(): boolean;
}

type DMAResult = {
    long: Big;
    short: Big;
};
interface FasterDMAResult {
    long: number;
    short: number;
}
declare class DMA extends TechnicalIndicator<DMAResult, BigSource> {
    readonly short: MovingAverage;
    readonly long: MovingAverage;
    constructor(short: number, long: number, Indicator?: MovingAverageTypes);
    get isStable(): boolean;
    update(price: BigSource, replace: boolean): {
        long: Big$1.Big;
        short: Big$1.Big;
    } | null;
}
declare class FasterDMA extends TechnicalIndicator<FasterDMAResult, number> {
    readonly short: FasterMovingAverage;
    readonly long: FasterMovingAverage;
    constructor(short: number, long: number, SmoothingIndicator?: FasterMovingAverageTypes);
    get isStable(): boolean;
    update(price: number, replace: boolean): {
        long: number;
        short: number;
    } | null;
}

declare class DX extends BigIndicatorSeries<HighLowClose> {
    readonly interval: number;
    private readonly movesUp;
    private readonly movesDown;
    private previousCandle?;
    private secondLastCandle?;
    private readonly atr;
    mdi?: Big__default;
    pdi?: Big__default;
    constructor(interval: number, SmoothingIndicator?: MovingAverageTypes);
    private updateState;
    update(candle: HighLowClose, replace: boolean): Big__default.Big | null;
}
declare class FasterDX extends NumberIndicatorSeries<HighLowCloseNumber> {
    readonly interval: number;
    private readonly movesUp;
    private readonly movesDown;
    private previousCandle?;
    private secondLastCandle?;
    private readonly atr;
    mdi?: number;
    pdi?: number;
    constructor(interval: number, SmoothingIndicator?: FasterMovingAverageTypes);
    private updateState;
    update(candle: HighLowCloseNumber, replace: boolean): number | null;
}

declare class NotEnoughDataError extends Error {
    constructor(message?: string);
}

type MACDConfig = {
    indicator: typeof EMA | typeof DEMA;
    longInterval: number;
    shortInterval: number;
    signalInterval: number;
};
type MACDResult = {
    histogram: Big__default;
    macd: Big__default;
    signal: Big__default;
};
type FasterMACDResult = {
    histogram: number;
    macd: number;
    signal: number;
};
declare class MACD extends TechnicalIndicator<MACDResult, BigSource> {
    readonly prices: BigSource[];
    readonly long: EMA | DEMA;
    readonly short: EMA | DEMA;
    private readonly signal;
    constructor(config: MACDConfig);
    update(_price: BigSource, replace: boolean): {
        histogram: Big__default.Big;
        macd: Big__default.Big;
        signal: Big__default.Big;
    } | null;
}
declare class FasterMACD extends TechnicalIndicator<FasterMACDResult, number> {
    readonly short: FasterEMA | FasterDEMA;
    readonly long: FasterEMA | FasterDEMA;
    readonly signal: FasterEMA | FasterDEMA;
    readonly prices: number[];
    constructor(short: FasterEMA | FasterDEMA, long: FasterEMA | FasterDEMA, signal: FasterEMA | FasterDEMA);
    update(price: number, replace: boolean): {
        histogram: number;
        macd: number;
        signal: number;
    } | null;
}

declare class MAD extends BigIndicatorSeries {
    readonly interval: number;
    readonly prices: BigSource[];
    constructor(interval: number);
    update(price: BigSource, replace: boolean): Big__default.Big | null;
    static getResultFromBatch(prices: BigSource[], average?: BigSource): Big__default;
}
declare class FasterMAD extends NumberIndicatorSeries {
    readonly interval: number;
    readonly prices: number[];
    constructor(interval: number);
    update(price: number, replace: boolean): number | null;
    static getResultFromBatch(prices: number[], average?: number): number;
}

declare class OBV extends BigIndicatorSeries<OpenHighLowCloseVolume> {
    readonly candles: OpenHighLowCloseVolume[];
    update(candle: OpenHighLowCloseVolume, replace: boolean): Big__default.Big | null;
}
declare class FasterOBV extends NumberIndicatorSeries<OpenHighLowCloseVolumeNumber> {
    readonly candles: OpenHighLowCloseVolumeNumber[];
    update(candle: OpenHighLowCloseVolumeNumber, replace: boolean): number | null;
}

declare class ROC extends BigIndicatorSeries {
    readonly interval: number;
    readonly prices: Big__default[];
    constructor(interval: number);
    update(price: BigSource, replace: boolean): Big__default.Big | null;
}
declare class FasterROC extends NumberIndicatorSeries {
    readonly interval: number;
    readonly prices: number[];
    constructor(interval: number);
    update(price: number, replace: boolean): number | null;
}

declare class RSI extends BigIndicatorSeries {
    readonly interval: number;
    private readonly previousPrices;
    private readonly avgGain;
    private readonly avgLoss;
    private readonly maxValue;
    constructor(interval: number, SmoothingIndicator?: MovingAverageTypes);
    update(price: BigSource, replace: boolean): Big__default.Big | null;
}
declare class FasterRSI extends NumberIndicatorSeries {
    readonly interval: number;
    private readonly previousPrices;
    private readonly avgGain;
    private readonly avgLoss;
    private readonly maxValue;
    constructor(interval: number, SmoothingIndicator?: FasterMovingAverageTypes);
    update(price: number, replace: boolean): number | null;
}

interface StochasticResult {
    stochD: Big__default;
    stochK: Big__default;
}
interface FasterStochasticResult {
    stochD: number;
    stochK: number;
}
declare class StochasticOscillator extends TechnicalIndicator<StochasticResult, HighLowClose> {
    readonly n: number;
    readonly m: number;
    readonly p: number;
    private readonly periodM;
    private readonly periodP;
    private readonly candles;
    constructor(n: number, m: number, p: number);
    update(candle: HighLowClose, replace: boolean): {
        stochD: Big__default.Big;
        stochK: Big__default.Big;
    } | null;
}
declare class FasterStochasticOscillator extends TechnicalIndicator<FasterStochasticResult, HighLowCloseNumber> {
    n: number;
    m: number;
    p: number;
    readonly candles: HighLowCloseNumber[];
    private readonly periodM;
    private readonly periodP;
    constructor(n: number, m: number, p: number);
    update(candle: HighLowCloseNumber, replace: boolean): {
        stochD: number;
        stochK: number;
    } | null;
}

declare class StochasticRSI extends BigIndicatorSeries {
    readonly interval: number;
    private readonly period;
    private readonly rsi;
    constructor(interval: number, SmoothingIndicator?: MovingAverageTypes);
    update(price: BigSource, replace: boolean): Big__default.Big | null;
}
declare class FasterStochasticRSI extends NumberIndicatorSeries {
    readonly interval: number;
    private readonly period;
    private readonly rsi;
    constructor(interval: number, SmoothingIndicator?: FasterMovingAverageTypes);
    update(price: number, replace: boolean): number | null;
}

declare class TR extends BigIndicatorSeries<HighLowClose> {
    private previousCandle?;
    private secondLastCandle?;
    update(candle: HighLowClose, replace: boolean): Big__default;
}
declare class FasterTR extends NumberIndicatorSeries<HighLowCloseNumber> {
    private previousCandle?;
    private twoPreviousCandle?;
    update(candle: HighLowCloseNumber, replace: boolean): number;
}

type LinearRegressionConfig = {
    period: number;
};
type LinearRegressionResult = {
    prediction: Big__default;
    slope: Big__default;
    intercept: Big__default;
};
type FasterLinearRegressionResult = {
    prediction: number;
    slope: number;
    intercept: number;
};
declare class LinearRegression extends TechnicalIndicator<LinearRegressionResult, BigSource> {
    readonly prices: BigSource[];
    private readonly period;
    constructor(config: LinearRegressionConfig);
    private calculateRegression;
    update(price: BigSource, replace: boolean): LinearRegressionResult | null;
    getResultOrThrow(): LinearRegressionResult;
    get isStable(): boolean;
}
declare class FasterLinearRegression extends TechnicalIndicator<FasterLinearRegressionResult, number> {
    readonly prices: number[];
    private readonly period;
    constructor(config: LinearRegressionConfig);
    private calculateRegression;
    update(price: number, replace: boolean): FasterLinearRegressionResult | null;
    getResultOrThrow(): FasterLinearRegressionResult;
    get isStable(): boolean;
}

export { AC, ADX, AO, ATR, AccelerationBands, type BandsResult, BaseIndicatorSeries, BigIndicatorSeries, BollingerBands, BollingerBandsWidth, CCI, CG, DEMA, DMA, type DMAResult, DX, EMA, FasterAC, FasterADX, FasterAO, FasterATR, FasterAccelerationBands, type FasterBandsResult, FasterBollingerBands, FasterBollingerBandsWidth, FasterCCI, FasterCG, FasterDEMA, FasterDMA, type FasterDMAResult, FasterDX, FasterEMA, FasterLinearRegression, type FasterLinearRegressionResult, FasterMACD, type FasterMACDResult, FasterMAD, FasterMOM, FasterMovingAverage, type FasterMovingAverageTypes, FasterOBV, FasterPeriod, type FasterPeriodResult, FasterRMA, FasterROC, FasterRSI, FasterSMA, FasterStochasticOscillator, FasterStochasticRSI, type FasterStochasticResult, FasterTR, FasterWMA, FasterWSMA, type HighLow, type HighLowClose, type HighLowCloseNumber, type HighLowNumber, LinearRegression, type LinearRegressionConfig, type LinearRegressionResult, MACD, type MACDConfig, type MACDResult, MAD, MOM, MovingAverage, type MovingAverageTypes, NotEnoughDataError, NumberIndicatorSeries, OBV, type OpenHighLowClose, type OpenHighLowCloseNumber, type OpenHighLowCloseVolume, type OpenHighLowCloseVolumeNumber, Period, type PeriodResult, RMA, ROC, RSI, SMA, StochasticOscillator, StochasticRSI, type StochasticResult, type Streak, TR, TechnicalIndicator, WMA, WSMA, getAverage, getFasterAverage, getFasterStandardDeviation, getMaximum, getMinimum, getStandardDeviation, getStreaks, pushUpdate };