wickra/bindings/node/index.d.ts

/* tslint:disable */
/* eslint-disable */

/* auto-generated by NAPI-RS */

/** Library version (matches the Rust crate version). */
export declare function version(): string
/**
 * Volatility-cone result: current realized volatility and its lookback
 * envelope (min / median / max) plus the percentile rank of `current`.
 */
export interface VolatilityConeValue {
  current: number
  min: number
  median: number
  max: number
  percentile: number
}
/** Lead/lag result: the offset that maximises correlation, and that correlation. */
export interface LeadLagValue {
  /** Offset that maximises `|corr(a, b shifted)|`. Positive ⇒ `a` leads `b`. */
  lag: number
  /** Signed correlation at that lag, in `[-1, 1]`. */
  correlation: number
}
/** Cointegration result: hedge ratio, current spread, and the ADF statistic. */
export interface CointegrationValue {
  /** Engle–Granger hedge ratio (OLS slope of `a` on `b`). */
  hedgeRatio: number
  /** Current spread (regression residual) `a - (alpha + beta*b)`. */
  spread: number
  /**
   * Augmented Dickey–Fuller statistic on the spread; more negative ⇒ more
   * strongly mean-reverting.
   */
  adfStat: number
}
/** Relative-strength triple: the a/b ratio, its moving average, and its RSI. */
export interface RelativeStrengthValue {
  /** Raw ratio `a / b`. */
  ratio: number
  /** Moving average of the ratio. */
  ratioMa: number
  /** RSI of the ratio. */
  ratioRsi: number
}
/** Kalman hedge-ratio result: dynamic hedge ratio, intercept, and spread. */
export interface KalmanHedgeRatioValue {
  /** Current hedge ratio (filtered slope of `a` on `b`). */
  hedgeRatio: number
  /** Current intercept (filtered level offset). */
  intercept: number
  /** Forecast error `a - (intercept + hedgeRatio*b)` — the spread signal. */
  spread: number
}
/** Spread Bollinger-bands result: middle, upper and lower bands plus `%b`. */
export interface SpreadBollingerBandsValue {
  /** Middle band: the rolling mean of the spread. */
  middle: number
  /** Upper band. */
  upper: number
  /** Lower band. */
  lower: number
  /** `%b`: where the spread sits across the band (`0` lower, `1` upper). */
  percentB: number
}
/** MACD triple: macd line, signal line, histogram. */
export interface MacdValue {
  macd: number
  signal: number
  histogram: number
}
export interface BollingerValue {
  upper: number
  middle: number
  lower: number
  stddev: number
}
export interface HtPhasorValue {
  inphase: number
  quadrature: number
}
export interface QqeValue {
  rsiMa: number
  trailingLine: number
}
export interface ElderRayValue {
  bullPower: number
  bearPower: number
}
export interface GatorOscillatorValue {
  upper: number
  lower: number
}
export interface KasePermissionStochasticValue {
  fast: number
  slow: number
}
export interface StochValue {
  k: number
  d: number
}
export interface AdxValue {
  plusDi: number
  minusDi: number
  adx: number
}
export interface KeltnerValue {
  upper: number
  middle: number
  lower: number
}
export interface DonchianValue {
  upper: number
  middle: number
  lower: number
}
export interface AroonValue {
  up: number
  down: number
}
export interface KstValue {
  kst: number
  signal: number
}
export interface ZeroLagMacdValue {
  macd: number
  signal: number
  histogram: number
}
export interface AlligatorValue {
  jaw: number
  teeth: number
  lips: number
}
export interface SuperTrendValue {
  value: number
  direction: number
}
export interface ChandelierExitValue {
  longStop: number
  shortStop: number
}
export interface ChandeKrollStopValue {
  stopLong: number
  stopShort: number
}
export interface DonchianStopValue {
  stopLong: number
  stopShort: number
}
export interface KaseDevStopValue {
  value: number
  direction: number
}
export interface ElderSafeZoneValue {
  value: number
  direction: number
}
export interface AtrRatchetValue {
  value: number
  direction: number
}
export interface NrtrValue {
  value: number
  direction: number
}
export interface ModifiedMaStopValue {
  value: number
  direction: number
}
/** Vortex Indicator pair: `VI+` and `VI-`. */
export interface VortexValue {
  plus: number
  minus: number
}
/** Random Walk Index pair: `RWI_High` and `RWI_Low`. */
export interface RwiValue {
  high: number
  low: number
}
/** Wave Trend Oscillator pair: `wt1` (channel index) and `wt2` (signal SMA). */
export interface WaveTrendValue {
  wt1: number
  wt2: number
}
export interface MaEnvelopeValue {
  upper: number
  middle: number
  lower: number
}
export interface AccelerationBandsValue {
  upper: number
  middle: number
  lower: number
}
export interface StarcBandsValue {
  upper: number
  middle: number
  lower: number
}
export interface AtrBandsValue {
  upper: number
  middle: number
  lower: number
}
export interface HurstChannelValue {
  upper: number
  middle: number
  lower: number
}
export interface LinRegChannelValue {
  upper: number
  middle: number
  lower: number
}
export interface StandardErrorBandsValue {
  upper: number
  middle: number
  lower: number
}
export interface QuartileBandsValue {
  upper: number
  middle: number
  lower: number
}
export interface BomarBandsValue {
  upper: number
  middle: number
  lower: number
}
export interface MedianChannelValue {
  upper: number
  middle: number
  lower: number
}
export interface ProjectionBandsValue {
  upper: number
  middle: number
  lower: number
}
export interface CentralPivotRangeValue {
  pivot: number
  tc: number
  bc: number
}
export interface MurreyMathLinesValue {
  mm8_8: number
  mm7_8: number
  mm6_8: number
  mm5_8: number
  mm4_8: number
  mm3_8: number
  mm2_8: number
  mm1_8: number
  mm0_8: number
}
export interface AndrewsPitchforkValue {
  median: number
  upper: number
  lower: number
}
export interface VolumeWeightedSrValue {
  support: number
  resistance: number
}
export interface DoubleBollingerValue {
  upperOuter: number
  upperInner: number
  middle: number
  lowerInner: number
  lowerOuter: number
}
export interface TtmSqueezeValue {
  squeeze: number
  momentum: number
}
export interface FractalChaosBandsValue {
  upper: number
  lower: number
}
export interface VwapStdDevBandsValue {
  upper: number
  middle: number
  lower: number
  stddev: number
}
export interface ClassicPivotsValue {
  pp: number
  r1: number
  r2: number
  r3: number
  s1: number
  s2: number
  s3: number
}
export interface FibonacciPivotsValue {
  pp: number
  r1: number
  r2: number
  r3: number
  s1: number
  s2: number
  s3: number
}
export interface CamarillaValue {
  pp: number
  r1: number
  r2: number
  r3: number
  r4: number
  s1: number
  s2: number
  s3: number
  s4: number
}
export interface WoodiePivotsValue {
  pp: number
  r1: number
  r2: number
  s1: number
  s2: number
}
export interface DemarkPivotsValue {
  pp: number
  r1: number
  s1: number
}
export interface WilliamsFractalsValue {
  /** Up fractal price; NaN when no up fractal was confirmed on this bar. */
  up: number
  /** Down fractal price; NaN when no down fractal was confirmed on this bar. */
  down: number
}
export interface ZigZagValue {
  swing: number
  direction: number
}
/** TD Sequential output triple: setup count, countdown count, direction. */
export interface TdSequentialValue {
  setup: number
  countdown: number
  direction: number
}
export interface TdMovingAverageValue {
  st1: number
  st2: number
}
/** TD Lines output pair: latest TDST resistance / support (NaN if unset). */
export interface TdLinesValue {
  resistance: number
  support: number
}
/** TD Range Projection output pair: projected next-bar high / low. */
export interface TdRangeProjectionValue {
  high: number
  low: number
}
/**
 * TD Risk Level output pair: buy-side / sell-side protective stop levels
 * (NaN if unset).
 */
export interface TdRiskLevelValue {
  buyRisk: number
  sellRisk: number
}
export interface MamaValue {
  mama: number
  fama: number
}
/**
 * Ichimoku output: five lines, any of which may be `NaN` while the indicator
 * is still warming up.
 */
export interface IchimokuValue {
  tenkan: number
  kijun: number
  senkouA: number
  senkouB: number
  chikou: number
}
export interface HeikinAshiValue {
  open: number
  high: number
  low: number
  close: number
}
export interface SmoothedHeikinAshiValue {
  open: number
  high: number
  low: number
  close: number
}
export interface EquivolumeValue {
  height: number
  width: number
}
export interface CandleVolumeValue {
  body: number
  width: number
}
export interface ValueAreaValue {
  poc: number
  vah: number
  val: number
}
export interface VolumeProfileValue {
  priceLow: number
  priceHigh: number
  bins: Array<number>
}
export interface HighLowVolumeNodesValue {
  hvn: number
  lvn: number
}
export interface CompositeProfileValue {
  poc: number
  vah: number
  val: number
}
export interface TpoProfileValue {
  priceLow: number
  priceHigh: number
  counts: Array<number>
}
export interface InitialBalanceValue {
  high: number
  low: number
}
export interface OpeningRangeValue {
  high: number
  low: number
  breakoutDistance: number
}
/** One order-book depth snapshot for batch evaluation. */
export interface ObSnapshot {
  bidPx: Array<number>
  bidSz: Array<number>
  askPx: Array<number>
  askSz: Array<number>
}
/** One price bucket of a footprint. */
export interface FootprintLevelValue {
  price: number
  bidVol: number
  askVol: number
}
/** The liquidation feature vector for one tick. */
export interface LiquidationFeaturesValue {
  long: number
  short: number
  net: number
  total: number
  imbalance: number
}
export interface RenkoBrickValue {
  open: number
  close: number
  direction: number
}
export interface KagiSegmentValue {
  start: number
  end: number
  direction: number
}
export interface PnfColumnValue {
  direction: number
  high: number
  low: number
}
export interface RangeBarValue {
  open: number
  close: number
  direction: number
}
export interface TickBarValue {
  open: number
  high: number
  low: number
  close: number
  volume: number
}
export interface VolumeBarValue {
  open: number
  high: number
  low: number
  close: number
  volume: number
}
export interface DollarBarValue {
  open: number
  high: number
  low: number
  close: number
  volume: number
  dollar: number
}
export interface ImbalanceBarValue {
  open: number
  high: number
  low: number
  close: number
  imbalance: number
  direction: number
}
export interface RunBarValue {
  open: number
  high: number
  low: number
  close: number
  length: number
  direction: number
}
export interface LineBreakBarValue {
  open: number
  close: number
  direction: number
}
export interface SessionHighLowValue {
  high: number
  low: number
}
export interface SessionRangeValue {
  asia: number
  eu: number
  us: number
}
export interface OvernightIntradayReturnValue {
  overnight: number
  intraday: number
}
export interface FibRetracementValue {
  level0: number
  level236: number
  level382: number
  level500: number
  level618: number
  level786: number
  level1000: number
}
export interface FibExtensionValue {
  level1272: number
  level1414: number
  level1618: number
  level2000: number
  level2618: number
}
export interface FibProjectionValue {
  level618: number
  level1000: number
  level1618: number
  level2618: number
}
export interface AutoFibValue {
  level0: number
  level236: number
  level382: number
  level500: number
  level618: number
  level786: number
  level1000: number
}
export interface GoldenPocketValue {
  low: number
  mid: number
  high: number
}
export interface FibConfluenceValue {
  price: number
  strength: number
}
export interface FibFanValue {
  fan382: number
  fan500: number
  fan618: number
}
export interface FibArcsValue {
  arc382: number
  arc500: number
  arc618: number
}
export interface FibChannelValue {
  base: number
  level618: number
  level1000: number
  level1618: number
}
export interface FibTimeZonesValue {
  onZone: number
  barsToNext: number
}
export interface VolumeWeightedMacdValue {
  macd: number
  signal: number
  histogram: number
}
export type SmaNode = SMA
export declare class SMA {
  constructor(period: number)
  update(value: number): number | null
  batch(prices: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type EmaNode = EMA
export declare class EMA {
  constructor(period: number)
  update(value: number): number | null
  batch(prices: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type WmaNode = WMA
export declare class WMA {
  constructor(period: number)
  update(value: number): number | null
  batch(prices: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type RsiNode = RSI
export declare class RSI {
  constructor(period: number)
  update(value: number): number | null
  batch(prices: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type DemaNode = DEMA
export declare class DEMA {
  constructor(period: number)
  update(value: number): number | null
  batch(prices: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type TemaNode = TEMA
export declare class TEMA {
  constructor(period: number)
  update(value: number): number | null
  batch(prices: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type HmaNode = HMA
export declare class HMA {
  constructor(period: number)
  update(value: number): number | null
  batch(prices: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type RocNode = ROC
export declare class ROC {
  constructor(period: number)
  update(value: number): number | null
  batch(prices: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type TrixNode = TRIX
export declare class TRIX {
  constructor(period: number)
  update(value: number): number | null
  batch(prices: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type SmmaNode = SMMA
export declare class SMMA {
  constructor(period: number)
  update(value: number): number | null
  batch(prices: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type TrimaNode = TRIMA
export declare class TRIMA {
  constructor(period: number)
  update(value: number): number | null
  batch(prices: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type ZlemaNode = ZLEMA
export declare class ZLEMA {
  constructor(period: number)
  update(value: number): number | null
  batch(prices: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type MomNode = MOM
export declare class MOM {
  constructor(period: number)
  update(value: number): number | null
  batch(prices: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type CmoNode = CMO
export declare class CMO {
  constructor(period: number)
  update(value: number): number | null
  batch(prices: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type DpoNode = DPO
export declare class DPO {
  constructor(period: number)
  update(value: number): number | null
  batch(prices: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type StdDevNode = StdDev
export declare class StdDev {
  constructor(period: number)
  update(value: number): number | null
  batch(prices: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type UlcerIndexNode = UlcerIndex
export declare class UlcerIndex {
  constructor(period: number)
  update(value: number): number | null
  batch(prices: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type VerticalHorizontalFilterNode = VerticalHorizontalFilter
export declare class VerticalHorizontalFilter {
  constructor(period: number)
  update(value: number): number | null
  batch(prices: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type ZScoreNode = ZScore
export declare class ZScore {
  constructor(period: number)
  update(value: number): number | null
  batch(prices: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type McGinleyDynamicNode = McGinleyDynamic
export declare class McGinleyDynamic {
  constructor(period: number)
  update(value: number): number | null
  batch(prices: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type FramaNode = FRAMA
export declare class FRAMA {
  constructor(period: number)
  update(value: number): number | null
  batch(prices: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type SuperSmootherNode = SuperSmoother
export declare class SuperSmoother {
  constructor(period: number)
  update(value: number): number | null
  batch(prices: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type FisherTransformNode = FisherTransform
export declare class FisherTransform {
  constructor(period: number)
  update(value: number): number | null
  batch(prices: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type DecyclerNode = Decycler
export declare class Decycler {
  constructor(period: number)
  update(value: number): number | null
  batch(prices: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type CenterOfGravityNode = CenterOfGravity
export declare class CenterOfGravity {
  constructor(period: number)
  update(value: number): number | null
  batch(prices: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type CyberneticCycleNode = CyberneticCycle
export declare class CyberneticCycle {
  constructor(period: number)
  update(value: number): number | null
  batch(prices: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type InstantaneousTrendlineNode = InstantaneousTrendline
export declare class InstantaneousTrendline {
  constructor(period: number)
  update(value: number): number | null
  batch(prices: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type EhlersStochasticNode = EhlersStochastic
export declare class EhlersStochastic {
  constructor(period: number)
  update(value: number): number | null
  batch(prices: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type RviVolatilityNode = RVIVolatility
export declare class RVIVolatility {
  constructor(period: number)
  update(value: number): number | null
  batch(prices: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type VarianceNode = Variance
export declare class Variance {
  constructor(period: number)
  update(value: number): number | null
  batch(prices: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type CoefficientOfVariationNode = CoefficientOfVariation
export declare class CoefficientOfVariation {
  constructor(period: number)
  update(value: number): number | null
  batch(prices: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type SkewnessNode = Skewness
export declare class Skewness {
  constructor(period: number)
  update(value: number): number | null
  batch(prices: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type KurtosisNode = Kurtosis
export declare class Kurtosis {
  constructor(period: number)
  update(value: number): number | null
  batch(prices: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type StandardErrorNode = StandardError
export declare class StandardError {
  constructor(period: number)
  update(value: number): number | null
  batch(prices: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type DetrendedStdDevNode = DetrendedStdDev
export declare class DetrendedStdDev {
  constructor(period: number)
  update(value: number): number | null
  batch(prices: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type RSquaredNode = RSquared
export declare class RSquared {
  constructor(period: number)
  update(value: number): number | null
  batch(prices: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type MedianAbsoluteDeviationNode = MedianAbsoluteDeviation
export declare class MedianAbsoluteDeviation {
  constructor(period: number)
  update(value: number): number | null
  batch(prices: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type MidPointNode = MIDPOINT
export declare class MIDPOINT {
  constructor(period: number)
  update(value: number): number | null
  batch(prices: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type RocpNode = ROCP
export declare class ROCP {
  constructor(period: number)
  update(value: number): number | null
  batch(prices: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type RocrNode = ROCR
export declare class ROCR {
  constructor(period: number)
  update(value: number): number | null
  batch(prices: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type Rocr100Node = ROCR100
export declare class ROCR100 {
  constructor(period: number)
  update(value: number): number | null
  batch(prices: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type LinRegInterceptNode = LINEARREG_INTERCEPT
export declare class LINEARREG_INTERCEPT {
  constructor(period: number)
  update(value: number): number | null
  batch(prices: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type TsfNode = TSF
export declare class TSF {
  constructor(period: number)
  update(value: number): number | null
  batch(prices: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type LogReturnNode = LogReturn
export declare class LogReturn {
  constructor(period: number)
  update(value: number): number | null
  batch(prices: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type RealizedVolatilityNode = RealizedVolatility
export declare class RealizedVolatility {
  constructor(period: number)
  update(value: number): number | null
  batch(prices: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type RollingIqrNode = RollingIqr
export declare class RollingIqr {
  constructor(period: number)
  update(value: number): number | null
  batch(prices: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type RollingPercentileRankNode = RollingPercentileRank
export declare class RollingPercentileRank {
  constructor(period: number)
  update(value: number): number | null
  batch(prices: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type TrendLabelNode = TrendLabel
export declare class TrendLabel {
  constructor(period: number)
  update(value: number): number | null
  batch(prices: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type WinRateNode = WinRate
export declare class WinRate {
  constructor(period: number)
  update(value: number): number | null
  batch(prices: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type ExpectancyNode = Expectancy
export declare class Expectancy {
  constructor(period: number)
  update(value: number): number | null
  batch(prices: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type SineWeightedMaNode = SWMA
export declare class SWMA {
  constructor(period: number)
  update(value: number): number | null
  batch(prices: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type GeometricMaNode = GMA
export declare class GMA {
  constructor(period: number)
  update(value: number): number | null
  batch(prices: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type EhmaNode = EHMA
export declare class EHMA {
  constructor(period: number)
  update(value: number): number | null
  batch(prices: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type MedianMaNode = MedianMA
export declare class MedianMA {
  constructor(period: number)
  update(value: number): number | null
  batch(prices: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type AdaptiveLaguerreFilterNode = AdaptiveLaguerre
export declare class AdaptiveLaguerre {
  constructor(period: number)
  update(value: number): number | null
  batch(prices: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type DisparityIndexNode = DisparityIndex
export declare class DisparityIndex {
  constructor(period: number)
  update(value: number): number | null
  batch(prices: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type FisherRsiNode = FisherRSI
export declare class FisherRSI {
  constructor(period: number)
  update(value: number): number | null
  batch(prices: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type RsxNode = RSX
export declare class RSX {
  constructor(period: number)
  update(value: number): number | null
  batch(prices: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type DynamicMomentumIndexNode = DynamicMomentumIndex
export declare class DynamicMomentumIndex {
  constructor(period: number)
  update(value: number): number | null
  batch(prices: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type TrendStrengthIndexNode = TREND_STRENGTH_INDEX
export declare class TREND_STRENGTH_INDEX {
  constructor(period: number)
  update(value: number): number | null
  batch(prices: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type TsfOscillatorNode = TsfOscillator
export declare class TsfOscillator {
  constructor(period: number)
  update(value: number): number | null
  batch(prices: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type BipowerVariationNode = BipowerVariation
export declare class BipowerVariation {
  constructor(period: number)
  update(value: number): number | null
  batch(prices: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type JarqueBeraNode = JARQUEBERA
export declare class JARQUEBERA {
  constructor(period: number)
  update(value: number): number | null
  batch(prices: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type RollingMinMaxScalerNode = ROLLINGMINMAX
export declare class ROLLINGMINMAX {
  constructor(period: number)
  update(value: number): number | null
  batch(prices: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type HighpassFilterNode = HIGHPASS
export declare class HIGHPASS {
  constructor(period: number)
  update(value: number): number | null
  batch(prices: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type ReflexNode = REFLEX
export declare class REFLEX {
  constructor(period: number)
  update(value: number): number | null
  batch(prices: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type TrendflexNode = TRENDFLEX
export declare class TRENDFLEX {
  constructor(period: number)
  update(value: number): number | null
  batch(prices: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type CorrelationTrendIndicatorNode = CTI
export declare class CTI {
  constructor(period: number)
  update(value: number): number | null
  batch(prices: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type AdaptiveRsiNode = ADAPTIVERSI
export declare class ADAPTIVERSI {
  constructor(period: number)
  update(value: number): number | null
  batch(prices: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type UniversalOscillatorNode = UNIVERSALOSC
export declare class UNIVERSALOSC {
  constructor(period: number)
  update(value: number): number | null
  batch(prices: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type SterlingRatioNode = SterlingRatio
export declare class SterlingRatio {
  constructor(period: number)
  update(value: number): number | null
  batch(prices: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type BurkeRatioNode = BurkeRatio
export declare class BurkeRatio {
  constructor(period: number)
  update(value: number): number | null
  batch(prices: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type MartinRatioNode = MartinRatio
export declare class MartinRatio {
  constructor(period: number)
  update(value: number): number | null
  batch(prices: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type TailRatioNode = TailRatio
export declare class TailRatio {
  constructor(period: number)
  update(value: number): number | null
  batch(prices: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type KRatioNode = KRatio
export declare class KRatio {
  constructor(period: number)
  update(value: number): number | null
  batch(prices: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type CommonSenseRatioNode = CommonSenseRatio
export declare class CommonSenseRatio {
  constructor(period: number)
  update(value: number): number | null
  batch(prices: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type GainToPainRatioNode = GainToPainRatio
export declare class GainToPainRatio {
  constructor(period: number)
  update(value: number): number | null
  batch(prices: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type UpsidePotentialRatioNode = UpsidePotentialRatio
export declare class UpsidePotentialRatio {
  constructor(period: number, mar: number)
  update(value: number): number | null
  batch(prices: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type M2MeasureNode = M2Measure
export declare class M2Measure {
  constructor(period: number, riskFree: number, benchmarkStddev: number)
  update(value: number): number | null
  batch(prices: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type BandpassFilterNode = BANDPASS
export declare class BANDPASS {
  constructor(period: number, bandwidth: number)
  update(value: number): number | null
  batch(prices: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type EvenBetterSinewaveNode = EVENBETTERSINE
export declare class EVENBETTERSINE {
  constructor(hpPeriod: number, ssfLength: number)
  update(value: number): number | null
  batch(prices: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type AutocorrelationPeriodogramNode = AUTOCORRPGRAM
export declare class AUTOCORRPGRAM {
  constructor(minPeriod: number, maxPeriod: number)
  update(value: number): number | null
  batch(prices: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type ShannonEntropyNode = SHANNONENT
export declare class SHANNONENT {
  constructor(period: number, bins: number)
  update(value: number): number | null
  batch(prices: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type SampleEntropyNode = SAMPLEENT
export declare class SAMPLEENT {
  constructor(period: number, m: number, rFactor: number)
  update(value: number): number | null
  batch(prices: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type EwmaVolatilityNode = EwmaVolatility
export declare class EwmaVolatility {
  constructor(lambda: number)
  update(value: number): number | null
  batch(prices: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type Garch11Node = Garch11
export declare class Garch11 {
  constructor(omega: number, alpha: number, beta: number)
  update(value: number): number | null
  batch(prices: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type VolatilityOfVolatilityNode = VolatilityOfVolatility
export declare class VolatilityOfVolatility {
  constructor(volWindow: number, vovWindow: number)
  update(value: number): number | null
  batch(prices: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type VolatilityConeNode = VolatilityCone
export declare class VolatilityCone {
  constructor(window: number, lookback: number)
  update(high: number, low: number, close: number): VolatilityConeValue | null
  batch(high: Array<number>, low: Array<number>, close: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type JumpIndicatorNode = JumpIndicator
export declare class JumpIndicator {
  constructor(period: number, threshold: number)
  update(value: number): number | null
  batch(prices: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type RegimeLabelNode = RegimeLabel
export declare class RegimeLabel {
  constructor(volPeriod: number, lookback: number)
  update(value: number): number | null
  batch(prices: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type RollingQuantileNode = RollingQuantile
export declare class RollingQuantile {
  constructor(period: number, quantile: number)
  update(value: number): number | null
  batch(prices: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type AutocorrelationNode = Autocorrelation
export declare class Autocorrelation {
  constructor(period: number, lag: number)
  update(value: number): number | null
  batch(prices: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type HurstExponentNode = HurstExponent
export declare class HurstExponent {
  constructor(period: number, chunks: number)
  update(value: number): number | null
  batch(prices: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type PearsonCorrelationNode = PearsonCorrelation
export declare class PearsonCorrelation {
  constructor(period: number)
  update(x: number, y: number): number | null
  /**
   * Batch over two equally-sized arrays. Returns a length-`n` array
   * with `NaN` for warmup positions.
   */
  batch(x: Array<number>, y: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type BetaNode = Beta
export declare class Beta {
  constructor(period: number)
  update(x: number, y: number): number | null
  /**
   * Batch over two equally-sized arrays. Returns a length-`n` array
   * with `NaN` for warmup positions.
   */
  batch(x: Array<number>, y: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type PairwiseBetaNode = PairwiseBeta
export declare class PairwiseBeta {
  constructor(period: number)
  update(x: number, y: number): number | null
  /**
   * Batch over two equally-sized arrays. Returns a length-`n` array
   * with `NaN` for warmup positions.
   */
  batch(x: Array<number>, y: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type SpreadAr1CoefficientNode = SpreadAr1Coefficient
export declare class SpreadAr1Coefficient {
  constructor(period: number)
  update(x: number, y: number): number | null
  /**
   * Batch over two equally-sized arrays. Returns a length-`n` array
   * with `NaN` for warmup positions.
   */
  batch(x: Array<number>, y: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type SpearmanCorrelationNode = SpearmanCorrelation
export declare class SpearmanCorrelation {
  constructor(period: number)
  update(x: number, y: number): number | null
  /**
   * Batch over two equally-sized arrays. Returns a length-`n` array
   * with `NaN` for warmup positions.
   */
  batch(x: Array<number>, y: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type RollingCorrelationNode = RollingCorrelation
export declare class RollingCorrelation {
  constructor(period: number)
  update(x: number, y: number): number | null
  /**
   * Batch over two equally-sized arrays. Returns a length-`n` array
   * with `NaN` for warmup positions.
   */
  batch(x: Array<number>, y: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type RollingCovarianceNode = RollingCovariance
export declare class RollingCovariance {
  constructor(period: number)
  update(x: number, y: number): number | null
  /**
   * Batch over two equally-sized arrays. Returns a length-`n` array
   * with `NaN` for warmup positions.
   */
  batch(x: Array<number>, y: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type OuHalfLifeNode = OuHalfLife
export declare class OuHalfLife {
  constructor(period: number)
  update(x: number, y: number): number | null
  /**
   * Batch over two equally-sized arrays. Returns a length-`n` array
   * with `NaN` for warmup positions.
   */
  batch(x: Array<number>, y: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type SpreadHurstNode = SpreadHurst
export declare class SpreadHurst {
  constructor(period: number)
  update(x: number, y: number): number | null
  /**
   * Batch over two equally-sized arrays. Returns a length-`n` array
   * with `NaN` for warmup positions.
   */
  batch(x: Array<number>, y: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type DistanceSsdNode = DistanceSsd
export declare class DistanceSsd {
  constructor(period: number)
  update(x: number, y: number): number | null
  /**
   * Batch over two equally-sized arrays. Returns a length-`n` array
   * with `NaN` for warmup positions.
   */
  batch(x: Array<number>, y: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type KendallTauNode = KendallTau
export declare class KendallTau {
  constructor(period: number)
  update(x: number, y: number): number | null
  /**
   * Batch over two equally-sized arrays. Returns a length-`n` array
   * with `NaN` for warmup positions.
   */
  batch(x: Array<number>, y: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type BetaNeutralSpreadNode = BetaNeutralSpread
export declare class BetaNeutralSpread {
  constructor(period: number)
  update(x: number, y: number): number | null
  /**
   * Batch over two equally-sized arrays. Returns a length-`n` array
   * with `NaN` for warmup positions.
   */
  batch(x: Array<number>, y: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type HasbrouckInformationShareNode = HasbrouckInformationShare
export declare class HasbrouckInformationShare {
  constructor(period: number)
  update(x: number, y: number): number | null
  /**
   * Batch over two equally-sized arrays. Returns a length-`n` array
   * with `NaN` for warmup positions.
   */
  batch(x: Array<number>, y: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type PairSpreadZScoreNode = PairSpreadZScore
/**
 * Pair spread z-score: two ctor params (`betaPeriod`, `zPeriod`), one `(a, b)`
 * price pair per update, a single z-score out.
 */
export declare class PairSpreadZScore {
  constructor(betaPeriod: number, zPeriod: number)
  update(a: number, b: number): number | null
  /**
   * Batch over two equally-sized arrays of prices. Returns a length-`n`
   * array with `NaN` for warmup positions.
   */
  batch(a: Array<number>, b: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type LeadLagCrossCorrelationNode = LeadLagCrossCorrelation
export declare class LeadLagCrossCorrelation {
  constructor(window: number, maxLag: number)
  update(a: number, b: number): LeadLagValue | null
  /**
   * Batch over two equally-sized arrays. Returns a flat array of length
   * `2 * n`, interleaved per row as `[lag0, corr0, lag1, corr1, ...]`. Read
   * column `j` of row `i` as `result[i * 2 + j]`. Warmup rows are `NaN`.
   */
  batch(a: Array<number>, b: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type CointegrationNode = Cointegration
export declare class Cointegration {
  constructor(period: number, adfLags: number)
  update(a: number, b: number): CointegrationValue | null
  /**
   * Batch over two equally-sized arrays. Returns a flat array of length
   * `3 * n`, interleaved per row as `[hedgeRatio0, spread0, adfStat0, ...]`.
   * Read column `j` of row `i` as `result[i * 3 + j]`. Warmup rows are `NaN`.
   */
  batch(a: Array<number>, b: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type RelativeStrengthAbNode = RelativeStrengthAB
export declare class RelativeStrengthAB {
  constructor(maPeriod: number, rsiPeriod: number)
  update(a: number, b: number): RelativeStrengthValue | null
  /**
   * Batch over two equally-sized arrays. Returns a flat array of length
   * `3 * n`, interleaved per row as `[ratio0, ratioMa0, ratioRsi0, ...]`.
   * Read column `j` of row `i` as `result[i * 3 + j]`. Warmup rows are `NaN`.
   */
  batch(a: Array<number>, b: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type VarianceRatioNode = VarianceRatio
/**
 * Lo–MacKinlay variance ratio: two ctor params (`period`, `q`), one `(a, b)`
 * pair per update, a single ratio out.
 */
export declare class VarianceRatio {
  constructor(period: number, q: number)
  update(a: number, b: number): number | null
  /**
   * Batch over two equally-sized arrays. Returns a length-`n` array with
   * `NaN` for warmup positions.
   */
  batch(a: Array<number>, b: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type GrangerCausalityNode = GrangerCausality
/**
 * Granger causality F-statistic: two ctor params (`period`, `lag`), one
 * `(a, b)` pair per update, a single F-statistic out.
 */
export declare class GrangerCausality {
  constructor(period: number, lag: number)
  update(a: number, b: number): number | null
  /**
   * Batch over two equally-sized arrays. Returns a length-`n` array with
   * `NaN` for warmup positions.
   */
  batch(a: Array<number>, b: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type KalmanHedgeRatioNode = KalmanHedgeRatio
export declare class KalmanHedgeRatio {
  constructor(delta: number, observationVar: number)
  update(a: number, b: number): KalmanHedgeRatioValue | null
  /**
   * Batch over two equally-sized arrays. Returns a flat array of length
   * `3 * n`, interleaved per row as `[hedgeRatio0, intercept0, spread0, ...]`.
   * Read column `j` of row `i` as `result[i * 3 + j]`. Warmup rows are `NaN`.
   */
  batch(a: Array<number>, b: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type SpreadBollingerBandsNode = SpreadBollingerBands
export declare class SpreadBollingerBands {
  constructor(period: number, numStd: number)
  update(a: number, b: number): SpreadBollingerBandsValue | null
  /**
   * Batch over two equally-sized arrays. Returns a flat array of length
   * `4 * n`, interleaved per row as `[middle0, upper0, lower0, percentB0, ...]`.
   * Read column `j` of row `i` as `result[i * 4 + j]`. Warmup rows are `NaN`.
   */
  batch(a: Array<number>, b: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type MacdNode = MACD
export declare class MACD {
  constructor(fast: number, slow: number, signal: number)
  update(value: number): MacdValue | null
  /**
   * Batch over a price array. Returns a flat array of length `3 * n`,
   * interleaved per row as `[macd0, signal0, histogram0, macd1, ...]`.
   * Read column `j` of row `i` as `result[i * 3 + j]`. Warmup rows are `NaN`.
   */
  batch(prices: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type MacdFixNode = MACDFIX
export declare class MACDFIX {
  constructor(signal: number)
  update(value: number): MacdValue | null
  /**
   * Batch over a price array. Returns a flat array of length `3 * n`,
   * interleaved per row as `[macd0, signal0, histogram0, macd1, ...]`.
   */
  batch(prices: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type MacdExtNode = MACDEXT
export declare class MACDEXT {
  /**
   * Moving-average types are TA-Lib `MA_Type` codes `0..=5`
   * (SMA, EMA, WMA, DEMA, TEMA, TRIMA).
   */
  constructor(fast: number, fastMatype: number, slow: number, slowMatype: number, signal: number, signalMatype: number)
  update(value: number): MacdValue | null
  /**
   * Batch over a price array. Returns a flat array of length `3 * n`,
   * interleaved per row as `[macd0, signal0, histogram0, macd1, ...]`.
   */
  batch(prices: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type BollingerNode = BollingerBands
export declare class BollingerBands {
  constructor(period: number, multiplier: number)
  update(value: number): BollingerValue | null
  /**
   * Batch over a price array. Returns a flat array of length `4 * n`,
   * interleaved per row as `[upper0, middle0, lower0, stddev0, upper1, ...]`.
   * Read column `j` of row `i` as `result[i * 4 + j]`. Warmup rows are `NaN`.
   */
  batch(prices: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type AtrNode = ATR
export declare class ATR {
  constructor(period: number)
  update(high: number, low: number, close: number): number | null
  batch(high: Array<number>, low: Array<number>, close: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type PlusDmNode = PLUS_DM
export declare class PLUS_DM {
  constructor(period: number)
  update(high: number, low: number, close: number): number | null
  batch(high: Array<number>, low: Array<number>, close: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type MinusDmNode = MINUS_DM
export declare class MINUS_DM {
  constructor(period: number)
  update(high: number, low: number, close: number): number | null
  batch(high: Array<number>, low: Array<number>, close: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type PlusDiNode = PLUS_DI
export declare class PLUS_DI {
  constructor(period: number)
  update(high: number, low: number, close: number): number | null
  batch(high: Array<number>, low: Array<number>, close: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type MinusDiNode = MINUS_DI
export declare class MINUS_DI {
  constructor(period: number)
  update(high: number, low: number, close: number): number | null
  batch(high: Array<number>, low: Array<number>, close: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type DxNode = DX
export declare class DX {
  constructor(period: number)
  update(high: number, low: number, close: number): number | null
  batch(high: Array<number>, low: Array<number>, close: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type MidPriceNode = MIDPRICE
export declare class MIDPRICE {
  constructor(period: number)
  update(high: number, low: number, close: number): number | null
  batch(high: Array<number>, low: Array<number>, close: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type AvgPriceNode = AVGPRICE
export declare class AVGPRICE {
  constructor()
  update(open: number, high: number, low: number, close: number): number | null
  batch(open: Array<number>, high: Array<number>, low: Array<number>, close: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type SarExtNode = SAREXT
export declare class SAREXT {
  constructor(startValue: number, offsetOnReverse: number, accelInitLong: number, accelLong: number, accelMaxLong: number, accelInitShort: number, accelShort: number, accelMaxShort: number)
  update(high: number, low: number, close: number): number | null
  batch(high: Array<number>, low: Array<number>, close: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type HtPhasorNode = HT_PHASOR
export declare class HT_PHASOR {
  constructor()
  update(value: number): HtPhasorValue | null
  /**
   * Batch over a price array. Returns a flat array of length `2 * n`,
   * interleaved per row as `[inphase0, quadrature0, inphase1, ...]`.
   */
  batch(prices: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type CloseVsOpenNode = CloseVsOpen
export declare class CloseVsOpen {
  constructor()
  update(open: number, high: number, low: number, close: number): number | null
  batch(open: Array<number>, high: Array<number>, low: Array<number>, close: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type BodySizePctNode = BodySizePct
export declare class BodySizePct {
  constructor()
  update(open: number, high: number, low: number, close: number): number | null
  batch(open: Array<number>, high: Array<number>, low: Array<number>, close: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type WickRatioNode = WickRatio
export declare class WickRatio {
  constructor()
  update(open: number, high: number, low: number, close: number): number | null
  batch(open: Array<number>, high: Array<number>, low: Array<number>, close: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type HighLowRangeNode = HighLowRange
export declare class HighLowRange {
  constructor()
  update(open: number, high: number, low: number, close: number): number | null
  batch(open: Array<number>, high: Array<number>, low: Array<number>, close: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type StochasticCciNode = StochasticCCI
export declare class StochasticCCI {
  constructor(period: number)
  update(high: number, low: number, close: number): number | null
  batch(high: Array<number>, low: Array<number>, close: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type ImiNode = IMI
export declare class IMI {
  constructor(period: number)
  update(open: number, high: number, low: number, close: number): number | null
  batch(open: Array<number>, high: Array<number>, low: Array<number>, close: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type QqeNode = QQE
export declare class QQE {
  constructor(rsiPeriod: number, smoothing: number, factor: number)
  update(value: number): QqeValue | null
  batch(prices: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type ElderRayNode = ElderRay
export declare class ElderRay {
  constructor(period: number)
  update(high: number, low: number, close: number): ElderRayValue | null
  batch(high: Array<number>, low: Array<number>, close: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type TtmTrendNode = TTM_TREND
export declare class TTM_TREND {
  constructor(period: number)
  update(high: number, low: number, close: number): number | null
  batch(high: Array<number>, low: Array<number>, close: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type QstickNode = Qstick
export declare class Qstick {
  constructor(period: number)
  update(open: number, close: number): number | null
  batch(open: Array<number>, close: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type PolarizedFractalEfficiencyNode = POLARIZED_FRACTAL_EFFICIENCY
export declare class POLARIZED_FRACTAL_EFFICIENCY {
  constructor(period: number, smoothing: number)
  update(value: number): number | null
  batch(prices: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type WavePmNode = WAVE_PM
export declare class WAVE_PM {
  constructor(length: number, smoothing: number)
  update(value: number): number | null
  batch(prices: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type GatorOscillatorNode = GatorOscillator
export declare class GatorOscillator {
  constructor(jawPeriod: number, teethPeriod: number, lipsPeriod: number)
  update(high: number, low: number, close: number): GatorOscillatorValue | null
  batch(high: Array<number>, low: Array<number>, close: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type KasePermissionStochasticNode = KasePermissionStochastic
export declare class KasePermissionStochastic {
  constructor(length: number, smooth: number)
  update(high: number, low: number, close: number): KasePermissionStochasticValue | null
  batch(high: Array<number>, low: Array<number>, close: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type VolatilityRatioNode = VolatilityRatio
export declare class VolatilityRatio {
  constructor(period: number)
  update(high: number, low: number, close: number): number | null
  batch(high: Array<number>, low: Array<number>, close: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type ProjectionOscillatorNode = ProjectionOscillator
export declare class ProjectionOscillator {
  constructor(period: number)
  update(high: number, low: number, close: number): number | null
  batch(high: Array<number>, low: Array<number>, close: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type TimeBasedStopNode = TimeBasedStop
export declare class TimeBasedStop {
  constructor(maxBars: number)
  update(high: number, low: number, close: number): number | null
  batch(high: Array<number>, low: Array<number>, close: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type AdaptiveCciNode = ADAPTIVECCI
export declare class ADAPTIVECCI {
  constructor(period: number)
  update(high: number, low: number, close: number): number | null
  batch(high: Array<number>, low: Array<number>, close: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type StochNode = Stochastic
export declare class Stochastic {
  constructor(kPeriod: number, dPeriod: number)
  update(high: number, low: number, close: number): StochValue | null
  batch(high: Array<number>, low: Array<number>, close: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type ObvNode = OBV
export declare class OBV {
  constructor()
  update(close: number, volume: number): number | null
  batch(close: Array<number>, volume: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type AdxNode = ADX
export declare class ADX {
  constructor(period: number)
  update(high: number, low: number, close: number): AdxValue | null
  batch(high: Array<number>, low: Array<number>, close: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type AdxrNode = ADXR
export declare class ADXR {
  constructor(period: number)
  update(high: number, low: number, close: number): number | null
  batch(high: Array<number>, low: Array<number>, close: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type CciNode = CCI
export declare class CCI {
  constructor(period: number)
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
  update(high: number, low: number, close: number): number | null
  batch(high: Array<number>, low: Array<number>, close: Array<number>): Array<number>
}
export type WilliamsRNode = WilliamsR
export declare class WilliamsR {
  constructor(period: number)
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
  update(high: number, low: number, close: number): number | null
  batch(high: Array<number>, low: Array<number>, close: Array<number>): Array<number>
}
export type MfiNode = MFI
export declare class MFI {
  constructor(period: number)
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
  update(high: number, low: number, close: number, volume: number): number | null
  batch(high: Array<number>, low: Array<number>, close: Array<number>, volume: Array<number>): Array<number>
}
export type PsarNode = PSAR
export declare class PSAR {
  constructor(afStart: number, afStep: number, afMax: number)
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
  update(high: number, low: number, close: number): number | null
  batch(high: Array<number>, low: Array<number>, close: Array<number>): Array<number>
}
export type KeltnerNode = Keltner
export declare class Keltner {
  constructor(emaPeriod: number, atrPeriod: number, multiplier: number)
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
  update(high: number, low: number, close: number): KeltnerValue | null
  batch(high: Array<number>, low: Array<number>, close: Array<number>): Array<number>
}
export type DonchianNode = Donchian
export declare class Donchian {
  constructor(period: number)
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
  update(high: number, low: number): DonchianValue | null
  batch(high: Array<number>, low: Array<number>): Array<number>
}
export type VwapNode = VWAP
export declare class VWAP {
  constructor()
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
  update(high: number, low: number, close: number, volume: number): number | null
  batch(high: Array<number>, low: Array<number>, close: Array<number>, volume: Array<number>): Array<number>
}
export type RollingVwapNode = RollingVWAP
export declare class RollingVWAP {
  constructor(period: number)
  get period(): number
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
  update(high: number, low: number, close: number, volume: number): number | null
  batch(high: Array<number>, low: Array<number>, close: Array<number>, volume: Array<number>): Array<number>
}
export type AoNode = AwesomeOscillator
export declare class AwesomeOscillator {
  constructor(fast: number, slow: number)
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
  update(high: number, low: number): number | null
  batch(high: Array<number>, low: Array<number>): Array<number>
}
export type AroonNode = Aroon
export declare class Aroon {
  constructor(period: number)
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
  update(high: number, low: number): AroonValue | null
  batch(high: Array<number>, low: Array<number>): Array<number>
}
export type InertiaNode = Inertia
export declare class Inertia {
  constructor(rviPeriod: number, linregPeriod: number)
  update(open: number, high: number, low: number, close: number): number | null
  batch(open: Array<number>, high: Array<number>, low: Array<number>, close: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type ConnorsRsiNode = ConnorsRSI
export declare class ConnorsRSI {
  constructor(periodRsi: number, periodStreak: number, periodRank: number)
  update(value: number): number | null
  batch(prices: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type LaguerreRsiNode = LaguerreRSI
export declare class LaguerreRSI {
  constructor(gamma: number)
  update(value: number): number | null
  batch(prices: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type SmiNode = SMI
export declare class SMI {
  constructor(period: number, dPeriod: number, d2Period: number)
  update(high: number, low: number, close: number): number | null
  batch(high: Array<number>, low: Array<number>, close: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type KstNode = KST
export declare class KST {
  constructor(roc1: number, roc2: number, roc3: number, roc4: number, sma1: number, sma2: number, sma3: number, sma4: number, signal: number)
  static classic(): KstNode
  update(value: number): KstValue | null
  batch(prices: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type PgoNode = PGO
export declare class PGO {
  constructor(period: number)
  update(high: number, low: number, close: number): number | null
  batch(high: Array<number>, low: Array<number>, close: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type RviNode = RVI
export declare class RVI {
  constructor(period: number)
  update(open: number, high: number, low: number, close: number): number | null
  batch(open: Array<number>, high: Array<number>, low: Array<number>, close: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type AwesomeOscillatorHistogramNode = AwesomeOscillatorHistogram
export declare class AwesomeOscillatorHistogram {
  constructor(fast: number, slow: number, smaPeriod: number)
  update(high: number, low: number): number | null
  batch(high: Array<number>, low: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type StcNode = STC
export declare class STC {
  constructor(fast: number, slow: number, schaffPeriod: number, factor: number)
  update(value: number): number | null
  batch(prices: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type ElderImpulseNode = ElderImpulse
export declare class ElderImpulse {
  constructor(emaPeriod: number, macdFast: number, macdSlow: number, macdSignal: number)
  update(value: number): number | null
  batch(prices: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type ZeroLagMacdNode = ZeroLagMACD
export declare class ZeroLagMACD {
  constructor(fast: number, slow: number, signal: number)
  update(value: number): ZeroLagMacdValue | null
  batch(prices: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type CfoNode = CFO
export declare class CFO {
  constructor(period: number)
  update(value: number): number | null
  batch(prices: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type ApoNode = APO
export declare class APO {
  constructor(fast: number, slow: number)
  update(value: number): number | null
  batch(prices: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type KamaNode = KAMA
export declare class KAMA {
  constructor(erPeriod: number, fast: number, slow: number)
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
  update(value: number): number | null
  batch(prices: Array<number>): Array<number>
}
export type EvwmaNode = EVWMA
export declare class EVWMA {
  constructor(period: number)
  update(close: number, volume: number): number | null
  batch(close: Array<number>, volume: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type AlligatorNode = Alligator
export declare class Alligator {
  constructor(jaw: number, teeth: number, lips: number)
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
  update(high: number, low: number): AlligatorValue | null
  batch(high: Array<number>, low: Array<number>): Array<number>
}
export type JmaNode = JMA
export declare class JMA {
  constructor(period: number, phase: number, power: number)
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
  update(value: number): number | null
  batch(prices: Array<number>): Array<number>
}
export type VidyaNode = VIDYA
export declare class VIDYA {
  constructor(period: number, cmoPeriod: number)
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
  update(value: number): number | null
  batch(prices: Array<number>): Array<number>
}
export type AlmaNode = ALMA
export declare class ALMA {
  constructor(period: number, offset: number, sigma: number)
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
  update(value: number): number | null
  batch(prices: Array<number>): Array<number>
}
export type T3Node = T3
export declare class T3 {
  constructor(period: number, v: number)
  update(value: number): number | null
  batch(prices: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type GeneralizedDemaNode = GD
export declare class GD {
  constructor(period: number, v: number)
  update(value: number): number | null
  batch(prices: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type HoltWintersNode = HoltWinters
export declare class HoltWinters {
  constructor(alpha: number, beta: number)
  update(value: number): number | null
  batch(prices: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type RmiNode = RMI
export declare class RMI {
  constructor(period: number, momentum: number)
  update(value: number): number | null
  batch(prices: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type DerivativeOscillatorNode = DerivativeOscillator
export declare class DerivativeOscillator {
  constructor(rsiPeriod: number, smooth1: number, smooth2: number, signalPeriod: number)
  update(value: number): number | null
  batch(prices: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type MacdHistogramNode = MacdHistogram
export declare class MacdHistogram {
  constructor(fast: number, slow: number, signal: number)
  update(value: number): number | null
  batch(prices: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type PpoHistogramNode = PpoHistogram
export declare class PpoHistogram {
  constructor(fast: number, slow: number, signal: number)
  update(value: number): number | null
  batch(prices: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type TsiNode = TSI
export declare class TSI {
  constructor(long: number, short: number)
  update(value: number): number | null
  batch(prices: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type PmoNode = PMO
export declare class PMO {
  constructor(smoothing1: number, smoothing2: number)
  update(value: number): number | null
  batch(prices: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type TiiNode = TII
export declare class TII {
  constructor(smaPeriod: number, devPeriod: number)
  update(value: number): number | null
  batch(prices: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type AdlNode = ADL
export declare class ADL {
  constructor()
  update(high: number, low: number, close: number, volume: number): number | null
  batch(high: Array<number>, low: Array<number>, close: Array<number>, volume: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type VolumePriceTrendNode = VolumePriceTrend
export declare class VolumePriceTrend {
  constructor()
  update(close: number, volume: number): number | null
  batch(close: Array<number>, volume: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type ChaikinMoneyFlowNode = ChaikinMoneyFlow
export declare class ChaikinMoneyFlow {
  constructor(period: number)
  update(high: number, low: number, close: number, volume: number): number | null
  batch(high: Array<number>, low: Array<number>, close: Array<number>, volume: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type ChaikinOscillatorNode = ChaikinOscillator
export declare class ChaikinOscillator {
  constructor(fast: number, slow: number)
  update(high: number, low: number, close: number, volume: number): number | null
  batch(high: Array<number>, low: Array<number>, close: Array<number>, volume: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type ForceIndexNode = ForceIndex
export declare class ForceIndex {
  constructor(period: number)
  update(close: number, volume: number): number | null
  batch(close: Array<number>, volume: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type NviNode = NVI
export declare class NVI {
  constructor(baseline?: number | undefined | null)
  update(close: number, volume: number): number | null
  batch(close: Array<number>, volume: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type PviNode = PVI
export declare class PVI {
  constructor(baseline?: number | undefined | null)
  update(close: number, volume: number): number | null
  batch(close: Array<number>, volume: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type VolumeOscillatorNode = VolumeOscillator
export declare class VolumeOscillator {
  constructor(fast: number, slow: number)
  update(volume: number): number | null
  batch(volume: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type KvoNode = KVO
export declare class KVO {
  constructor(fast: number, slow: number)
  update(high: number, low: number, close: number, volume: number): number | null
  batch(high: Array<number>, low: Array<number>, close: Array<number>, volume: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type AdOscillatorNode = WilliamsAD
export declare class WilliamsAD {
  constructor()
  update(high: number, low: number, close: number): number | null
  batch(high: Array<number>, low: Array<number>, close: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type AnchoredRsiNode = AnchoredRSI
export declare class AnchoredRSI {
  constructor()
  setAnchor(): void
  update(value: number): number | null
  batch(prices: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type AnchoredVwapNode = AnchoredVWAP
export declare class AnchoredVWAP {
  constructor()
  setAnchor(): void
  update(high: number, low: number, close: number, volume: number): number | null
  batch(high: Array<number>, low: Array<number>, close: Array<number>, volume: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type DemandIndexNode = DemandIndex
export declare class DemandIndex {
  constructor(period: number)
  update(high: number, low: number, close: number, volume: number): number | null
  batch(high: Array<number>, low: Array<number>, close: Array<number>, volume: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type TsvNode = TSV
export declare class TSV {
  constructor(period: number)
  update(close: number, volume: number): number | null
  batch(close: Array<number>, volume: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type VzoNode = VZO
export declare class VZO {
  constructor(period: number)
  update(close: number, volume: number): number | null
  batch(close: Array<number>, volume: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type MarketFacilitationIndexNode = MarketFacilitationIndex
export declare class MarketFacilitationIndex {
  constructor()
  update(high: number, low: number, volume: number): number | null
  batch(high: Array<number>, low: Array<number>, volume: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type EaseOfMovementNode = EaseOfMovement
export declare class EaseOfMovement {
  constructor(period: number, divisor: number)
  update(high: number, low: number, volume: number): number | null
  batch(high: Array<number>, low: Array<number>, volume: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type SuperTrendNode = SuperTrend
export declare class SuperTrend {
  constructor(atrPeriod: number, multiplier: number)
  update(high: number, low: number, close: number): SuperTrendValue | null
  /**
   * Returns `[value0, direction0, value1, direction1, ...]`, length `2 * n`.
   * Warmup positions are `NaN`.
   */
  batch(high: Array<number>, low: Array<number>, close: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type ChandelierExitNode = ChandelierExit
export declare class ChandelierExit {
  constructor(period: number, multiplier: number)
  update(high: number, low: number, close: number): ChandelierExitValue | null
  /**
   * Returns `[long0, short0, long1, short1, ...]`, length `2 * n`. Warmup
   * positions are `NaN`.
   */
  batch(high: Array<number>, low: Array<number>, close: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type ChandeKrollStopNode = ChandeKrollStop
export declare class ChandeKrollStop {
  constructor(atrPeriod: number, atrMultiplier: number, stopPeriod: number)
  update(high: number, low: number, close: number): ChandeKrollStopValue | null
  /**
   * Returns `[long0, short0, long1, short1, ...]`, length `2 * n`. Warmup
   * positions are `NaN`.
   */
  batch(high: Array<number>, low: Array<number>, close: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type AtrTrailingStopNode = AtrTrailingStop
export declare class AtrTrailingStop {
  constructor(atrPeriod: number, multiplier: number)
  update(high: number, low: number, close: number): number | null
  batch(high: Array<number>, low: Array<number>, close: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type HiLoActivatorNode = HiLoActivator
export declare class HiLoActivator {
  constructor(period: number)
  update(high: number, low: number, close: number): number | null
  batch(high: Array<number>, low: Array<number>, close: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type VoltyStopNode = VoltyStop
export declare class VoltyStop {
  constructor(atrPeriod: number, multiplier: number)
  update(high: number, low: number, close: number): number | null
  batch(high: Array<number>, low: Array<number>, close: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type YoyoExitNode = YoyoExit
export declare class YoyoExit {
  constructor(atrPeriod: number, multiplier: number)
  update(high: number, low: number, close: number): number | null
  batch(high: Array<number>, low: Array<number>, close: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
  inTrade(): boolean
}
export type DonchianStopNode = DonchianStop
export declare class DonchianStop {
  constructor(period: number)
  update(high: number, low: number): DonchianStopValue | null
  /**
   * Returns `[long0, short0, long1, short1, ...]`, length `2 * n`. Warmup
   * positions are `NaN`.
   */
  batch(high: Array<number>, low: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type PercentageTrailingStopNode = PercentageTrailingStop
export declare class PercentageTrailingStop {
  constructor(percent: number)
  update(value: number): number | null
  batch(prices: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type StepTrailingStopNode = StepTrailingStop
export declare class StepTrailingStop {
  constructor(stepSize: number)
  update(value: number): number | null
  batch(prices: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type RenkoTrailingStopNode = RenkoTrailingStop
export declare class RenkoTrailingStop {
  constructor(blockSize: number)
  update(value: number): number | null
  batch(prices: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type KaseDevStopNode = KaseDevStop
export declare class KaseDevStop {
  constructor(period: number, dev: number)
  update(high: number, low: number, close: number): KaseDevStopValue | null
  /**
   * Returns `[value0, direction0, value1, direction1, ...]`, length `2 * n`.
   * Warmup positions are `NaN`.
   */
  batch(high: Array<number>, low: Array<number>, close: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type ElderSafeZoneNode = ElderSafeZone
export declare class ElderSafeZone {
  constructor(period: number, coeff: number)
  update(high: number, low: number, close: number): ElderSafeZoneValue | null
  /**
   * Returns `[value0, direction0, value1, direction1, ...]`, length `2 * n`.
   * Warmup positions are `NaN`.
   */
  batch(high: Array<number>, low: Array<number>, close: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type AtrRatchetNode = AtrRatchet
export declare class AtrRatchet {
  constructor(atrPeriod: number, startMult: number, increment: number)
  update(high: number, low: number, close: number): AtrRatchetValue | null
  /**
   * Returns `[value0, direction0, value1, direction1, ...]`, length `2 * n`.
   * Warmup positions are `NaN`.
   */
  batch(high: Array<number>, low: Array<number>, close: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type NrtrNode = Nrtr
export declare class Nrtr {
  constructor(pct: number)
  update(high: number, low: number, close: number): NrtrValue | null
  /**
   * Returns `[value0, direction0, value1, direction1, ...]`, length `2 * n`.
   * Warmup positions are `NaN`.
   */
  batch(high: Array<number>, low: Array<number>, close: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type ModifiedMaStopNode = ModifiedMaStop
export declare class ModifiedMaStop {
  constructor(period: number)
  update(high: number, low: number, close: number): ModifiedMaStopValue | null
  /**
   * Returns `[value0, direction0, value1, direction1, ...]`, length `2 * n`.
   * Warmup positions are `NaN`.
   */
  batch(high: Array<number>, low: Array<number>, close: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type TypicalPriceNode = TypicalPrice
export declare class TypicalPrice {
  constructor()
  update(high: number, low: number, close: number): number | null
  batch(high: Array<number>, low: Array<number>, close: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type MedianPriceNode = MedianPrice
export declare class MedianPrice {
  constructor()
  update(high: number, low: number): number | null
  batch(high: Array<number>, low: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type WeightedCloseNode = WeightedClose
export declare class WeightedClose {
  constructor()
  update(high: number, low: number, close: number): number | null
  batch(high: Array<number>, low: Array<number>, close: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type LinearRegressionNode = LinearRegression
export declare class LinearRegression {
  constructor(period: number)
  update(value: number): number | null
  batch(prices: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type LinRegSlopeNode = LinRegSlope
export declare class LinRegSlope {
  constructor(period: number)
  update(value: number): number | null
  batch(prices: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type AcceleratorOscillatorNode = AcceleratorOscillator
export declare class AcceleratorOscillator {
  constructor(aoFast: number, aoSlow: number, signalPeriod: number)
  update(high: number, low: number): number | null
  batch(high: Array<number>, low: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type BalanceOfPowerNode = BalanceOfPower
export declare class BalanceOfPower {
  constructor()
  update(open: number, high: number, low: number, close: number): number | null
  batch(open: Array<number>, high: Array<number>, low: Array<number>, close: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type ChoppinessIndexNode = ChoppinessIndex
export declare class ChoppinessIndex {
  constructor(period: number)
  update(high: number, low: number, close: number): number | null
  batch(high: Array<number>, low: Array<number>, close: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type TrueRangeNode = TrueRange
export declare class TrueRange {
  constructor()
  update(high: number, low: number, close: number): number | null
  batch(high: Array<number>, low: Array<number>, close: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type ChaikinVolatilityNode = ChaikinVolatility
export declare class ChaikinVolatility {
  constructor(emaPeriod: number, rocPeriod: number)
  update(high: number, low: number): number | null
  batch(high: Array<number>, low: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type YangZhangVolatilityNode = YangZhangVolatility
export declare class YangZhangVolatility {
  constructor(period: number, tradingPeriods: number)
  update(open: number, high: number, low: number, close: number): number | null
  batch(open: Array<number>, high: Array<number>, low: Array<number>, close: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type RogersSatchellVolatilityNode = RogersSatchellVolatility
export declare class RogersSatchellVolatility {
  constructor(period: number, tradingPeriods: number)
  update(open: number, high: number, low: number, close: number): number | null
  batch(open: Array<number>, high: Array<number>, low: Array<number>, close: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type GarmanKlassVolatilityNode = GarmanKlassVolatility
export declare class GarmanKlassVolatility {
  constructor(period: number, tradingPeriods: number)
  update(open: number, high: number, low: number, close: number): number | null
  batch(open: Array<number>, high: Array<number>, low: Array<number>, close: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type ParkinsonVolatilityNode = ParkinsonVolatility
export declare class ParkinsonVolatility {
  constructor(period: number, tradingPeriods: number)
  update(high: number, low: number): number | null
  batch(high: Array<number>, low: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type LinRegAngleNode = LinRegAngle
export declare class LinRegAngle {
  constructor(period: number)
  update(value: number): number | null
  batch(prices: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type BollingerBandwidthNode = BollingerBandwidth
export declare class BollingerBandwidth {
  constructor(period: number, multiplier: number)
  update(value: number): number | null
  batch(prices: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type PercentBNode = PercentB
export declare class PercentB {
  constructor(period: number, multiplier: number)
  update(value: number): number | null
  batch(prices: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type NatrNode = NATR
export declare class NATR {
  constructor(period: number)
  update(high: number, low: number, close: number): number | null
  batch(high: Array<number>, low: Array<number>, close: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type HistoricalVolatilityNode = HistoricalVolatility
export declare class HistoricalVolatility {
  constructor(period: number, tradingPeriods: number)
  update(value: number): number | null
  batch(prices: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type AroonOscillatorNode = AroonOscillator
export declare class AroonOscillator {
  constructor(period: number)
  update(high: number, low: number): number | null
  batch(high: Array<number>, low: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type WaveTrendNode = WaveTrend
export declare class WaveTrend {
  constructor(channelPeriod: number, averagePeriod: number, signalPeriod: number)
  static classic(): WaveTrendNode
  update(high: number, low: number, close: number): WaveTrendValue | null
  batch(high: Array<number>, low: Array<number>, close: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type RwiNode = RWI
export declare class RWI {
  constructor(period: number)
  update(high: number, low: number, close: number): RwiValue | null
  /** Returns `[high0, low0, high1, low1, ...]`, length `2 * n`. Warmup is NaN. */
  batch(high: Array<number>, low: Array<number>, close: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type VortexNode = Vortex
export declare class Vortex {
  constructor(period: number)
  update(high: number, low: number, close: number): VortexValue | null
  /** Returns `[plus0, minus0, plus1, minus1, ...]`, length `2 * n`. Warmup is NaN. */
  batch(high: Array<number>, low: Array<number>, close: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type MassIndexNode = MassIndex
export declare class MassIndex {
  constructor(emaPeriod: number, sumPeriod: number)
  update(high: number, low: number): number | null
  batch(high: Array<number>, low: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type StochRsiNode = StochRSI
export declare class StochRSI {
  constructor(rsiPeriod: number, stochPeriod: number)
  update(value: number): number | null
  batch(prices: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type UltimateOscillatorNode = UltimateOscillator
export declare class UltimateOscillator {
  constructor(short: number, mid: number, long: number)
  update(high: number, low: number, close: number): number | null
  batch(high: Array<number>, low: Array<number>, close: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type PpoNode = PPO
export declare class PPO {
  constructor(fast: number, slow: number)
  update(value: number): number | null
  batch(prices: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type CoppockNode = Coppock
export declare class Coppock {
  constructor(rocLong: number, rocShort: number, wmaPeriod: number)
  update(value: number): number | null
  batch(prices: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type VwmaNode = VWMA
export declare class VWMA {
  constructor(period: number)
  update(close: number, volume: number): number | null
  batch(close: Array<number>, volume: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type MaEnvelopeNode = MaEnvelope
export declare class MaEnvelope {
  constructor(period: number, percent: number)
  update(value: number): MaEnvelopeValue | null
  /** Flat `[upper0, middle0, lower0, upper1, ...]`, length `3 * n`. */
  batch(prices: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type AccelerationBandsNode = AccelerationBands
export declare class AccelerationBands {
  constructor(period: number, factor: number)
  update(high: number, low: number, close: number): AccelerationBandsValue | null
  batch(high: Array<number>, low: Array<number>, close: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type StarcBandsNode = StarcBands
export declare class StarcBands {
  constructor(smaPeriod: number, atrPeriod: number, multiplier: number)
  update(high: number, low: number, close: number): StarcBandsValue | null
  batch(high: Array<number>, low: Array<number>, close: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type AtrBandsNode = AtrBands
export declare class AtrBands {
  constructor(period: number, multiplier: number)
  update(high: number, low: number, close: number): AtrBandsValue | null
  batch(high: Array<number>, low: Array<number>, close: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type HurstChannelNode = HurstChannel
export declare class HurstChannel {
  constructor(period: number, multiplier: number)
  update(high: number, low: number, close: number): HurstChannelValue | null
  batch(high: Array<number>, low: Array<number>, close: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type LinRegChannelNode = LinRegChannel
export declare class LinRegChannel {
  constructor(period: number, multiplier: number)
  update(value: number): LinRegChannelValue | null
  batch(prices: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type StandardErrorBandsNode = StandardErrorBands
export declare class StandardErrorBands {
  constructor(period: number, multiplier: number)
  update(value: number): StandardErrorBandsValue | null
  batch(prices: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type QuartileBandsNode = QuartileBands
export declare class QuartileBands {
  constructor(period: number)
  update(value: number): QuartileBandsValue | null
  batch(prices: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type BomarBandsNode = BomarBands
export declare class BomarBands {
  constructor(period: number, coverage: number)
  update(value: number): BomarBandsValue | null
  batch(prices: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type MedianChannelNode = MedianChannel
export declare class MedianChannel {
  constructor(period: number, multiplier: number)
  update(value: number): MedianChannelValue | null
  batch(prices: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type ProjectionBandsNode = ProjectionBands
export declare class ProjectionBands {
  constructor(period: number)
  update(high: number, low: number): ProjectionBandsValue | null
  batch(high: Array<number>, low: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type CentralPivotRangeNode = CentralPivotRange
export declare class CentralPivotRange {
  constructor()
  update(high: number, low: number, close: number): CentralPivotRangeValue | null
  batch(high: Array<number>, low: Array<number>, close: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type MurreyMathLinesNode = MurreyMathLines
export declare class MurreyMathLines {
  constructor(period: number)
  update(high: number, low: number): MurreyMathLinesValue | null
  batch(high: Array<number>, low: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type AndrewsPitchforkNode = AndrewsPitchfork
export declare class AndrewsPitchfork {
  constructor(strength: number)
  update(high: number, low: number): AndrewsPitchforkValue | null
  batch(high: Array<number>, low: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type VolumeWeightedSrNode = VolumeWeightedSr
export declare class VolumeWeightedSr {
  constructor(period: number)
  update(high: number, low: number, volume: number): VolumeWeightedSrValue | null
  batch(high: Array<number>, low: Array<number>, volume: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type PivotReversalNode = PivotReversal
export declare class PivotReversal {
  constructor(left: number, right: number)
  update(high: number, low: number, close: number): number | null
  batch(high: Array<number>, low: Array<number>, close: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type DoubleBollingerNode = DoubleBollinger
export declare class DoubleBollinger {
  constructor(period: number, kInner: number, kOuter: number)
  update(value: number): DoubleBollingerValue | null
  /** Flat `[u_o, u_i, m, l_i, l_o, ...]`, length `5 * n`. */
  batch(prices: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type TtmSqueezeNode = TtmSqueeze
export declare class TtmSqueeze {
  constructor(period: number, bbMult: number, kcMult: number)
  update(high: number, low: number, close: number): TtmSqueezeValue | null
  /** Flat `[sq0, mom0, sq1, mom1, ...]`, length `2 * n`. */
  batch(high: Array<number>, low: Array<number>, close: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type FractalChaosBandsNode = FractalChaosBands
export declare class FractalChaosBands {
  constructor(k: number)
  update(high: number, low: number): FractalChaosBandsValue | null
  /** Flat `[u0, l0, u1, l1, ...]`, length `2 * n`. */
  batch(high: Array<number>, low: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type VwapStdDevBandsNode = VwapStdDevBands
export declare class VwapStdDevBands {
  constructor(multiplier: number)
  update(high: number, low: number, close: number, volume: number): VwapStdDevBandsValue | null
  /** Flat `[u0, m0, l0, sd0, ...]`, length `4 * n`. */
  batch(high: Array<number>, low: Array<number>, close: Array<number>, volume: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type ClassicPivotsNode = ClassicPivots
export declare class ClassicPivots {
  constructor()
  update(high: number, low: number, close: number): ClassicPivotsValue | null
  batch(high: Array<number>, low: Array<number>, close: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type FibonacciPivotsNode = FibonacciPivots
export declare class FibonacciPivots {
  constructor()
  update(high: number, low: number, close: number): FibonacciPivotsValue | null
  batch(high: Array<number>, low: Array<number>, close: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type CamarillaNode = Camarilla
export declare class Camarilla {
  constructor()
  update(high: number, low: number, close: number): CamarillaValue | null
  batch(high: Array<number>, low: Array<number>, close: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type WoodiePivotsNode = WoodiePivots
export declare class WoodiePivots {
  constructor()
  update(high: number, low: number, close: number): WoodiePivotsValue | null
  batch(high: Array<number>, low: Array<number>, close: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type DemarkPivotsNode = DemarkPivots
export declare class DemarkPivots {
  constructor()
  update(open: number, high: number, low: number, close: number): DemarkPivotsValue | null
  batch(open: Array<number>, high: Array<number>, low: Array<number>, close: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type WilliamsFractalsNode = WilliamsFractals
export declare class WilliamsFractals {
  constructor()
  update(high: number, low: number): WilliamsFractalsValue | null
  batch(high: Array<number>, low: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type ZigZagNode = ZigZag
export declare class ZigZag {
  constructor(threshold: number)
  update(high: number, low: number): ZigZagValue | null
  batch(high: Array<number>, low: Array<number>): Array<number>
  get threshold(): number
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type TdSetupNode = TDSetup
export declare class TDSetup {
  constructor(lookback: number, target: number)
  update(high: number, low: number, close: number): number | null
  batch(high: Array<number>, low: Array<number>, close: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type TdSequentialNode = TDSequential
export declare class TDSequential {
  constructor(setupLookback: number, setupTarget: number, countdownLookback: number, countdownTarget: number)
  update(high: number, low: number, close: number): TdSequentialValue | null
  /** Batch returns a flat array `[setup0, countdown0, direction0, setup1, ...]`. */
  batch(high: Array<number>, low: Array<number>, close: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type TdDeMarkerNode = TDDeMarker
export declare class TDDeMarker {
  constructor(period: number)
  update(high: number, low: number): number | null
  batch(high: Array<number>, low: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type TdReiNode = TDREI
export declare class TDREI {
  constructor(period: number)
  update(high: number, low: number): number | null
  batch(high: Array<number>, low: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type TdPressureNode = TDPressure
export declare class TDPressure {
  constructor(period: number)
  update(open: number, high: number, low: number, close: number, volume: number): number | null
  batch(open: Array<number>, high: Array<number>, low: Array<number>, close: Array<number>, volume: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type TdComboNode = TDCombo
export declare class TDCombo {
  constructor(setupLookback: number, setupTarget: number, countdownLookback: number, countdownTarget: number)
  update(high: number, low: number, close: number): number | null
  batch(high: Array<number>, low: Array<number>, close: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type TdDWaveNode = TDDWave
export declare class TDDWave {
  constructor(strength: number)
  update(high: number, low: number, close: number): number | null
  batch(high: Array<number>, low: Array<number>, close: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type TdMovingAverageNode = TDMovingAverage
export declare class TDMovingAverage {
  constructor(periodSt1: number, periodSt2: number)
  update(high: number, low: number): TdMovingAverageValue | null
  batch(high: Array<number>, low: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type TdCountdownNode = TDCountdown
export declare class TDCountdown {
  constructor(setupLookback: number, setupTarget: number, countdownLookback: number, countdownTarget: number)
  update(high: number, low: number, close: number): number | null
  batch(high: Array<number>, low: Array<number>, close: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type TdLinesNode = TDLines
export declare class TDLines {
  constructor(lookback: number, target: number)
  update(high: number, low: number, close: number): TdLinesValue | null
  /** Batch returns a flat array `[resistance0, support0, resistance1, ...]`. */
  batch(high: Array<number>, low: Array<number>, close: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type TdRangeProjectionNode = TDRangeProjection
export declare class TDRangeProjection {
  constructor()
  update(open: number, high: number, low: number, close: number): TdRangeProjectionValue | null
  /** Batch returns a flat array `[high0, low0, high1, low1, ...]`. */
  batch(open: Array<number>, high: Array<number>, low: Array<number>, close: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type TdDifferentialNode = TDDifferential
export declare class TDDifferential {
  constructor()
  update(high: number, low: number, close: number): number | null
  batch(high: Array<number>, low: Array<number>, close: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type TdOpenNode = TDOpen
export declare class TDOpen {
  constructor()
  update(open: number, high: number, low: number, close: number): number | null
  batch(open: Array<number>, high: Array<number>, low: Array<number>, close: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type TdRiskLevelNode = TDRiskLevel
export declare class TDRiskLevel {
  constructor(lookback: number, target: number)
  update(high: number, low: number, close: number): TdRiskLevelValue | null
  /** Batch returns a flat array `[buyRisk0, sellRisk0, buyRisk1, ...]`. */
  batch(high: Array<number>, low: Array<number>, close: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type InverseFisherTransformNode = InverseFisherTransform
export declare class InverseFisherTransform {
  constructor(scale: number)
  update(value: number): number | null
  batch(prices: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type DecyclerOscillatorNode = DecyclerOscillator
export declare class DecyclerOscillator {
  constructor(fast: number, slow: number)
  update(value: number): number | null
  batch(prices: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type RoofingFilterNode = RoofingFilter
export declare class RoofingFilter {
  constructor(lpPeriod: number, hpPeriod: number)
  update(value: number): number | null
  batch(prices: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type EmpiricalModeDecompositionNode = EmpiricalModeDecomposition
export declare class EmpiricalModeDecomposition {
  constructor(period: number, fraction: number)
  update(value: number): number | null
  batch(prices: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type HtDcPhaseNode = HT_DCPHASE
export declare class HT_DCPHASE {
  constructor()
  update(value: number): number | null
  batch(prices: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type HtTrendModeNode = HT_TRENDMODE
export declare class HT_TRENDMODE {
  constructor()
  update(value: number): number | null
  batch(prices: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type HilbertDominantCycleNode = HilbertDominantCycle
export declare class HilbertDominantCycle {
  constructor()
  update(value: number): number | null
  batch(prices: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type AdaptiveCycleNode = AdaptiveCycle
export declare class AdaptiveCycle {
  constructor()
  update(value: number): number | null
  batch(prices: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type SineWaveNode = SineWave
export declare class SineWave {
  constructor()
  update(value: number): number | null
  batch(prices: Array<number>): Array<number>
  lead(): number
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type MamaNode = MAMA
export declare class MAMA {
  constructor(fastLimit: number, slowLimit: number)
  update(value: number): MamaValue | null
  /** Returns a flat array of length `2 * n`: `[mama0, fama0, mama1, fama1, ...]`. */
  batch(prices: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type FamaNode = FAMA
export declare class FAMA {
  constructor(fastLimit: number, slowLimit: number)
  update(value: number): number | null
  batch(prices: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type IchimokuNode = Ichimoku
export declare class Ichimoku {
  constructor(tenkanPeriod: number, kijunPeriod: number, senkouBPeriod: number, displacement: number)
  update(high: number, low: number, close: number): IchimokuValue | null
  /**
   * Returns `[tenkan0, kijun0, senkouA0, senkouB0, chikou0, tenkan1, ...]`,
   * length `5 * n`. Cells without a defined value are `NaN`.
   */
  batch(high: Array<number>, low: Array<number>, close: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type HeikinAshiNode = HeikinAshi
export declare class HeikinAshi {
  constructor()
  update(open: number, high: number, low: number, close: number): HeikinAshiValue | null
  /** Returns `[open0, high0, low0, close0, open1, ...]`, length `4 * n`. */
  batch(open: Array<number>, high: Array<number>, low: Array<number>, close: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type HeikinAshiOscillatorNode = HeikinAshiOscillator
export declare class HeikinAshiOscillator {
  constructor(period: number)
  update(open: number, high: number, low: number, close: number): number | null
  batch(open: Array<number>, high: Array<number>, low: Array<number>, close: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type ThreeLineBreakNode = ThreeLineBreak
export declare class ThreeLineBreak {
  constructor(lines: number)
  update(high: number, low: number, close: number): number | null
  batch(high: Array<number>, low: Array<number>, close: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type SmoothedHeikinAshiNode = SmoothedHeikinAshi
export declare class SmoothedHeikinAshi {
  constructor(period: number)
  update(open: number, high: number, low: number, close: number): SmoothedHeikinAshiValue | null
  batch(open: Array<number>, high: Array<number>, low: Array<number>, close: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type EquivolumeNode = Equivolume
export declare class Equivolume {
  constructor(period: number)
  update(high: number, low: number, volume: number): EquivolumeValue | null
  batch(high: Array<number>, low: Array<number>, volume: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type CandleVolumeNode = CandleVolume
export declare class CandleVolume {
  constructor(period: number)
  update(open: number, close: number, volume: number): CandleVolumeValue | null
  batch(open: Array<number>, close: Array<number>, volume: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type FryPanBottomNode = FryPanBottom
export declare class FryPanBottom {
  constructor(period: number)
  update(high: number, low: number, close: number): number | null
  batch(high: Array<number>, low: Array<number>, close: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type DumplingTopNode = DumplingTop
export declare class DumplingTop {
  constructor(period: number)
  update(high: number, low: number, close: number): number | null
  batch(high: Array<number>, low: Array<number>, close: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type NewPriceLinesNode = NewPriceLines
export declare class NewPriceLines {
  constructor(count: number)
  update(high: number, low: number, close: number): number | null
  batch(high: Array<number>, low: Array<number>, close: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type ValueAreaNode = ValueArea
export declare class ValueArea {
  constructor(period: number, binCount: number, valueAreaPct: number)
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
  update(high: number, low: number, volume: number): ValueAreaValue | null
  batch(high: Array<number>, low: Array<number>, volume: Array<number>): Array<number>
}
export type NakedPocNode = NakedPoc
export declare class NakedPoc {
  constructor(sessionLen: number, binCount: number)
  update(high: number, low: number, close: number, volume: number): number | null
  batch(high: Array<number>, low: Array<number>, close: Array<number>, volume: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type SinglePrintsNode = SinglePrints
export declare class SinglePrints {
  constructor(period: number, binCount: number)
  update(high: number, low: number): number | null
  batch(high: Array<number>, low: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type ProfileShapeNode = ProfileShape
export declare class ProfileShape {
  constructor(period: number, binCount: number)
  update(high: number, low: number, volume: number): number | null
  batch(high: Array<number>, low: Array<number>, volume: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type HighLowVolumeNodesNode = HighLowVolumeNodes
export declare class HighLowVolumeNodes {
  constructor(period: number, binCount: number)
  update(high: number, low: number, volume: number): HighLowVolumeNodesValue | null
  batch(high: Array<number>, low: Array<number>, volume: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type CompositeProfileNode = CompositeProfile
export declare class CompositeProfile {
  constructor(period: number, binCount: number, valueAreaPct: number)
  update(high: number, low: number, volume: number): CompositeProfileValue | null
  batch(high: Array<number>, low: Array<number>, volume: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type VolumeProfileNode = VolumeProfile
export declare class VolumeProfile {
  constructor(period: number, binCount: number)
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
  update(high: number, low: number, volume: number): VolumeProfileValue | null
  batch(high: Array<number>, low: Array<number>, volume: Array<number>): Array<number>
}
export type TpoProfileNode = TpoProfile
export declare class TpoProfile {
  constructor(period: number, binCount: number)
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
  update(high: number, low: number): TpoProfileValue | null
  batch(high: Array<number>, low: Array<number>): Array<number>
}
export type InitialBalanceNode = InitialBalance
export declare class InitialBalance {
  constructor(period: number)
  reset(): void
  isReady(): boolean
  isLocked(): boolean
  warmupPeriod(): number
  update(high: number, low: number): InitialBalanceValue | null
  batch(high: Array<number>, low: Array<number>): Array<number>
}
export type OpeningRangeNode = OpeningRange
export declare class OpeningRange {
  constructor(period: number)
  reset(): void
  isReady(): boolean
  isLocked(): boolean
  warmupPeriod(): number
  update(high: number, low: number, close: number): OpeningRangeValue | null
  batch(high: Array<number>, low: Array<number>, close: Array<number>): Array<number>
}
export type DojiNode = Doji
export declare class Doji {
  constructor(signed?: boolean | undefined | null)
  update(open: number, high: number, low: number, close: number): number | null
  batch(open: Array<number>, high: Array<number>, low: Array<number>, close: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
  isSigned(): boolean
}
export type HammerNode = Hammer
export declare class Hammer {
  constructor()
  update(open: number, high: number, low: number, close: number): number | null
  batch(open: Array<number>, high: Array<number>, low: Array<number>, close: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type InvertedHammerNode = InvertedHammer
export declare class InvertedHammer {
  constructor()
  update(open: number, high: number, low: number, close: number): number | null
  batch(open: Array<number>, high: Array<number>, low: Array<number>, close: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type HangingManNode = HangingMan
export declare class HangingMan {
  constructor()
  update(open: number, high: number, low: number, close: number): number | null
  batch(open: Array<number>, high: Array<number>, low: Array<number>, close: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type ShootingStarNode = ShootingStar
export declare class ShootingStar {
  constructor()
  update(open: number, high: number, low: number, close: number): number | null
  batch(open: Array<number>, high: Array<number>, low: Array<number>, close: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type EngulfingNode = Engulfing
export declare class Engulfing {
  constructor()
  update(open: number, high: number, low: number, close: number): number | null
  batch(open: Array<number>, high: Array<number>, low: Array<number>, close: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type HaramiNode = Harami
export declare class Harami {
  constructor()
  update(open: number, high: number, low: number, close: number): number | null
  batch(open: Array<number>, high: Array<number>, low: Array<number>, close: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type MorningEveningStarNode = MorningEveningStar
export declare class MorningEveningStar {
  constructor()
  update(open: number, high: number, low: number, close: number): number | null
  batch(open: Array<number>, high: Array<number>, low: Array<number>, close: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type ThreeSoldiersOrCrowsNode = ThreeSoldiersOrCrows
export declare class ThreeSoldiersOrCrows {
  constructor()
  update(open: number, high: number, low: number, close: number): number | null
  batch(open: Array<number>, high: Array<number>, low: Array<number>, close: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type PiercingDarkCloudNode = PiercingDarkCloud
export declare class PiercingDarkCloud {
  constructor()
  update(open: number, high: number, low: number, close: number): number | null
  batch(open: Array<number>, high: Array<number>, low: Array<number>, close: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type MarubozuNode = Marubozu
export declare class Marubozu {
  constructor()
  update(open: number, high: number, low: number, close: number): number | null
  batch(open: Array<number>, high: Array<number>, low: Array<number>, close: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type TweezerNode = Tweezer
export declare class Tweezer {
  constructor()
  update(open: number, high: number, low: number, close: number): number | null
  batch(open: Array<number>, high: Array<number>, low: Array<number>, close: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type SpinningTopNode = SpinningTop
export declare class SpinningTop {
  constructor()
  update(open: number, high: number, low: number, close: number): number | null
  batch(open: Array<number>, high: Array<number>, low: Array<number>, close: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type ThreeInsideNode = ThreeInside
export declare class ThreeInside {
  constructor()
  update(open: number, high: number, low: number, close: number): number | null
  batch(open: Array<number>, high: Array<number>, low: Array<number>, close: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type ThreeOutsideNode = ThreeOutside
export declare class ThreeOutside {
  constructor()
  update(open: number, high: number, low: number, close: number): number | null
  batch(open: Array<number>, high: Array<number>, low: Array<number>, close: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type TwoCrowsNode = TwoCrows
export declare class TwoCrows {
  constructor()
  update(open: number, high: number, low: number, close: number): number | null
  batch(open: Array<number>, high: Array<number>, low: Array<number>, close: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type UpsideGapTwoCrowsNode = UpsideGapTwoCrows
export declare class UpsideGapTwoCrows {
  constructor()
  update(open: number, high: number, low: number, close: number): number | null
  batch(open: Array<number>, high: Array<number>, low: Array<number>, close: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type IdenticalThreeCrowsNode = IdenticalThreeCrows
export declare class IdenticalThreeCrows {
  constructor()
  update(open: number, high: number, low: number, close: number): number | null
  batch(open: Array<number>, high: Array<number>, low: Array<number>, close: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type ThreeLineStrikeNode = ThreeLineStrike
export declare class ThreeLineStrike {
  constructor()
  update(open: number, high: number, low: number, close: number): number | null
  batch(open: Array<number>, high: Array<number>, low: Array<number>, close: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type ThreeStarsInSouthNode = ThreeStarsInSouth
export declare class ThreeStarsInSouth {
  constructor()
  update(open: number, high: number, low: number, close: number): number | null
  batch(open: Array<number>, high: Array<number>, low: Array<number>, close: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type AbandonedBabyNode = AbandonedBaby
export declare class AbandonedBaby {
  constructor()
  update(open: number, high: number, low: number, close: number): number | null
  batch(open: Array<number>, high: Array<number>, low: Array<number>, close: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type AdvanceBlockNode = AdvanceBlock
export declare class AdvanceBlock {
  constructor()
  update(open: number, high: number, low: number, close: number): number | null
  batch(open: Array<number>, high: Array<number>, low: Array<number>, close: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type BeltHoldNode = BeltHold
export declare class BeltHold {
  constructor()
  update(open: number, high: number, low: number, close: number): number | null
  batch(open: Array<number>, high: Array<number>, low: Array<number>, close: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type BreakawayNode = Breakaway
export declare class Breakaway {
  constructor()
  update(open: number, high: number, low: number, close: number): number | null
  batch(open: Array<number>, high: Array<number>, low: Array<number>, close: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type CounterattackNode = Counterattack
export declare class Counterattack {
  constructor()
  update(open: number, high: number, low: number, close: number): number | null
  batch(open: Array<number>, high: Array<number>, low: Array<number>, close: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type DojiStarNode = DojiStar
export declare class DojiStar {
  constructor()
  update(open: number, high: number, low: number, close: number): number | null
  batch(open: Array<number>, high: Array<number>, low: Array<number>, close: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type DragonflyDojiNode = DragonflyDoji
export declare class DragonflyDoji {
  constructor()
  update(open: number, high: number, low: number, close: number): number | null
  batch(open: Array<number>, high: Array<number>, low: Array<number>, close: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type GravestoneDojiNode = GravestoneDoji
export declare class GravestoneDoji {
  constructor()
  update(open: number, high: number, low: number, close: number): number | null
  batch(open: Array<number>, high: Array<number>, low: Array<number>, close: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type LongLeggedDojiNode = LongLeggedDoji
export declare class LongLeggedDoji {
  constructor()
  update(open: number, high: number, low: number, close: number): number | null
  batch(open: Array<number>, high: Array<number>, low: Array<number>, close: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type RickshawManNode = RickshawMan
export declare class RickshawMan {
  constructor()
  update(open: number, high: number, low: number, close: number): number | null
  batch(open: Array<number>, high: Array<number>, low: Array<number>, close: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type EveningDojiStarNode = EveningDojiStar
export declare class EveningDojiStar {
  constructor()
  update(open: number, high: number, low: number, close: number): number | null
  batch(open: Array<number>, high: Array<number>, low: Array<number>, close: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type MorningDojiStarNode = MorningDojiStar
export declare class MorningDojiStar {
  constructor()
  update(open: number, high: number, low: number, close: number): number | null
  batch(open: Array<number>, high: Array<number>, low: Array<number>, close: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type GapSideBySideWhiteNode = GapSideBySideWhite
export declare class GapSideBySideWhite {
  constructor()
  update(open: number, high: number, low: number, close: number): number | null
  batch(open: Array<number>, high: Array<number>, low: Array<number>, close: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type HighWaveNode = HighWave
export declare class HighWave {
  constructor()
  update(open: number, high: number, low: number, close: number): number | null
  batch(open: Array<number>, high: Array<number>, low: Array<number>, close: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type HikkakeNode = Hikkake
export declare class Hikkake {
  constructor()
  update(open: number, high: number, low: number, close: number): number | null
  batch(open: Array<number>, high: Array<number>, low: Array<number>, close: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type HikkakeModifiedNode = HikkakeModified
export declare class HikkakeModified {
  constructor()
  update(open: number, high: number, low: number, close: number): number | null
  batch(open: Array<number>, high: Array<number>, low: Array<number>, close: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type HomingPigeonNode = HomingPigeon
export declare class HomingPigeon {
  constructor()
  update(open: number, high: number, low: number, close: number): number | null
  batch(open: Array<number>, high: Array<number>, low: Array<number>, close: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type OnNeckNode = OnNeck
export declare class OnNeck {
  constructor()
  update(open: number, high: number, low: number, close: number): number | null
  batch(open: Array<number>, high: Array<number>, low: Array<number>, close: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type InNeckNode = InNeck
export declare class InNeck {
  constructor()
  update(open: number, high: number, low: number, close: number): number | null
  batch(open: Array<number>, high: Array<number>, low: Array<number>, close: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type ThrustingNode = Thrusting
export declare class Thrusting {
  constructor()
  update(open: number, high: number, low: number, close: number): number | null
  batch(open: Array<number>, high: Array<number>, low: Array<number>, close: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type SeparatingLinesNode = SeparatingLines
export declare class SeparatingLines {
  constructor()
  update(open: number, high: number, low: number, close: number): number | null
  batch(open: Array<number>, high: Array<number>, low: Array<number>, close: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type KickingNode = Kicking
export declare class Kicking {
  constructor()
  update(open: number, high: number, low: number, close: number): number | null
  batch(open: Array<number>, high: Array<number>, low: Array<number>, close: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type KickingByLengthNode = KickingByLength
export declare class KickingByLength {
  constructor()
  update(open: number, high: number, low: number, close: number): number | null
  batch(open: Array<number>, high: Array<number>, low: Array<number>, close: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type LadderBottomNode = LadderBottom
export declare class LadderBottom {
  constructor()
  update(open: number, high: number, low: number, close: number): number | null
  batch(open: Array<number>, high: Array<number>, low: Array<number>, close: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type MatHoldNode = MatHold
export declare class MatHold {
  constructor()
  update(open: number, high: number, low: number, close: number): number | null
  batch(open: Array<number>, high: Array<number>, low: Array<number>, close: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type MatchingLowNode = MatchingLow
export declare class MatchingLow {
  constructor()
  update(open: number, high: number, low: number, close: number): number | null
  batch(open: Array<number>, high: Array<number>, low: Array<number>, close: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type LongLineNode = LongLine
export declare class LongLine {
  constructor()
  update(open: number, high: number, low: number, close: number): number | null
  batch(open: Array<number>, high: Array<number>, low: Array<number>, close: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type ShortLineNode = ShortLine
export declare class ShortLine {
  constructor()
  update(open: number, high: number, low: number, close: number): number | null
  batch(open: Array<number>, high: Array<number>, low: Array<number>, close: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type RisingThreeMethodsNode = RisingThreeMethods
export declare class RisingThreeMethods {
  constructor()
  update(open: number, high: number, low: number, close: number): number | null
  batch(open: Array<number>, high: Array<number>, low: Array<number>, close: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type FallingThreeMethodsNode = FallingThreeMethods
export declare class FallingThreeMethods {
  constructor()
  update(open: number, high: number, low: number, close: number): number | null
  batch(open: Array<number>, high: Array<number>, low: Array<number>, close: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type UpsideGapThreeMethodsNode = UpsideGapThreeMethods
export declare class UpsideGapThreeMethods {
  constructor()
  update(open: number, high: number, low: number, close: number): number | null
  batch(open: Array<number>, high: Array<number>, low: Array<number>, close: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type DownsideGapThreeMethodsNode = DownsideGapThreeMethods
export declare class DownsideGapThreeMethods {
  constructor()
  update(open: number, high: number, low: number, close: number): number | null
  batch(open: Array<number>, high: Array<number>, low: Array<number>, close: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type StalledPatternNode = StalledPattern
export declare class StalledPattern {
  constructor()
  update(open: number, high: number, low: number, close: number): number | null
  batch(open: Array<number>, high: Array<number>, low: Array<number>, close: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type StickSandwichNode = StickSandwich
export declare class StickSandwich {
  constructor()
  update(open: number, high: number, low: number, close: number): number | null
  batch(open: Array<number>, high: Array<number>, low: Array<number>, close: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type TakuriNode = Takuri
export declare class Takuri {
  constructor()
  update(open: number, high: number, low: number, close: number): number | null
  batch(open: Array<number>, high: Array<number>, low: Array<number>, close: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type ClosingMarubozuNode = ClosingMarubozu
export declare class ClosingMarubozu {
  constructor()
  update(open: number, high: number, low: number, close: number): number | null
  batch(open: Array<number>, high: Array<number>, low: Array<number>, close: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type OpeningMarubozuNode = OpeningMarubozu
export declare class OpeningMarubozu {
  constructor()
  update(open: number, high: number, low: number, close: number): number | null
  batch(open: Array<number>, high: Array<number>, low: Array<number>, close: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type TasukiGapNode = TasukiGap
export declare class TasukiGap {
  constructor()
  update(open: number, high: number, low: number, close: number): number | null
  batch(open: Array<number>, high: Array<number>, low: Array<number>, close: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type UniqueThreeRiverNode = UniqueThreeRiver
export declare class UniqueThreeRiver {
  constructor()
  update(open: number, high: number, low: number, close: number): number | null
  batch(open: Array<number>, high: Array<number>, low: Array<number>, close: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type ConcealingBabySwallowNode = ConcealingBabySwallow
export declare class ConcealingBabySwallow {
  constructor()
  update(open: number, high: number, low: number, close: number): number | null
  batch(open: Array<number>, high: Array<number>, low: Array<number>, close: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type DoubleTopBottomNode = DoubleTopBottom
export declare class DoubleTopBottom {
  constructor()
  update(open: number, high: number, low: number, close: number): number | null
  batch(open: Array<number>, high: Array<number>, low: Array<number>, close: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type TripleTopBottomNode = TripleTopBottom
export declare class TripleTopBottom {
  constructor()
  update(open: number, high: number, low: number, close: number): number | null
  batch(open: Array<number>, high: Array<number>, low: Array<number>, close: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type HeadAndShouldersNode = HeadAndShoulders
export declare class HeadAndShoulders {
  constructor()
  update(open: number, high: number, low: number, close: number): number | null
  batch(open: Array<number>, high: Array<number>, low: Array<number>, close: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type TriangleNode = Triangle
export declare class Triangle {
  constructor()
  update(open: number, high: number, low: number, close: number): number | null
  batch(open: Array<number>, high: Array<number>, low: Array<number>, close: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type WedgeNode = Wedge
export declare class Wedge {
  constructor()
  update(open: number, high: number, low: number, close: number): number | null
  batch(open: Array<number>, high: Array<number>, low: Array<number>, close: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type FlagPennantNode = FlagPennant
export declare class FlagPennant {
  constructor()
  update(open: number, high: number, low: number, close: number): number | null
  batch(open: Array<number>, high: Array<number>, low: Array<number>, close: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type RectangleRangeNode = RectangleRange
export declare class RectangleRange {
  constructor()
  update(open: number, high: number, low: number, close: number): number | null
  batch(open: Array<number>, high: Array<number>, low: Array<number>, close: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type CupAndHandleNode = CupAndHandle
export declare class CupAndHandle {
  constructor()
  update(open: number, high: number, low: number, close: number): number | null
  batch(open: Array<number>, high: Array<number>, low: Array<number>, close: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type AbcdNode = Abcd
export declare class Abcd {
  constructor()
  update(open: number, high: number, low: number, close: number): number | null
  batch(open: Array<number>, high: Array<number>, low: Array<number>, close: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type GartleyNode = Gartley
export declare class Gartley {
  constructor()
  update(open: number, high: number, low: number, close: number): number | null
  batch(open: Array<number>, high: Array<number>, low: Array<number>, close: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type ButterflyNode = Butterfly
export declare class Butterfly {
  constructor()
  update(open: number, high: number, low: number, close: number): number | null
  batch(open: Array<number>, high: Array<number>, low: Array<number>, close: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type BatNode = Bat
export declare class Bat {
  constructor()
  update(open: number, high: number, low: number, close: number): number | null
  batch(open: Array<number>, high: Array<number>, low: Array<number>, close: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type CrabNode = Crab
export declare class Crab {
  constructor()
  update(open: number, high: number, low: number, close: number): number | null
  batch(open: Array<number>, high: Array<number>, low: Array<number>, close: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type SharkNode = Shark
export declare class Shark {
  constructor()
  update(open: number, high: number, low: number, close: number): number | null
  batch(open: Array<number>, high: Array<number>, low: Array<number>, close: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type CypherNode = Cypher
export declare class Cypher {
  constructor()
  update(open: number, high: number, low: number, close: number): number | null
  batch(open: Array<number>, high: Array<number>, low: Array<number>, close: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type ThreeDrivesNode = ThreeDrives
export declare class ThreeDrives {
  constructor()
  update(open: number, high: number, low: number, close: number): number | null
  batch(open: Array<number>, high: Array<number>, low: Array<number>, close: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type TdCamouflageNode = TDCamouflage
export declare class TDCamouflage {
  constructor()
  update(open: number, high: number, low: number, close: number): number | null
  batch(open: Array<number>, high: Array<number>, low: Array<number>, close: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type TdClopNode = TDClop
export declare class TDClop {
  constructor()
  update(open: number, high: number, low: number, close: number): number | null
  batch(open: Array<number>, high: Array<number>, low: Array<number>, close: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type TdClopwinNode = TDClopwin
export declare class TDClopwin {
  constructor()
  update(open: number, high: number, low: number, close: number): number | null
  batch(open: Array<number>, high: Array<number>, low: Array<number>, close: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type TdPropulsionNode = TDPropulsion
export declare class TDPropulsion {
  constructor()
  update(open: number, high: number, low: number, close: number): number | null
  batch(open: Array<number>, high: Array<number>, low: Array<number>, close: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type TdTrapNode = TDTrap
export declare class TDTrap {
  constructor()
  update(open: number, high: number, low: number, close: number): number | null
  batch(open: Array<number>, high: Array<number>, low: Array<number>, close: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type TristarNode = Tristar
export declare class Tristar {
  constructor()
  update(open: number, high: number, low: number, close: number): number | null
  batch(open: Array<number>, high: Array<number>, low: Array<number>, close: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type HaramiCrossNode = HaramiCross
export declare class HaramiCross {
  constructor()
  update(open: number, high: number, low: number, close: number): number | null
  batch(open: Array<number>, high: Array<number>, low: Array<number>, close: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type TowerTopBottomNode = TowerTopBottom
export declare class TowerTopBottom {
  constructor()
  update(open: number, high: number, low: number, close: number): number | null
  batch(open: Array<number>, high: Array<number>, low: Array<number>, close: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type OrderBookImbalanceTop1Node = OrderBookImbalanceTop1
export declare class OrderBookImbalanceTop1 {
  constructor()
  update(bidPx: Array<number>, bidSz: Array<number>, askPx: Array<number>, askSz: Array<number>): number | null
  batch(snapshots: Array<ObSnapshot>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type OrderBookImbalanceFullNode = OrderBookImbalanceFull
export declare class OrderBookImbalanceFull {
  constructor()
  update(bidPx: Array<number>, bidSz: Array<number>, askPx: Array<number>, askSz: Array<number>): number | null
  batch(snapshots: Array<ObSnapshot>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type MicropriceNode = Microprice
export declare class Microprice {
  constructor()
  update(bidPx: Array<number>, bidSz: Array<number>, askPx: Array<number>, askSz: Array<number>): number | null
  batch(snapshots: Array<ObSnapshot>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type QuotedSpreadNode = QuotedSpread
export declare class QuotedSpread {
  constructor()
  update(bidPx: Array<number>, bidSz: Array<number>, askPx: Array<number>, askSz: Array<number>): number | null
  batch(snapshots: Array<ObSnapshot>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type DepthSlopeNode = DepthSlope
export declare class DepthSlope {
  constructor()
  update(bidPx: Array<number>, bidSz: Array<number>, askPx: Array<number>, askSz: Array<number>): number | null
  batch(snapshots: Array<ObSnapshot>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type OrderBookImbalanceTopNNode = OrderBookImbalanceTopN
export declare class OrderBookImbalanceTopN {
  constructor(levels: number)
  update(bidPx: Array<number>, bidSz: Array<number>, askPx: Array<number>, askSz: Array<number>): number | null
  batch(snapshots: Array<ObSnapshot>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type SignedVolumeNode = SignedVolume
export declare class SignedVolume {
  constructor()
  update(price: number, size: number, isBuy: boolean): number | null
  batch(price: Array<number>, size: Array<number>, isBuy: Array<boolean>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type CumulativeVolumeDeltaNode = CumulativeVolumeDelta
export declare class CumulativeVolumeDelta {
  constructor()
  update(price: number, size: number, isBuy: boolean): number | null
  batch(price: Array<number>, size: Array<number>, isBuy: Array<boolean>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type TradeImbalanceNode = TradeImbalance
export declare class TradeImbalance {
  constructor(window: number)
  update(price: number, size: number, isBuy: boolean): number | null
  batch(price: Array<number>, size: Array<number>, isBuy: Array<boolean>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type TradeSignAutocorrelationNode = TradeSignAutocorrelation
export declare class TradeSignAutocorrelation {
  constructor(period: number)
  update(price: number, size: number, isBuy: boolean): number | null
  batch(price: Array<number>, size: Array<number>, isBuy: Array<boolean>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type PinNode = Pin
export declare class Pin {
  constructor(window: number)
  update(price: number, size: number, isBuy: boolean): number | null
  batch(price: Array<number>, size: Array<number>, isBuy: Array<boolean>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type OrderFlowImbalanceNode = OrderFlowImbalance
export declare class OrderFlowImbalance {
  constructor(period: number)
  update(bidPx: Array<number>, bidSz: Array<number>, askPx: Array<number>, askSz: Array<number>): number | null
  batch(snapshots: Array<ObSnapshot>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type VpinNode = Vpin
export declare class Vpin {
  constructor(bucketVolume: number, numBuckets: number)
  update(price: number, size: number, isBuy: boolean): number | null
  batch(price: Array<number>, size: Array<number>, isBuy: Array<boolean>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type AmihudIlliquidityNode = AmihudIlliquidity
export declare class AmihudIlliquidity {
  constructor(period: number)
  update(price: number, size: number, isBuy: boolean): number | null
  batch(price: Array<number>, size: Array<number>, isBuy: Array<boolean>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type RollMeasureNode = RollMeasure
export declare class RollMeasure {
  constructor(period: number)
  update(price: number, size: number, isBuy: boolean): number | null
  batch(price: Array<number>, size: Array<number>, isBuy: Array<boolean>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type EffectiveSpreadNode = EffectiveSpread
export declare class EffectiveSpread {
  constructor()
  update(price: number, size: number, isBuy: boolean, mid: number): number | null
  batch(price: Array<number>, size: Array<number>, isBuy: Array<boolean>, mid: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type RealizedSpreadNode = RealizedSpread
export declare class RealizedSpread {
  constructor(horizon: number)
  update(price: number, size: number, isBuy: boolean, mid: number): number | null
  batch(price: Array<number>, size: Array<number>, isBuy: Array<boolean>, mid: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type KylesLambdaNode = KylesLambda
export declare class KylesLambda {
  constructor(window: number)
  update(price: number, size: number, isBuy: boolean, mid: number): number | null
  batch(price: Array<number>, size: Array<number>, isBuy: Array<boolean>, mid: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type FootprintNode = Footprint
export declare class Footprint {
  constructor(tickSize: number)
  update(price: number, size: number, isBuy: boolean): Array<FootprintLevelValue>
  batch(price: Array<number>, size: Array<number>, isBuy: Array<boolean>): Array<Array<FootprintLevelValue>>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type FundingRateNode = FundingRate
export declare class FundingRate {
  constructor()
  update(fundingRate: number): number | null
  batch(fundingRate: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type FundingRateMeanNode = FundingRateMean
export declare class FundingRateMean {
  constructor(window: number)
  update(fundingRate: number): number | null
  batch(fundingRate: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type FundingRateZScoreNode = FundingRateZScore
export declare class FundingRateZScore {
  constructor(window: number)
  update(fundingRate: number): number | null
  batch(fundingRate: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type FundingBasisNode = FundingBasis
export declare class FundingBasis {
  constructor()
  update(markPrice: number, indexPrice: number): number | null
  batch(markPrice: Array<number>, indexPrice: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type OpenInterestDeltaNode = OpenInterestDelta
export declare class OpenInterestDelta {
  constructor()
  update(openInterest: number): number | null
  batch(openInterest: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type OIPriceDivergenceNode = OIPriceDivergence
export declare class OIPriceDivergence {
  constructor(window: number)
  update(openInterest: number, markPrice: number): number | null
  batch(openInterest: Array<number>, markPrice: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type OIWeightedNode = OIWeighted
export declare class OIWeighted {
  constructor()
  update(markPrice: number, openInterest: number): number | null
  batch(markPrice: Array<number>, openInterest: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type LongShortRatioNode = LongShortRatio
export declare class LongShortRatio {
  constructor()
  update(longSize: number, shortSize: number): number | null
  batch(longSize: Array<number>, shortSize: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type TakerBuySellRatioNode = TakerBuySellRatio
export declare class TakerBuySellRatio {
  constructor()
  update(takerBuyVolume: number, takerSellVolume: number): number | null
  batch(takerBuyVolume: Array<number>, takerSellVolume: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type LiquidationFeaturesNode = LiquidationFeatures
export declare class LiquidationFeatures {
  constructor()
  update(longLiquidation: number, shortLiquidation: number): LiquidationFeaturesValue | null
  batch(longLiquidation: Array<number>, shortLiquidation: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type TermStructureBasisNode = TermStructureBasis
export declare class TermStructureBasis {
  constructor()
  update(futuresPrice: number, indexPrice: number): number | null
  batch(futuresPrice: Array<number>, indexPrice: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type CalendarSpreadNode = CalendarSpread
export declare class CalendarSpread {
  constructor()
  update(futuresPrice: number, markPrice: number): number | null
  batch(futuresPrice: Array<number>, markPrice: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type EstimatedLeverageRatioNode = EstimatedLeverageRatio
export declare class EstimatedLeverageRatio {
  constructor()
  update(openInterest: number, longSize: number, shortSize: number): number | null
  batch(openInterest: Array<number>, longSize: Array<number>, shortSize: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type OiToVolumeRatioNode = OiToVolumeRatio
export declare class OiToVolumeRatio {
  constructor()
  update(openInterest: number, takerBuyVolume: number, takerSellVolume: number): number | null
  batch(openInterest: Array<number>, takerBuyVolume: Array<number>, takerSellVolume: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type PerpetualPremiumIndexNode = PerpetualPremiumIndex
export declare class PerpetualPremiumIndex {
  constructor()
  update(markPrice: number, indexPrice: number): number | null
  batch(markPrice: Array<number>, indexPrice: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type FundingImpliedAprNode = FundingImpliedApr
export declare class FundingImpliedApr {
  constructor(intervalsPerYear: number)
  update(fundingRate: number): number | null
  batch(fundingRate: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type OpenInterestMomentumNode = OpenInterestMomentum
export declare class OpenInterestMomentum {
  constructor(period: number)
  update(openInterest: number): number | null
  batch(openInterest: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type AdvanceDeclineNode = AdvanceDecline
export declare class AdvanceDecline {
  constructor()
  update(change: Array<number>, volume: Array<number>, newHigh: Array<boolean>, newLow: Array<boolean>): number | null
  batch(change: Array<Array<number>>, volume: Array<Array<number>>, newHigh: Array<Array<boolean>>, newLow: Array<Array<boolean>>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type AdvanceDeclineRatioNode = AdvanceDeclineRatio
export declare class AdvanceDeclineRatio {
  constructor()
  update(change: Array<number>, volume: Array<number>, newHigh: Array<boolean>, newLow: Array<boolean>): number | null
  batch(change: Array<Array<number>>, volume: Array<Array<number>>, newHigh: Array<Array<boolean>>, newLow: Array<Array<boolean>>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type AdVolumeLineNode = AdVolumeLine
export declare class AdVolumeLine {
  constructor()
  update(change: Array<number>, volume: Array<number>, newHigh: Array<boolean>, newLow: Array<boolean>): number | null
  batch(change: Array<Array<number>>, volume: Array<Array<number>>, newHigh: Array<Array<boolean>>, newLow: Array<Array<boolean>>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type McClellanOscillatorNode = McClellanOscillator
export declare class McClellanOscillator {
  constructor()
  update(change: Array<number>, volume: Array<number>, newHigh: Array<boolean>, newLow: Array<boolean>): number | null
  batch(change: Array<Array<number>>, volume: Array<Array<number>>, newHigh: Array<Array<boolean>>, newLow: Array<Array<boolean>>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type McClellanSummationIndexNode = McClellanSummationIndex
export declare class McClellanSummationIndex {
  constructor()
  update(change: Array<number>, volume: Array<number>, newHigh: Array<boolean>, newLow: Array<boolean>): number | null
  batch(change: Array<Array<number>>, volume: Array<Array<number>>, newHigh: Array<Array<boolean>>, newLow: Array<Array<boolean>>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type TrinNode = Trin
export declare class Trin {
  constructor()
  update(change: Array<number>, volume: Array<number>, newHigh: Array<boolean>, newLow: Array<boolean>): number | null
  batch(change: Array<Array<number>>, volume: Array<Array<number>>, newHigh: Array<Array<boolean>>, newLow: Array<Array<boolean>>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type BreadthThrustNode = BreadthThrust
export declare class BreadthThrust {
  constructor(period: number)
  update(change: Array<number>, volume: Array<number>, newHigh: Array<boolean>, newLow: Array<boolean>): number | null
  batch(change: Array<Array<number>>, volume: Array<Array<number>>, newHigh: Array<Array<boolean>>, newLow: Array<Array<boolean>>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type NewHighsNewLowsNode = NewHighsNewLows
export declare class NewHighsNewLows {
  constructor()
  update(change: Array<number>, volume: Array<number>, newHigh: Array<boolean>, newLow: Array<boolean>): number | null
  batch(change: Array<Array<number>>, volume: Array<Array<number>>, newHigh: Array<Array<boolean>>, newLow: Array<Array<boolean>>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type HighLowIndexNode = HighLowIndex
export declare class HighLowIndex {
  constructor(period: number)
  update(change: Array<number>, volume: Array<number>, newHigh: Array<boolean>, newLow: Array<boolean>): number | null
  batch(change: Array<Array<number>>, volume: Array<Array<number>>, newHigh: Array<Array<boolean>>, newLow: Array<Array<boolean>>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type PercentAboveMaNode = PercentAboveMa
export declare class PercentAboveMa {
  constructor()
  update(change: Array<number>, volume: Array<number>, newHigh: Array<boolean>, newLow: Array<boolean>, aboveMa: Array<boolean>): number | null
  batch(change: Array<Array<number>>, volume: Array<Array<number>>, newHigh: Array<Array<boolean>>, newLow: Array<Array<boolean>>, aboveMa: Array<Array<boolean>>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type UpDownVolumeRatioNode = UpDownVolumeRatio
export declare class UpDownVolumeRatio {
  constructor()
  update(change: Array<number>, volume: Array<number>, newHigh: Array<boolean>, newLow: Array<boolean>): number | null
  batch(change: Array<Array<number>>, volume: Array<Array<number>>, newHigh: Array<Array<boolean>>, newLow: Array<Array<boolean>>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type BullishPercentIndexNode = BullishPercentIndex
export declare class BullishPercentIndex {
  constructor()
  update(change: Array<number>, volume: Array<number>, newHigh: Array<boolean>, newLow: Array<boolean>, onBuySignal: Array<boolean>): number | null
  batch(change: Array<Array<number>>, volume: Array<Array<number>>, newHigh: Array<Array<boolean>>, newLow: Array<Array<boolean>>, onBuySignal: Array<Array<boolean>>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type CumulativeVolumeIndexNode = CumulativeVolumeIndex
export declare class CumulativeVolumeIndex {
  constructor()
  update(change: Array<number>, volume: Array<number>, newHigh: Array<boolean>, newLow: Array<boolean>): number | null
  batch(change: Array<Array<number>>, volume: Array<Array<number>>, newHigh: Array<Array<boolean>>, newLow: Array<Array<boolean>>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type AbsoluteBreadthIndexNode = AbsoluteBreadthIndex
export declare class AbsoluteBreadthIndex {
  constructor()
  update(change: Array<number>, volume: Array<number>, newHigh: Array<boolean>, newLow: Array<boolean>): number | null
  batch(change: Array<Array<number>>, volume: Array<Array<number>>, newHigh: Array<Array<boolean>>, newLow: Array<Array<boolean>>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type TickIndexNode = TickIndex
export declare class TickIndex {
  constructor()
  update(change: Array<number>, volume: Array<number>, newHigh: Array<boolean>, newLow: Array<boolean>): number | null
  batch(change: Array<Array<number>>, volume: Array<Array<number>>, newHigh: Array<Array<boolean>>, newLow: Array<Array<boolean>>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type SharpeRatioNode = SharpeRatio
export declare class SharpeRatio {
  constructor(period: number, riskFree: number)
  update(value: number): number | null
  batch(prices: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type SortinoRatioNode = SortinoRatio
export declare class SortinoRatio {
  constructor(period: number, mar: number)
  update(value: number): number | null
  batch(prices: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type CalmarRatioNode = CalmarRatio
export declare class CalmarRatio {
  constructor(period: number)
  update(value: number): number | null
  batch(prices: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type OmegaRatioNode = OmegaRatio
export declare class OmegaRatio {
  constructor(period: number, threshold: number)
  update(value: number): number | null
  batch(prices: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type MaxDrawdownNode = MaxDrawdown
export declare class MaxDrawdown {
  constructor(period: number)
  update(value: number): number | null
  batch(prices: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type AverageDrawdownNode = AverageDrawdown
export declare class AverageDrawdown {
  constructor(period: number)
  update(value: number): number | null
  batch(prices: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type DrawdownDurationNode = DrawdownDuration
export declare class DrawdownDuration {
  constructor()
  update(value: number): number | null
  batch(prices: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type PainIndexNode = PainIndex
export declare class PainIndex {
  constructor(period: number)
  update(value: number): number | null
  batch(prices: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type ValueAtRiskNode = ValueAtRisk
export declare class ValueAtRisk {
  constructor(period: number, confidence: number)
  update(value: number): number | null
  batch(prices: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type ConditionalValueAtRiskNode = ConditionalValueAtRisk
export declare class ConditionalValueAtRisk {
  constructor(period: number, confidence: number)
  update(value: number): number | null
  batch(prices: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type ProfitFactorNode = ProfitFactor
export declare class ProfitFactor {
  constructor(period: number)
  update(value: number): number | null
  batch(prices: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type GainLossRatioNode = GainLossRatio
export declare class GainLossRatio {
  constructor(period: number)
  update(value: number): number | null
  batch(prices: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type RecoveryFactorNode = RecoveryFactor
export declare class RecoveryFactor {
  constructor()
  update(value: number): number | null
  batch(prices: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type KellyCriterionNode = KellyCriterion
export declare class KellyCriterion {
  constructor(period: number)
  update(value: number): number | null
  batch(prices: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type TreynorRatioNode = TreynorRatio
export declare class TreynorRatio {
  constructor(period: number, riskFree: number)
  update(asset: number, benchmark: number): number | null
  batch(asset: Array<number>, benchmark: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type InformationRatioNode = InformationRatio
export declare class InformationRatio {
  constructor(period: number)
  update(asset: number, benchmark: number): number | null
  batch(asset: Array<number>, benchmark: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type RenkoBarsNode = RenkoBars
export declare class RenkoBars {
  constructor(boxSize: number)
  update(close: number): Array<RenkoBrickValue>
  batch(close: Array<number>): Array<RenkoBrickValue>
  boxSize(): number
  reset(): void
}
export type KagiBarsNode = KagiBars
export declare class KagiBars {
  constructor(reversal: number)
  update(close: number): Array<KagiSegmentValue>
  batch(close: Array<number>): Array<KagiSegmentValue>
  reversal(): number
  reset(): void
}
export type PointAndFigureBarsNode = PointAndFigureBars
export declare class PointAndFigureBars {
  constructor(boxSize: number, reversal: number)
  update(close: number): Array<PnfColumnValue>
  batch(close: Array<number>): Array<PnfColumnValue>
  boxSize(): number
  reversal(): number
  reset(): void
}
export type RangeBarsNode = RangeBars
export declare class RangeBars {
  constructor(range: number)
  update(close: number): Array<RangeBarValue>
  batch(close: Array<number>): Array<RangeBarValue>
  range(): number
  reset(): void
}
export type TickBarsNode = TickBars
export declare class TickBars {
  constructor(ticks: number)
  update(open: number, high: number, low: number, close: number, volume: number): Array<TickBarValue>
  batch(open: Array<number>, high: Array<number>, low: Array<number>, close: Array<number>, volume: Array<number>): Array<TickBarValue>
  ticks(): number
  reset(): void
}
export type VolumeBarsNode = VolumeBars
export declare class VolumeBars {
  constructor(volumePerBar: number)
  update(open: number, high: number, low: number, close: number, volume: number): Array<VolumeBarValue>
  batch(open: Array<number>, high: Array<number>, low: Array<number>, close: Array<number>, volume: Array<number>): Array<VolumeBarValue>
  volumePerBar(): number
  reset(): void
}
export type DollarBarsNode = DollarBars
export declare class DollarBars {
  constructor(dollarPerBar: number)
  update(open: number, high: number, low: number, close: number, volume: number): Array<DollarBarValue>
  batch(open: Array<number>, high: Array<number>, low: Array<number>, close: Array<number>, volume: Array<number>): Array<DollarBarValue>
  dollarPerBar(): number
  reset(): void
}
export type ImbalanceBarsNode = ImbalanceBars
export declare class ImbalanceBars {
  constructor(threshold: number)
  update(open: number, high: number, low: number, close: number): Array<ImbalanceBarValue>
  batch(open: Array<number>, high: Array<number>, low: Array<number>, close: Array<number>): Array<ImbalanceBarValue>
  threshold(): number
  reset(): void
}
export type RunBarsNode = RunBars
export declare class RunBars {
  constructor(runLength: number)
  update(open: number, high: number, low: number, close: number): Array<RunBarValue>
  batch(open: Array<number>, high: Array<number>, low: Array<number>, close: Array<number>): Array<RunBarValue>
  runLength(): number
  reset(): void
}
export type ThreeLineBreakBarsNode = ThreeLineBreakBars
export declare class ThreeLineBreakBars {
  constructor(lines: number)
  update(close: number): Array<LineBreakBarValue>
  batch(close: Array<number>): Array<LineBreakBarValue>
  lines(): number
  reset(): void
}
export type AlphaNode = Alpha
export declare class Alpha {
  constructor(period: number, riskFree: number)
  update(asset: number, benchmark: number): number | null
  batch(asset: Array<number>, benchmark: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type SessionVwapNode = SessionVwap
export declare class SessionVwap {
  constructor(utcOffsetMinutes: number)
  update(open: number, high: number, low: number, close: number, volume: number, timestamp: number): number | null
  batch(open: Array<number>, high: Array<number>, low: Array<number>, close: Array<number>, volume: Array<number>, timestamp: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
  utcOffsetMinutes(): number
}
export type OvernightGapNode = OvernightGap
export declare class OvernightGap {
  constructor(utcOffsetMinutes: number)
  update(open: number, high: number, low: number, close: number, volume: number, timestamp: number): number | null
  batch(open: Array<number>, high: Array<number>, low: Array<number>, close: Array<number>, volume: Array<number>, timestamp: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
  utcOffsetMinutes(): number
}
export type SeasonalZScoreNode = SeasonalZScore
export declare class SeasonalZScore {
  constructor(utcOffsetMinutes: number)
  update(open: number, high: number, low: number, close: number, volume: number, timestamp: number): number | null
  batch(open: Array<number>, high: Array<number>, low: Array<number>, close: Array<number>, volume: Array<number>, timestamp: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
  utcOffsetMinutes(): number
}
export type TimeOfDayReturnProfileNode = TimeOfDayReturnProfile
export declare class TimeOfDayReturnProfile {
  constructor(buckets: number, utcOffsetMinutes: number)
  update(open: number, high: number, low: number, close: number, volume: number, timestamp: number): Array<number> | null
  batch(open: Array<number>, high: Array<number>, low: Array<number>, close: Array<number>, volume: Array<number>, timestamp: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
  buckets(): number
  utcOffsetMinutes(): number
}
export type IntradayVolatilityProfileNode = IntradayVolatilityProfile
export declare class IntradayVolatilityProfile {
  constructor(buckets: number, utcOffsetMinutes: number)
  update(open: number, high: number, low: number, close: number, volume: number, timestamp: number): Array<number> | null
  batch(open: Array<number>, high: Array<number>, low: Array<number>, close: Array<number>, volume: Array<number>, timestamp: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
  buckets(): number
  utcOffsetMinutes(): number
}
export type VolumeByTimeProfileNode = VolumeByTimeProfile
export declare class VolumeByTimeProfile {
  constructor(buckets: number, utcOffsetMinutes: number)
  update(open: number, high: number, low: number, close: number, volume: number, timestamp: number): Array<number> | null
  batch(open: Array<number>, high: Array<number>, low: Array<number>, close: Array<number>, volume: Array<number>, timestamp: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
  buckets(): number
  utcOffsetMinutes(): number
}
export type DayOfWeekProfileNode = DayOfWeekProfile
export declare class DayOfWeekProfile {
  constructor(utcOffsetMinutes: number)
  update(open: number, high: number, low: number, close: number, volume: number, timestamp: number): Array<number> | null
  batch(open: Array<number>, high: Array<number>, low: Array<number>, close: Array<number>, volume: Array<number>, timestamp: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
  utcOffsetMinutes(): number
}
export type AverageDailyRangeNode = AverageDailyRange
export declare class AverageDailyRange {
  constructor(period: number, utcOffsetMinutes: number)
  update(open: number, high: number, low: number, close: number, volume: number, timestamp: number): number | null
  batch(open: Array<number>, high: Array<number>, low: Array<number>, close: Array<number>, volume: Array<number>, timestamp: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type TurnOfMonthNode = TurnOfMonth
export declare class TurnOfMonth {
  constructor(nFirst: number, nLast: number, utcOffsetMinutes: number)
  update(open: number, high: number, low: number, close: number, volume: number, timestamp: number): number | null
  batch(open: Array<number>, high: Array<number>, low: Array<number>, close: Array<number>, volume: Array<number>, timestamp: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type SessionHighLowNode = SessionHighLow
export declare class SessionHighLow {
  constructor(utcOffsetMinutes: number)
  update(open: number, high: number, low: number, close: number, volume: number, timestamp: number): SessionHighLowValue | null
  batch(open: Array<number>, high: Array<number>, low: Array<number>, close: Array<number>, volume: Array<number>, timestamp: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type SessionRangeNode = SessionRange
export declare class SessionRange {
  constructor(utcOffsetMinutes: number)
  update(open: number, high: number, low: number, close: number, volume: number, timestamp: number): SessionRangeValue | null
  batch(open: Array<number>, high: Array<number>, low: Array<number>, close: Array<number>, volume: Array<number>, timestamp: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type OvernightIntradayReturnNode = OvernightIntradayReturn
export declare class OvernightIntradayReturn {
  constructor(utcOffsetMinutes: number)
  update(open: number, high: number, low: number, close: number, volume: number, timestamp: number): OvernightIntradayReturnValue | null
  batch(open: Array<number>, high: Array<number>, low: Array<number>, close: Array<number>, volume: Array<number>, timestamp: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type FibRetracementNode = FibRetracement
export declare class FibRetracement {
  constructor()
  update(high: number, low: number): FibRetracementValue | null
  batch(high: Array<number>, low: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type FibExtensionNode = FibExtension
export declare class FibExtension {
  constructor()
  update(high: number, low: number): FibExtensionValue | null
  batch(high: Array<number>, low: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type FibProjectionNode = FibProjection
export declare class FibProjection {
  constructor()
  update(high: number, low: number): FibProjectionValue | null
  batch(high: Array<number>, low: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type AutoFibNode = AutoFib
export declare class AutoFib {
  constructor()
  update(high: number, low: number): AutoFibValue | null
  batch(high: Array<number>, low: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type GoldenPocketNode = GoldenPocket
export declare class GoldenPocket {
  constructor()
  update(high: number, low: number): GoldenPocketValue | null
  batch(high: Array<number>, low: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type FibConfluenceNode = FibConfluence
export declare class FibConfluence {
  constructor()
  update(high: number, low: number): FibConfluenceValue | null
  batch(high: Array<number>, low: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type FibFanNode = FibFan
export declare class FibFan {
  constructor()
  update(high: number, low: number): FibFanValue | null
  batch(high: Array<number>, low: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type FibArcsNode = FibArcs
export declare class FibArcs {
  constructor()
  update(high: number, low: number): FibArcsValue | null
  batch(high: Array<number>, low: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type FibChannelNode = FibChannel
export declare class FibChannel {
  constructor()
  update(high: number, low: number): FibChannelValue | null
  batch(high: Array<number>, low: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type FibTimeZonesNode = FibTimeZones
export declare class FibTimeZones {
  constructor()
  update(high: number, low: number): FibTimeZonesValue | null
  batch(high: Array<number>, low: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type VolumeRsiNode = VolumeRsi
export declare class VolumeRsi {
  constructor(period: number)
  update(close: number, volume: number): number | null
  batch(close: Array<number>, volume: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type WadNode = Wad
export declare class Wad {
  constructor()
  update(high: number, low: number, close: number): number | null
  batch(high: Array<number>, low: Array<number>, close: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type TwiggsMoneyFlowNode = TwiggsMoneyFlow
export declare class TwiggsMoneyFlow {
  constructor(period: number)
  update(high: number, low: number, close: number, volume: number): number | null
  batch(high: Array<number>, low: Array<number>, close: Array<number>, volume: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type TradeVolumeIndexNode = TradeVolumeIndex
export declare class TradeVolumeIndex {
  constructor(minTick: number)
  update(close: number, volume: number): number | null
  batch(close: Array<number>, volume: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type IntradayIntensityNode = IntradayIntensity
export declare class IntradayIntensity {
  constructor()
  update(high: number, low: number, close: number, volume: number): number | null
  batch(high: Array<number>, low: Array<number>, close: Array<number>, volume: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type BetterVolumeNode = BetterVolume
export declare class BetterVolume {
  constructor(period: number)
  update(high: number, low: number, close: number, volume: number): number | null
  batch(high: Array<number>, low: Array<number>, close: Array<number>, volume: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}
export type VolumeWeightedMacdNode = VolumeWeightedMacd
export declare class VolumeWeightedMacd {
  constructor(fast: number, slow: number, signal: number)
  update(close: number, volume: number): VolumeWeightedMacdValue | null
  /**
   * Returns `[macd0, signal0, histogram0, macd1, ...]`, length `3 * n`.
   * Warmup positions are `NaN`.
   */
  batch(close: Array<number>, volume: Array<number>): Array<number>
  reset(): void
  isReady(): boolean
  warmupPeriod(): number
}