pinets 0.3.0 → 0.6.1

package/dist/types/namespaces/ta/methods/cum.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Cumulative Sum (CUM)
+ *
+ * Returns the cumulative sum of the source values from the first bar to the current bar.
+ * The cumulative sum is the running total of all values.
+ *
+ * Formula:
+ * - CUM[0] = source[0]
+ * - CUM[n] = CUM[n-1] + source[n]
+ *
+ * @param source - The data source to accumulate
+ * @returns The cumulative sum up to the current bar
+ */
+export declare function cum(context: any): (source: any, _callId?: string) => any;

package/dist/types/namespaces/ta/methods/dmi.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Directional Movement Index (DMI)
+ *
+ * The DMI function returns the directional movement index.
+ *
+ * Formula:
+ * up = high - high[1]
+ * down = low[1] - low
+ * plusDM = (up > down && up > 0) ? up : 0
+ * minusDM = (down > up && down > 0) ? down : 0
+ * tr = ta.tr
+ * tru = rma(tr, diLength)
+ * plus = rma(plusDM, diLength)
+ * minus = rma(minusDM, diLength)
+ * plusDI = 100 * plus / tru
+ * minusDI = 100 * minus / tru
+ * dx = 100 * abs(plusDI - minusDI) / (plusDI + minusDI)
+ * adx = rma(dx, adxSmoothing)
+ *
+ * @param diLength - DI Period
+ * @param adxSmoothing - ADX Smoothing Period
+ * @returns Tuple of three DMI series: [+DI, -DI, ADX]
+ */
+export declare function dmi(context: any): (_diLength: any, _adxSmoothing: any, _callId?: string) => any[][];

package/dist/types/namespaces/ta/methods/falling.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Falling Detection
+ *
+ * Tests if the source series is now falling for length bars long.
+ * Returns true if the series has been consecutively falling for length bars.
+ *
+ * Formula:
+ * For length=2: source[0] < source[1] AND source[1] < source[2]
+ * For length=n: source[i] < source[i+1] for all i from 0 to n-1
+ *
+ * @param source - Series of values to process
+ * @param length - Number of bars to check (lookback period)
+ * @returns true if consecutively falling for length bars, false otherwise
+ */
+export declare function falling(context: any): (source: any, _length: any, _callId?: string) => boolean;

package/dist/types/namespaces/ta/methods/highestbars.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Highest Bars
+ *
+ * Returns the offset to the highest value over a given length.
+ * Formula: Offset to the highest bar (negative value).
+ */
+export declare function highestbars(context: any): (source: any, _length: any, _callId?: string) => number;

package/dist/types/namespaces/ta/methods/iii.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Intraday Intensity Index (III)
+ *
+ * Formula:
+ * (2 * close - high - low) / ((high - low) * volume)
+ */
+export declare function iii(context: any): (_callId?: string) => any;

package/dist/types/namespaces/ta/methods/kc.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Keltner Channels (KC)
+ *
+ * Formula:
+ * basis = ta.ema(src, length)
+ * span = useTrueRange ? ta.tr : (high - low)
+ * rangeEma = ta.ema(span, length)
+ * upper = basis + rangeEma * mult
+ * lower = basis - rangeEma * mult
+ * Returns [basis, upper, lower]
+ */
+export declare function kc(context: any): (source: any, _length: any, _mult: any, _useTrueRange?: any, _callId?: string) => any[][];

package/dist/types/namespaces/ta/methods/kcw.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Keltner Channels Width (KCW)
+ *
+ * Formula:
+ * basis = ta.ema(src, length)
+ * span = useTrueRange ? ta.tr : (high - low)
+ * rangeEma = ta.ema(span, length)
+ * kcw = ((basis + rangeEma * mult) - (basis - rangeEma * mult)) / basis
+ *     = (2 * rangeEma * mult) / basis
+ */
+export declare function kcw(context: any): (source: any, _length: any, _mult: any, _useTrueRange?: any, _callId?: string) => any;

package/dist/types/namespaces/ta/methods/lowestbars.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Lowest Bars
+ *
+ * Returns the offset to the lowest value over a given length.
+ * Formula: Offset to the lowest bar (negative value).
+ */
+export declare function lowestbars(context: any): (source: any, _length: any, _callId?: string) => number;

package/dist/types/namespaces/ta/methods/macd.d.ts

@@ -0,0 +1,18 @@
+/**
+ * MACD - Moving Average Convergence Divergence
+ *
+ * MACD is a trend-following momentum indicator that shows the relationship between
+ * two moving averages of a security's price.
+ *
+ * Formula:
+ * - MACD Line = EMA(source, fastLength) - EMA(source, slowLength)
+ * - Signal Line = EMA(MACD Line, signalLength)
+ * - Histogram = MACD Line - Signal Line
+ *
+ * @param source - The data source (typically close price)
+ * @param fastLength - The short period (default 12)
+ * @param slowLength - The long period (default 26)
+ * @param signalLength - The signal period (default 9)
+ * @returns [macdLine, signalLine, histLine]
+ */
+export declare function macd(context: any): (source: any, _fastLength: any, _slowLength: any, _signalLength: any, _callId?: string) => any[][];

package/dist/types/namespaces/ta/methods/mfi.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Money Flow Index (MFI)
+ *
+ * MFI is a momentum indicator that uses price and volume to identify overbought or oversold conditions.
+ *
+ * Pine Script Formula:
+ * upper = sum(volume * (change(src) <= 0 ? 0 : src), length)
+ * lower = sum(volume * (change(src) >= 0 ? 0 : src), length)
+ * mfi = 100.0 - (100.0 / (1.0 + upper / lower))
+ *
+ * @param source - Source series (typically hlc3)
+ * @param length - Number of bars back (lookback period)
+ * @returns MFI value (0-100)
+ */
+export declare function mfi(context: any): (source: any, _length: any, _callId?: string) => any;

package/dist/types/namespaces/ta/methods/mode.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Mode
+ *
+ * Returns the mode of the series. If there are several values with the same frequency, returns the smallest value.
+ */
+export declare function mode(context: any): (source: any, _length: any, _callId?: string) => number;

package/dist/types/namespaces/ta/methods/nvi.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Negative Volume Index (NVI)
+ *
+ * Formula:
+ * If close or close[1] is 0, nvi = nvi[1]
+ * Else if volume < volume[1], nvi = nvi[1] + ((close - close[1]) / close[1]) * nvi[1]
+ * Else nvi = nvi[1]
+ * Initial value is 1.0
+ */
+export declare function nvi(context: any): (_callId?: string) => any;

package/dist/types/namespaces/ta/methods/obv.d.ts

@@ -0,0 +1,12 @@
+/**
+ * On-Balance Volume (OBV)
+ * Cumulative indicator that adds volume on up days and subtracts on down days
+ *
+ * Logic:
+ * - If close > close[1]: OBV = OBV[1] + volume
+ * - If close < close[1]: OBV = OBV[1] - volume
+ * - If close == close[1]: OBV = OBV[1]
+ *
+ * Note: OBV starts at 0 on the first bar (when there's no previous close to compare)
+ */
+export declare function obv(context: any): () => any;

package/dist/types/namespaces/ta/methods/percentile_linear_interpolation.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Percentile Linear Interpolation
+ *
+ * Calculates percentile using method of linear interpolation between the two nearest ranks.
+ */
+export declare function percentile_linear_interpolation(context: any): (source: any, _length: any, _percentage: any, _callId?: string) => any;

package/dist/types/namespaces/ta/methods/percentile_nearest_rank.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Percentile Nearest Rank
+ *
+ * Calculates percentile using method of Nearest Rank.
+ * A percentile calculated using the Nearest Rank method will always be a member of the input data set.
+ */
+export declare function percentile_nearest_rank(context: any): (source: any, _length: any, _percentage: any, _callId?: string) => any;

package/dist/types/namespaces/ta/methods/percentrank.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Percent Rank
+ *
+ * Returns the percentage of values in the last length previous bars that are less than or equal to the current value.
+ */
+export declare function percentrank(context: any): (source: any, _length: any, _callId?: string) => any;

package/dist/types/namespaces/ta/methods/pvi.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Positive Volume Index (PVI)
+ *
+ * Formula:
+ * If close or close[1] is 0, pvi = pvi[1]
+ * Else if volume > volume[1], pvi = pvi[1] + ((close - close[1]) / close[1]) * pvi[1]
+ * Else pvi = pvi[1]
+ * Initial value is 1.0
+ */
+export declare function pvi(context: any): (_callId?: string) => any;

package/dist/types/namespaces/ta/methods/pvt.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Price-Volume Trend (PVT)
+ *
+ * The PVT function calculates the Price-Volume Trend, which is a cumulative
+ * total of volume adjusted by the percentage change in price.
+ *
+ * Formula:
+ * PVT = Previous PVT + ((Current Close - Previous Close) / Previous Close) * Volume
+ *
+ * @returns The PVT series
+ */
+export declare function pvt(context: any): (_callId?: string) => any;

package/dist/types/namespaces/ta/methods/range.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Range
+ *
+ * Returns the difference between the highest and lowest values of a series over a given length.
+ * Formula: ta.highest(source, length) - ta.lowest(source, length)
+ */
+export declare function range(context: any): (source: any, _length: any, _callId?: string) => any;

package/dist/types/namespaces/ta/methods/rising.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Rising Detection
+ *
+ * Tests if the source series is now rising for length bars long.
+ * Returns true if the series has been consecutively rising for length bars.
+ *
+ * Formula:
+ * For length=2: source[0] > source[1] AND source[1] > source[2]
+ * For length=n: source[i] > source[i+1] for all i from 0 to n-1
+ *
+ * @param source - Series of values to process
+ * @param length - Number of bars to check (lookback period)
+ * @returns true if consecutively rising for length bars, false otherwise
+ */
+export declare function rising(context: any): (source: any, _length: any, _callId?: string) => boolean;

package/dist/types/namespaces/ta/methods/sar.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Parabolic SAR (Stop and Reverse)
+ *
+ * Parabolic SAR is a method devised by J. Welles Wilder, Jr., to find potential reversals
+ * in the market price direction.
+ *
+ * @param start - Start acceleration factor
+ * @param inc - Increment acceleration factor
+ * @param max - Maximum acceleration factor
+ * @returns Parabolic SAR value
+ */
+export declare function sar(context: any): (_start: any, _inc: any, _max: any, _callId?: string) => any;

package/dist/types/namespaces/ta/methods/stoch.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Stochastic Oscillator (STOCH)
+ *
+ * The Stochastic Oscillator is a momentum indicator that shows the location of the close
+ * relative to the high-low range over a set number of periods.
+ *
+ * Formula:
+ * STOCH = 100 * (close - lowest(low, length)) / (highest(high, length) - lowest(low, length))
+ *
+ * @param source - Source series (typically close price)
+ * @param high - Series of high prices
+ * @param low - Series of low prices
+ * @param length - Number of bars back (lookback period)
+ * @returns Stochastic value (0-100)
+ *
+ * @remarks
+ * - NaN values in the source series are ignored
+ * - Returns NaN during initialization period (when not enough data)
+ * - Returns NaN if highest equals lowest (to avoid division by zero)
+ */
+export declare function stoch(context: any): (source: any, high: any, low: any, _length: any, _callId?: string) => any;

package/dist/types/namespaces/ta/methods/supertrend.d.ts

@@ -1 +1,24 @@
+/**
+ * SuperTrend Indicator
+ *
+ * The Supertrend is a trend following indicator based on ATR.
+ *
+ * Pine Script Formula:
+ * src = hl2
+ * atr = ta.atr(atrPeriod)
+ * upperBand = src + factor * atr
+ * lowerBand = src - factor * atr
+ * prevLowerBand = nz(lowerBand[1])
+ * prevUpperBand = nz(upperBand[1])
+ *
+ * lowerBand := lowerBand > prevLowerBand or close[1] < prevLowerBand ? lowerBand : prevLowerBand
+ * upperBand := upperBand < prevUpperBand or close[1] > prevUpperBand ? upperBand : prevUpperBand
+ *
+ * direction: 1 (down/bearish), -1 (up/bullish)
+ * superTrend := direction == -1 ? lowerBand : upperBand
+ *
+ * @param factor - The multiplier by which the ATR will get multiplied
+ * @param atrPeriod - Length of ATR
+ * @returns Tuple [supertrend, direction] where direction is 1 (down) or -1 (up)
+ */
 export declare function supertrend(context: any): (_factor: any, _atrPeriod: any, _callId?: string) => any[][];

package/dist/types/namespaces/ta/methods/swma.d.ts

@@ -0,0 +1,14 @@
+/**
+ * SWMA - Symmetrically Weighted Moving Average
+ *
+ * Pine Script's ta.swma() uses a fixed period of 4 bars with symmetric weights.
+ * The weights are applied symmetrically: the current and 3 previous bars.
+ *
+ * Weights for 4-bar period: [1, 2, 2, 1]
+ * Formula: SWMA = (price[3]*1 + price[2]*2 + price[1]*2 + price[0]*1) / 6
+ *
+ * @param source - The data source (typically close price)
+ *
+ * Note: Unlike other moving averages, SWMA has a fixed period of 4 in Pine Script
+ */
+export declare function swma(context: any): (source: any, _callId?: string) => any;

package/dist/types/namespaces/ta/methods/tr.d.ts

@@ -0,0 +1,2 @@
+import { Context } from '../../../Context.class';
+export declare function tr(context: Context): (handle_na?: boolean, _callId?: string) => number;

package/dist/types/namespaces/ta/methods/tsi.d.ts

@@ -0,0 +1,17 @@
+/**
+ * True Strength Index (TSI)
+ *
+ * True strength index uses moving averages of the underlying momentum of a financial instrument.
+ *
+ * Formula:
+ * pc = change(source)                    // Price change
+ * double_smoothed_pc = ema(ema(pc, long_length), short_length)
+ * double_smoothed_abs_pc = ema(ema(abs(pc), long_length), short_length)
+ * tsi = double_smoothed_pc / double_smoothed_abs_pc
+ *
+ * @param source - Source series (typically close)
+ * @param shortLength - Short EMA length
+ * @param longLength - Long EMA length
+ * @returns TSI value in range [-1, 1]
+ */
+export declare function tsi(context: any): (source: any, _shortLength: any, _longLength: any, _callId?: string) => any;

package/dist/types/namespaces/ta/methods/valuewhen.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Value When
+ *
+ * Returns the value of the source series on the bar where the condition was true on the nth most recent occurrence.
+ */
+export declare function valuewhen(context: any): (condition: any, source: any, _occurrence: any, _callId?: string) => any;

package/dist/types/namespaces/ta/methods/vwap.d.ts

@@ -0,0 +1,14 @@
+/**
+ * VWAP - Volume Weighted Average Price
+ *
+ * VWAP calculates the average price weighted by volume for a trading session.
+ * It resets at the start of each new session (typically daily).
+ *
+ * Formula: VWAP = Σ(Price × Volume) / Σ(Volume)
+ *
+ * @param source - The price source (typically close, hlc3, or ohlc4)
+ *
+ * Note: This implementation resets VWAP at the start of each trading session
+ * based on detecting new trading days (when openTime changes to a new day).
+ */
+export declare function vwap(context: any): (source: any, _callId?: string) => any;

package/dist/types/namespaces/ta/methods/wad.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Williams Accumulation/Distribution (WAD)
+ *
+ * Formula:
+ * trueHigh = math.max(high, close[1])
+ * trueLow = math.min(low, close[1])
+ * mom = ta.change(close)
+ * gain = (mom > 0) ? close - trueLow : (mom < 0) ? close - trueHigh : 0
+ * ta.cum(gain)
+ */
+export declare function wad(context: any): (_callId?: string) => any;

package/dist/types/namespaces/ta/methods/wpr.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Williams %R (WPR)
+ *
+ * The oscillator shows the current closing price in relation to the high and low
+ * of the past 'length' bars.
+ *
+ * Formula:
+ * %R = (Highest High - Close) / (Highest High - Lowest Low) * -100
+ *
+ * Note: Williams %R produces values between -100 and 0
+ * - Values near -100 indicate oversold conditions
+ * - Values near 0 indicate overbought conditions
+ *
+ * @param length - Number of bars (lookback period)
+ * @returns Williams %R value (-100 to 0)
+ */
+export declare function wpr(context: any): (_length: any, _callId?: string) => any;

package/dist/types/namespaces/ta/methods/wvad.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Williams Variable Accumulation/Distribution (WVAD)
+ *
+ * Formula:
+ * (close - open) / (high - low) * volume
+ */
+export declare function wvad(context: any): (_callId?: string) => any;

package/dist/types/namespaces/ta/ta.index.d.ts

@@ -1,84 +1,199 @@
-import { tr } from './getters/tr';
+import { accdist } from './methods/accdist';
+import { alma } from './methods/alma';
 import { atr } from './methods/atr';
+import { barssince } from './methods/barssince';
+import { bb } from './methods/bb';
+import { bbw } from './methods/bbw';
+import { cci } from './methods/cci';
 import { change } from './methods/change';
+import { cmo } from './methods/cmo';
+import { cog } from './methods/cog';
+import { correlation } from './methods/correlation';
+import { cross } from './methods/cross';
 import { crossover } from './methods/crossover';
 import { crossunder } from './methods/crossunder';
+import { cum } from './methods/cum';
 import { dev } from './methods/dev';
+import { dmi } from './methods/dmi';
 import { ema } from './methods/ema';
+import { falling } from './methods/falling';
 import { highest } from './methods/highest';
+import { highestbars } from './methods/highestbars';
 import { hma } from './methods/hma';
+import { iii } from './methods/iii';
+import { kc } from './methods/kc';
+import { kcw } from './methods/kcw';
 import { linreg } from './methods/linreg';
 import { lowest } from './methods/lowest';
+import { lowestbars } from './methods/lowestbars';
+import { macd } from './methods/macd';
 import { median } from './methods/median';
+import { mfi } from './methods/mfi';
+import { mode } from './methods/mode';
 import { mom } from './methods/mom';
+import { nvi } from './methods/nvi';
+import { obv } from './methods/obv';
 import { param } from './methods/param';
+import { percentile_linear_interpolation } from './methods/percentile_linear_interpolation';
+import { percentile_nearest_rank } from './methods/percentile_nearest_rank';
+import { percentrank } from './methods/percentrank';
 import { pivothigh } from './methods/pivothigh';
 import { pivotlow } from './methods/pivotlow';
+import { pvi } from './methods/pvi';
+import { pvt } from './methods/pvt';
+import { range } from './methods/range';
+import { rising } from './methods/rising';
 import { rma } from './methods/rma';
 import { roc } from './methods/roc';
 import { rsi } from './methods/rsi';
+import { sar } from './methods/sar';
 import { sma } from './methods/sma';
 import { stdev } from './methods/stdev';
+import { stoch } from './methods/stoch';
 import { supertrend } from './methods/supertrend';
+import { swma } from './methods/swma';
+import { tr } from './methods/tr';
+import { tsi } from './methods/tsi';
+import { valuewhen } from './methods/valuewhen';
 import { variance } from './methods/variance';
+import { vwap } from './methods/vwap';
 import { vwma } from './methods/vwma';
+import { wad } from './methods/wad';
 import { wma } from './methods/wma';
-declare const getters: {
-    tr: typeof tr;
-};
+import { wpr } from './methods/wpr';
+import { wvad } from './methods/wvad';
 declare const methods: {
+    accdist: typeof accdist;
+    alma: typeof alma;
     atr: typeof atr;
+    barssince: typeof barssince;
+    bb: typeof bb;
+    bbw: typeof bbw;
+    cci: typeof cci;
     change: typeof change;
+    cmo: typeof cmo;
+    cog: typeof cog;
+    correlation: typeof correlation;
+    cross: typeof cross;
     crossover: typeof crossover;
     crossunder: typeof crossunder;
+    cum: typeof cum;
     dev: typeof dev;
+    dmi: typeof dmi;
     ema: typeof ema;
+    falling: typeof falling;
     highest: typeof highest;
+    highestbars: typeof highestbars;
     hma: typeof hma;
+    iii: typeof iii;
+    kc: typeof kc;
+    kcw: typeof kcw;
     linreg: typeof linreg;
     lowest: typeof lowest;
+    lowestbars: typeof lowestbars;
+    macd: typeof macd;
     median: typeof median;
+    mfi: typeof mfi;
+    mode: typeof mode;
     mom: typeof mom;
+    nvi: typeof nvi;
+    obv: typeof obv;
     param: typeof param;
+    percentile_linear_interpolation: typeof percentile_linear_interpolation;
+    percentile_nearest_rank: typeof percentile_nearest_rank;
+    percentrank: typeof percentrank;
     pivothigh: typeof pivothigh;
     pivotlow: typeof pivotlow;
+    pvi: typeof pvi;
+    pvt: typeof pvt;
+    range: typeof range;
+    rising: typeof rising;
     rma: typeof rma;
     roc: typeof roc;
     rsi: typeof rsi;
+    sar: typeof sar;
     sma: typeof sma;
     stdev: typeof stdev;
+    stoch: typeof stoch;
     supertrend: typeof supertrend;
+    swma: typeof swma;
+    tr: typeof tr;
+    tsi: typeof tsi;
+    valuewhen: typeof valuewhen;
     variance: typeof variance;
+    vwap: typeof vwap;
     vwma: typeof vwma;
+    wad: typeof wad;
     wma: typeof wma;
+    wpr: typeof wpr;
+    wvad: typeof wvad;
 };
 export declare class TechnicalAnalysis {
     private context;
-    readonly tr: ReturnType<ReturnType<typeof getters.tr>>;
+    accdist: ReturnType<typeof methods.accdist>;
+    alma: ReturnType<typeof methods.alma>;
     atr: ReturnType<typeof methods.atr>;
+    barssince: ReturnType<typeof methods.barssince>;
+    bb: ReturnType<typeof methods.bb>;
+    bbw: ReturnType<typeof methods.bbw>;
+    cci: ReturnType<typeof methods.cci>;
     change: ReturnType<typeof methods.change>;
+    cmo: ReturnType<typeof methods.cmo>;
+    cog: ReturnType<typeof methods.cog>;
+    correlation: ReturnType<typeof methods.correlation>;
+    cross: ReturnType<typeof methods.cross>;
     crossover: ReturnType<typeof methods.crossover>;
     crossunder: ReturnType<typeof methods.crossunder>;
+    cum: ReturnType<typeof methods.cum>;
     dev: ReturnType<typeof methods.dev>;
+    dmi: ReturnType<typeof methods.dmi>;
     ema: ReturnType<typeof methods.ema>;
+    falling: ReturnType<typeof methods.falling>;
     highest: ReturnType<typeof methods.highest>;
+    highestbars: ReturnType<typeof methods.highestbars>;
     hma: ReturnType<typeof methods.hma>;
+    iii: ReturnType<typeof methods.iii>;
+    kc: ReturnType<typeof methods.kc>;
+    kcw: ReturnType<typeof methods.kcw>;
     linreg: ReturnType<typeof methods.linreg>;
     lowest: ReturnType<typeof methods.lowest>;
+    lowestbars: ReturnType<typeof methods.lowestbars>;
+    macd: ReturnType<typeof methods.macd>;
     median: ReturnType<typeof methods.median>;
+    mfi: ReturnType<typeof methods.mfi>;
+    mode: ReturnType<typeof methods.mode>;
     mom: ReturnType<typeof methods.mom>;
+    nvi: ReturnType<typeof methods.nvi>;
+    obv: ReturnType<typeof methods.obv>;
     param: ReturnType<typeof methods.param>;
+    percentile_linear_interpolation: ReturnType<typeof methods.percentile_linear_interpolation>;
+    percentile_nearest_rank: ReturnType<typeof methods.percentile_nearest_rank>;
+    percentrank: ReturnType<typeof methods.percentrank>;
     pivothigh: ReturnType<typeof methods.pivothigh>;
     pivotlow: ReturnType<typeof methods.pivotlow>;
+    pvi: ReturnType<typeof methods.pvi>;
+    pvt: ReturnType<typeof methods.pvt>;
+    range: ReturnType<typeof methods.range>;
+    rising: ReturnType<typeof methods.rising>;
     rma: ReturnType<typeof methods.rma>;
     roc: ReturnType<typeof methods.roc>;
     rsi: ReturnType<typeof methods.rsi>;
+    sar: ReturnType<typeof methods.sar>;
     sma: ReturnType<typeof methods.sma>;
     stdev: ReturnType<typeof methods.stdev>;
+    stoch: ReturnType<typeof methods.stoch>;
     supertrend: ReturnType<typeof methods.supertrend>;
+    swma: ReturnType<typeof methods.swma>;
+    tr: ReturnType<typeof methods.tr>;
+    tsi: ReturnType<typeof methods.tsi>;
+    valuewhen: ReturnType<typeof methods.valuewhen>;
     variance: ReturnType<typeof methods.variance>;
+    vwap: ReturnType<typeof methods.vwap>;
     vwma: ReturnType<typeof methods.vwma>;
+    wad: ReturnType<typeof methods.wad>;
     wma: ReturnType<typeof methods.wma>;
+    wpr: ReturnType<typeof methods.wpr>;
+    wvad: ReturnType<typeof methods.wvad>;
     constructor(context: any);
 }
 export default TechnicalAnalysis;

package/dist/types/transpiler/analysis/ScopeManager.d.ts

@@ -5,6 +5,7 @@ export declare class ScopeManager {
     private contextBoundVars;
     private arrayPatternElements;
     private rootParams;
+    private localSeriesVars;
     private varKinds;
     private loopVars;
     private loopVarNames;
@@ -12,6 +13,8 @@ export declare class ScopeManager {
     private cacheIdCounter;
     private tempVarCounter;
     private taCallIdCounter;
+    private hoistingStack;
+    private suppressHoisting;
     get nextParamIdArg(): any;
     get nextCacheIdArg(): any;
     getNextTACallId(): any;
@@ -20,6 +23,8 @@ export declare class ScopeManager {
     popScope(): void;
     getCurrentScopeType(): string;
     getCurrentScopeCount(): number;
+    addLocalSeriesVar(name: string): void;
+    isLocalSeriesVar(name: string): boolean;
     addContextBoundVar(name: string, isRootParam?: boolean): void;
     removeContextBoundVar(name: any): void;
     addArrayPatternElement(name: string): void;
@@ -32,5 +37,11 @@ export declare class ScopeManager {
     addVariable(name: string, kind: string): string;
     getVariable(name: string): [string, string];
     generateTempVar(): string;
+    enterHoistingScope(): void;
+    exitHoistingScope(): any[];
+    addHoistedStatement(stmt: any): void;
+    setSuppressHoisting(suppress: boolean): void;
+    shouldSuppressHoisting(): boolean;
+    generateParamId(): string;
 }
 export default ScopeManager;