pinets 0.3.0 → 0.5.0

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

@@ -0,0 +1,18 @@
+/**
+ * ALMA - Arnaud Legoux Moving Average
+ *
+ * ALMA uses a Gaussian distribution to weight the moving average,
+ * reducing lag while maintaining smoothness.
+ *
+ * @param source - The data source (typically close price)
+ * @param period - The number of periods (window size)
+ * @param offset - Position of Gaussian peak (0-1, default 0.85). Higher = more responsive
+ * @param sigma - Width of Gaussian curve (default 6). Higher = smoother
+ *
+ * Formula:
+ * - m = offset * (period - 1)
+ * - s = period / sigma
+ * - weight[i] = exp(-((i - m)^2) / (2 * s^2))
+ * - ALMA = sum(weight[i] * price[i]) / sum(weight[i])
+ */
+export declare function alma(context: any): (source: any, _period: any, _offset: any, _sigma: any, _callId?: string) => any;

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

@@ -0,0 +1,6 @@
+/**
+ * Bars Since
+ *
+ * Counts the number of bars since the last time the condition was true.
+ */
+export declare function barssince(context: any): (condition: any, _callId?: string) => number;

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

@@ -0,0 +1,17 @@
+/**
+ * Bollinger Bands (BB)
+ *
+ * Bollinger Bands are volatility bands placed above and below a moving average.
+ * Volatility is based on the standard deviation, which changes as volatility increases and decreases.
+ *
+ * Formula:
+ * - Middle Band = SMA(source, length)
+ * - Upper Band = Middle Band + (multiplier × Standard Deviation)
+ * - Lower Band = Middle Band - (multiplier × Standard Deviation)
+ *
+ * @param source - The data source (typically close price)
+ * @param length - The period for SMA and standard deviation (default 20)
+ * @param mult - The multiplier for standard deviation (default 2)
+ * @returns [upper, middle, lower]
+ */
+export declare function bb(context: any): (source: any, _length: any, _mult: any, _callId?: string) => any[][];

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

@@ -0,0 +1,9 @@
+/**
+ * Bollinger Bands Width (BBW)
+ *
+ * Formula:
+ * basis = ta.sma(source, length)
+ * dev = mult * ta.stdev(source, length)
+ * bbw = (((basis + dev) - (basis - dev)) / basis) * 100
+ */
+export declare function bbw(context: any): (source: any, _length: any, _mult: any, _callId?: string) => any;

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

@@ -0,0 +1,20 @@
+/**
+ * Commodity Channel Index (CCI)
+ *
+ * CCI measures the deviation of the price from its average price.
+ * It's used to identify cyclical trends and overbought/oversold conditions.
+ *
+ * Formula:
+ * - Typical Price (TP) = (high + low + close) / 3
+ * - CCI = (TP - SMA(TP, length)) / (0.015 × Mean Deviation)
+ * - Mean Deviation = Average of |TP - SMA(TP)| over length periods
+ *
+ * @param source - Source series (typically close price, but can be any price)
+ * @param length - Number of bars back (lookback period)
+ * @returns CCI value
+ *
+ * @remarks
+ * - Returns NaN during initialization period (when not enough data)
+ * - The constant 0.015 ensures approximately 70-80% of values fall between -100 and +100
+ */
+export declare function cci(context: any): (source: any, _length: any, _callId?: string) => any;

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

@@ -0,0 +1,17 @@
+/**
+ * Chande Momentum Oscillator (CMO)
+ *
+ * Calculates the difference between the sum of recent gains and the sum of recent losses
+ * and then divides the result by the sum of all price movement over the same period.
+ *
+ * Pine Script Formula:
+ * mom = change(src)
+ * sm1 = sum((mom >= 0) ? mom : 0.0, length)
+ * sm2 = sum((mom >= 0) ? 0.0 : -mom, length)
+ * cmo = 100 * (sm1 - sm2) / (sm1 + sm2)
+ *
+ * @param source - Source series (typically close)
+ * @param length - Number of bars (lookback period)
+ * @returns CMO value (-100 to +100)
+ */
+export declare function cmo(context: any): (source: any, _length: any, _callId?: string) => any;

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

@@ -0,0 +1,18 @@
+/**
+ * Center of Gravity (COG)
+ *
+ * The cog (center of gravity) is an indicator based on statistics and the Fibonacci golden ratio.
+ *
+ * Pine Script Formula:
+ * sum = sum(source, length)
+ * num = 0.0
+ * for i = 0 to length - 1
+ *     price = source[i]
+ *     num = num + price * (i + 1)
+ * cog = -num / sum
+ *
+ * @param source - Source series (typically close)
+ * @param length - Number of bars (lookback period)
+ * @returns Center of Gravity value
+ */
+export declare function cog(context: any): (source: any, _length: any, _callId?: string) => any;

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

@@ -0,0 +1,7 @@
+/**
+ * Correlation Coefficient
+ *
+ * Describes the degree to which two series tend to deviate from their ta.sma() values.
+ * r = cov(X, Y) / (stdev(X) * stdev(Y))
+ */
+export declare function correlation(context: any): (source1: any, source2: any, _length: any, _callId?: string) => any;

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

@@ -0,0 +1,15 @@
+/**
+ * Cross Detection
+ *
+ * Detects when two series cross each other (either direction).
+ * Returns true if series1 crosses series2 (either above or below).
+ *
+ * Formula:
+ * cross = (source1[0] > source2[0] && source1[1] <= source2[1]) ||
+ *         (source1[0] < source2[0] && source1[1] >= source2[1])
+ *
+ * @param source1 - First data series
+ * @param source2 - Second data series
+ * @returns true if the series have crossed, false otherwise
+ */
+export declare function cross(context: any): (source1: any, source2: any, _callId?: string) => boolean;

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 @@
+export declare function tr(context: any): (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;