gavindiaz/wickra
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
fd9f4c8bc633a4284bf77fcaa0efa6cf33874473
wickra/bindings/node/index.d.ts
T
kingchenc fd9f4c8bc6 feat(bindings): expose name() on every indicator in all 10 languages (#308) 
* feat(bindings): expose name() on every indicator in Node, WASM, and Python

Surface the core Indicator::name() / BarBuilder::name() accessor through the
three native bindings so every indicator reports its canonical name at runtime,
matching the existing reset/isReady/warmupPeriod surface.

- Node (napi): name(): string on all 514 classes (regenerated index.d.ts)
- WASM (wasm-bindgen): name(): string on all 514 classes
- Python (pyo3): name() -> str on all classes

* feat(bindings): expose name() across the C ABI and C/C++/Go/C#/Java/R

Regenerate the C ABI and the four generated language bindings from the updated
ScriptHelpers generators so every indicator and bar builder reports its
canonical name at runtime, completing name() coverage across all 10 languages.

- C ABI (bindings/c): wickra_<ind>_name() -> *const c_char for all 514, cached
  in a per-function OnceLock<CString> with ind.name() as the source of truth;
  cbindgen header regenerated and vendored into bindings/go/include.
- Go: Name() string; C#: string Name(); Java: String name(); R: name() S3
  generic over the wk_<ind>_name C glue (methods.R + NAMESPACE).

The Java regeneration also restores two fixes that had drifted out of the
generator (bool* arrays via boolSegment; uint8_t ctor args cast to byte) and C#
re-emits '#nullable enable'; these are no-op vs the previous committed output
apart from the new name() accessors.

* test(golden): pin canonical name() across all 10 language bindings

Add a cross-language name() consistency check: every indicator must report the
exact core Indicator::name() (which can differ from the registered class name,
e.g. ChaikinMoneyFlow -> "CMF", Donchian -> "DonchianChannels"). The 514 core
names are committed as testdata/golden/names.json (keyed by Rust canonical) and
asserted by each binding's golden replay, which already reconstructs the whole
catalogue:

- node / wasm: assert against names.json in the existing golden test
- python: new test_golden_names.py over the shared node manifest
- go / csharp / java / c+c++ / r: the golden-test generators load names.json and
  emit a name assertion per indicator (regenerated test artifacts committed)

All 10 bindings return identical names by construction (each delegates to core),
so this pins that contract and guards against a future binding breaking the
passthrough.

* docs(changelog): record name() across all 10 bindings under Unreleased

* fix(r): restore bool* flag marshalling in the regenerated C glue

The name() regeneration had reverted the cross-section bool fix: the R glue
emitted (bool *)REAL(x) for const bool* inputs, reinterpreting 8-byte doubles as
1-byte bools so every flag read as false (PercentAboveMa, NewHighsNewLows,
HighLowIndex, BullishPercentIndex returned 0 instead of the breadth value). The
wk_bool_vec() helper is restored in the generator and the glue routes bool arrays
through it again.
2026-06-15 17:19:24 +02:00

5933 lines
187 KiB
TypeScript
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
/* 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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
isReady(): boolean
warmupPeriod(): number
}
export type CciNode = CCI
export declare class CCI {
constructor(period: number)
reset(): void
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
isReady(): boolean
warmupPeriod(): number
}
export type KamaNode = KAMA
export declare class KAMA {
constructor(erPeriod: number, fast: number, slow: number)
reset(): void
name(): string
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
name(): string
isReady(): boolean
warmupPeriod(): number
}
export type AlligatorNode = Alligator
export declare class Alligator {
constructor(jaw: number, teeth: number, lips: number)
reset(): void
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
isReady(): boolean
warmupPeriod(): number
}
export type AdOscillatorNode = ADOSC
export declare class ADOSC {
constructor()
update(high: number, low: number, close: number): number | null
batch(high: Array<number>, low: Array<number>, close: Array<number>): Array<number>
reset(): void
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
isReady(): boolean
warmupPeriod(): number
}
export type ValueAreaNode = ValueArea
export declare class ValueArea {
constructor(period: number, binCount: number, valueAreaPct: number)
reset(): void
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
isReady(): boolean
warmupPeriod(): number
}
export type VolumeProfileNode = VolumeProfile
export declare class VolumeProfile {
constructor(period: number, binCount: number)
reset(): void
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
}
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
name(): string
}
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
name(): string
}
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
name(): string
}
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
name(): string
}
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
name(): string
}
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
name(): string
}
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
name(): string
}
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
name(): string
}
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
name(): string
}
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
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
name(): string
isReady(): boolean
warmupPeriod(): number
}
Reference in New Issue View Git Blame Copy Permalink