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>;
    getRequiredInputs(): number;
    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;
    abstract getRequiredInputs(): number;
    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);
    getRequiredInputs(): 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);
    getRequiredInputs(): 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);
    getRequiredInputs(): 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);
    getRequiredInputs(): number;
    update(price: number, replace: boolean): number | null;
}

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

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

declare class RMA extends MovingAverage {
    readonly interval: number;
    private pricesCounter;
    private readonly weightFactor;
    constructor(interval: number);
    getRequiredInputs(): 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);
    getRequiredInputs(): 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 getMedian(values: Big[]): Big;
declare function getFasterMedian(values: number[]): number;

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

declare function getQuartile(values: Big[], quartile: 0.25 | 0.5 | 0.75): Big;
declare function getFasterQuartile(values: number[], q: 0.25 | 0.5 | 0.75): number;

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<T = BigSource> = {
    high: T;
    low: T;
};
type HighLowClose<T = BigSource> = HighLow<T> & {
    close: T;
};
type OpenHighLowClose<T = BigSource> = HighLowClose<T> & {
    open: T;
};
type OpenHighLowCloseVolume<T = BigSource> = OpenHighLowClose<T> & {
    volume: T;
};
type HighLowCloseVolume<T = BigSource> = Omit<OpenHighLowCloseVolume<T>, 'open'>;

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);
    getRequiredInputs(): 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);
    getRequiredInputs(): 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;
    getRequiredInputs(): number;
    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, HighLowClose<number>> {
    readonly interval: number;
    readonly width: number;
    private readonly lowerBand;
    private readonly middleBand;
    private readonly upperBand;
    constructor(interval: number, width: number, SmoothingIndicator?: FasterMovingAverageTypes);
    getRequiredInputs(): number;
    update({ high, low, close }: HighLowClose<number>, 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);
    getRequiredInputs(): number;
    update({ low, high }: HighLow, replace: boolean): Big__default.Big | null;
}
declare class FasterAO extends NumberIndicatorSeries<HighLow<number>> {
    readonly shortInterval: number;
    readonly longInterval: number;
    readonly long: FasterMovingAverage;
    readonly short: FasterMovingAverage;
    constructor(shortInterval: number, longInterval: number, SmoothingIndicator?: FasterMovingAverageTypes);
    getRequiredInputs(): number;
    update({ low, high }: HighLow<number>, replace: boolean): number | null;
}

declare class MOM extends BigIndicatorSeries {
    readonly interval: number;
    private readonly history;
    private readonly historyLength;
    constructor(interval: number);
    getRequiredInputs(): 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);
    getRequiredInputs(): 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);
    getRequiredInputs(): number;
    update(input: HighLow, replace: boolean): Big$1.Big | null;
}
declare class FasterAC extends NumberIndicatorSeries<HighLow<number>> {
    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);
    getRequiredInputs(): number;
    update(input: HighLow<number>, 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;
    getRequiredInputs(): number;
    update(candle: HighLowClose, replace: boolean): Big$1.Big | null;
}
declare class FasterADX extends NumberIndicatorSeries<HighLowClose<number>> {
    readonly interval: number;
    private readonly dx;
    private readonly smoothed;
    constructor(interval: number, SmoothingIndicator?: FasterMovingAverageTypes);
    get mdi(): number | void;
    get pdi(): number | void;
    getRequiredInputs(): number;
    update(candle: HighLowClose<number>, replace: boolean): number | null;
}

declare class ATR extends BigIndicatorSeries<HighLowClose> {
    readonly interval: number;
    private readonly tr;
    private readonly smoothing;
    constructor(interval: number, SmoothingIndicator?: MovingAverageTypes);
    getRequiredInputs(): number;
    update(candle: HighLowClose, replace: boolean): Big$1.Big | null;
}
declare class FasterATR extends NumberIndicatorSeries<HighLowClose<number>> {
    readonly interval: number;
    private readonly tr;
    private readonly smoothing;
    constructor(interval: number, SmoothingIndicator?: FasterMovingAverageTypes);
    getRequiredInputs(): number;
    update(candle: HighLowClose<number>, 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);
    getRequiredInputs(): 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);
    getRequiredInputs(): number;
    update(price: number, replace: boolean): {
        lower: number;
        middle: number;
        upper: number;
    } | null;
}

declare class BollingerBandsWidth extends BigIndicatorSeries {
    readonly bollingerBands: BollingerBands;
    constructor(bollingerBands: BollingerBands);
    getRequiredInputs(): number;
    update(price: BigSource, replace: boolean): Big$1.Big | null;
}
declare class FasterBollingerBandsWidth extends NumberIndicatorSeries {
    readonly bollingerBands: FasterBollingerBands;
    constructor(bollingerBands: FasterBollingerBands);
    getRequiredInputs(): number;
    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);
    getRequiredInputs(): number;
    update(candle: HighLowClose, replace: boolean): Big__default.Big | null;
    private cacheTypicalPrice;
}
declare class FasterCCI extends NumberIndicatorSeries<HighLowClose<number>> {
    readonly interval: number;
    private readonly sma;
    private readonly typicalPrices;
    constructor(interval: number);
    getRequiredInputs(): number;
    update(candle: HighLowClose<number>, 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);
    getRequiredInputs(): 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);
    getRequiredInputs(): 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);
    getRequiredInputs(): 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);
    getRequiredInputs(): 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;
    getRequiredInputs(): number;
    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;
    getRequiredInputs(): number;
    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;
    getRequiredInputs(): number;
    update(candle: HighLowClose, replace: boolean): Big__default.Big | null;
}
declare class FasterDX extends NumberIndicatorSeries<HighLowClose<number>> {
    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;
    getRequiredInputs(): number;
    update(candle: HighLowClose<number>, replace: boolean): number | null;
}

declare class NotEnoughDataError extends Error {
    constructor(requiredAmount: number);
}

declare class IQR extends BigIndicatorSeries {
    readonly interval: number;
    private readonly values;
    constructor(interval: number);
    getRequiredInputs(): number;
    update(value: BigSource, replace: boolean): Big__default | null;
}
declare class FasterIQR extends NumberIndicatorSeries {
    readonly interval: number;
    private readonly values;
    constructor(interval: number);
    getRequiredInputs(): number;
    update(value: number, replace: boolean): number | null;
}

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 interval: number;
    readonly prices: BigSource[];
    constructor(interval: number);
    getRequiredInputs(): number;
    private calculateRegression;
    update(price: BigSource, replace: boolean): LinearRegressionResult | null;
    getResultOrThrow(): LinearRegressionResult;
    get isStable(): boolean;
}
declare class FasterLinearRegression extends TechnicalIndicator<FasterLinearRegressionResult, number> {
    readonly interval: number;
    readonly prices: number[];
    constructor(interval: number);
    getRequiredInputs(): number;
    private calculateRegression;
    update(price: number, replace: boolean): FasterLinearRegressionResult | null;
    get isStable(): boolean;
}

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);
    getRequiredInputs(): number;
    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);
    getRequiredInputs(): number;
    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);
    getRequiredInputs(): 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);
    getRequiredInputs(): number;
    update(price: number, replace: boolean): number | null;
    static getResultFromBatch(prices: number[], average?: number): number;
}

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

type PSARConfig = {
    accelerationStep: number;
    accelerationMax: number;
};
declare class PSAR extends BigIndicatorSeries<HighLow> {
    private readonly accelerationStep;
    private readonly accelerationMax;
    private acceleration;
    private extreme;
    private lastSar;
    private isLong;
    private previousCandle;
    private prePreviousCandle;
    constructor(config: PSARConfig);
    getRequiredInputs(): number;
    get isStable(): boolean;
    update(candle: HighLow, replace: boolean): Big__default | null;
    getResultOrThrow(): Big__default;
}
declare class FasterPSAR extends NumberIndicatorSeries<HighLow<number>> {
    private readonly accelerationStep;
    private readonly accelerationMax;
    private acceleration;
    private extreme;
    private lastSar;
    private isLong;
    private previousCandle;
    private prePreviousCandle;
    constructor(config: PSARConfig);
    get isStable(): boolean;
    getRequiredInputs(): number;
    update(candle: HighLow<number>, replace: boolean): number | null;
    getResultOrThrow(): number;
}

declare class REI extends BigIndicatorSeries<HighLowClose> {
    readonly interval: number;
    private readonly highs;
    private readonly lows;
    private readonly closes;
    constructor(interval: number);
    getRequiredInputs(): number;
    private calculateN;
    private calculateM;
    update(candle: HighLowClose, replace: boolean): Big__default.Big | null;
}
declare class FasterREI extends NumberIndicatorSeries<HighLowClose<number>> {
    readonly interval: number;
    private readonly highs;
    private readonly lows;
    private readonly closes;
    constructor(interval: number);
    getRequiredInputs(): number;
    private calculateN;
    private calculateM;
    update(candle: HighLowClose<number>, replace: boolean): number | null;
}

declare class ROC extends BigIndicatorSeries {
    readonly interval: number;
    readonly prices: Big__default[];
    constructor(interval: number);
    getRequiredInputs(): number;
    update(price: BigSource, replace: boolean): Big__default.Big | null;
}
declare class FasterROC extends NumberIndicatorSeries {
    readonly interval: number;
    readonly prices: number[];
    constructor(interval: number);
    getRequiredInputs(): 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);
    getRequiredInputs(): number;
    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);
    getRequiredInputs(): number;
    update(price: number, replace: boolean): number | null;
}

declare class SMA15 extends MovingAverage {
    readonly interval: number;
    private readonly prices;
    private static readonly WEIGHTS;
    private static readonly WEIGHT_SUM;
    constructor(interval: number);
    getRequiredInputs(): number;
    update(price: BigSource, replace: boolean): Big__default.Big | null;
}
declare class FasterSMA15 extends FasterMovingAverage {
    readonly prices: number[];
    private static readonly WEIGHTS;
    private static readonly WEIGHT_SUM;
    getRequiredInputs(): number;
    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);
    getRequiredInputs(): number;
    update(candle: HighLowClose, replace: boolean): {
        stochD: Big__default.Big;
        stochK: Big__default.Big;
    } | null;
}
declare class FasterStochasticOscillator extends TechnicalIndicator<FasterStochasticResult, HighLowClose<number>> {
    n: number;
    m: number;
    p: number;
    readonly candles: HighLowClose<number>[];
    private readonly periodM;
    private readonly periodP;
    constructor(n: number, m: number, p: number);
    getRequiredInputs(): number;
    update(candle: HighLowClose<number>, replace: boolean): {
        stochD: number;
        stochK: number;
    } | null;
}

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

declare class TDS extends BigIndicatorSeries {
    private readonly closes;
    private setupCount;
    private setupDirection;
    getRequiredInputs(): number;
    update(close: BigSource, replace: boolean): Big__default | null;
}
declare class FasterTDS extends NumberIndicatorSeries {
    private readonly closes;
    private setupCount;
    private setupDirection;
    getRequiredInputs(): number;
    update(close: number, replace: boolean): number | null;
}

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

declare class VWAP extends BigIndicatorSeries<HighLowCloseVolume> {
    private cumulativeTypicalPriceVolume;
    private cumulativeVolume;
    private lastCandle;
    constructor();
    private calculateTypicalPriceVolume;
    getRequiredInputs(): number;
    update(candle: HighLowCloseVolume, replace: boolean): Big__default.Big | null;
}
declare class FasterVWAP extends NumberIndicatorSeries<HighLowCloseVolume<number>> {
    private cumulativeTypicalPriceVolume;
    private cumulativeVolume;
    private lastCandle;
    constructor();
    private calculateTypicalPriceVolume;
    getRequiredInputs(): number;
    update(candle: HighLowCloseVolume<number>, replace: boolean): number | null;
}

type ZigZagConfig = {
    deviation: number;
};
declare class ZigZag extends BigIndicatorSeries<HighLow> {
    private readonly deviation;
    private isUp;
    private highestExtreme;
    private lowestExtreme;
    constructor(config: ZigZagConfig);
    getRequiredInputs(): number;
    update(candle: HighLow, replace: boolean): Big__default | null;
}
declare class FasterZigZag extends NumberIndicatorSeries<HighLow> {
    private readonly deviation;
    private isUp;
    private highestExtreme;
    private lowestExtreme;
    constructor(config: ZigZagConfig);
    getRequiredInputs(): number;
    update(candle: HighLow<number>, replace: boolean): number | null;
}

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, FasterIQR, FasterLinearRegression, type FasterLinearRegressionResult, FasterMACD, type FasterMACDResult, FasterMAD, FasterMOM, FasterMovingAverage, type FasterMovingAverageTypes, FasterOBV, FasterPSAR, FasterPeriod, type FasterPeriodResult, FasterREI, FasterRMA, FasterROC, FasterRSI, FasterSMA, FasterSMA15, FasterStochasticOscillator, FasterStochasticRSI, type FasterStochasticResult, FasterTDS, FasterTR, FasterVWAP, FasterWMA, FasterWSMA, FasterZigZag, type HighLow, type HighLowClose, type HighLowCloseVolume, IQR, LinearRegression, type LinearRegressionResult, MACD, type MACDConfig, type MACDResult, MAD, MOM, MovingAverage, type MovingAverageTypes, NotEnoughDataError, NumberIndicatorSeries, OBV, type OpenHighLowClose, type OpenHighLowCloseVolume, PSAR, type PSARConfig, Period, type PeriodResult, REI, RMA, ROC, RSI, SMA, SMA15, StochasticOscillator, StochasticRSI, type StochasticResult, type Streak, TDS, TR, TechnicalIndicator, VWAP, WMA, WSMA, ZigZag, type ZigZagConfig, getAverage, getFasterAverage, getFasterMedian, getFasterQuartile, getFasterStandardDeviation, getMaximum, getMedian, getMinimum, getQuartile, getStandardDeviation, getStreaks, pushUpdate };