oakscriptjs 0.8.1 → 0.9.0

package/dist/esm/ta/index.d.ts

@@ -0,0 +1,1397 @@
+/**
+ * Technical Analysis (ta) namespace
+ * Mirrors PineScript's ta.* functions for technical analysis indicators and calculations.
+ *
+ * @remarks
+ * All technical analysis functions in this namespace follow PineScript v6 API specifications.
+ *
+ * @version 6
+ */
+import type { series_float, series_bool, series_int, Source, simple_int, simple_float, simple_bool } from '../types/index.js';
+/**
+ * Simple Moving Average - returns the moving average (sum of last y values divided by y).
+ *
+ * @param source - Series of values to process
+ * @param length - Number of bars (length)
+ * @returns Simple moving average of source for length bars back
+ *
+ * @remarks
+ * - `na` values (also +/-Infinity) in the source series are ignored: the mean of the last `length` non-`na`
+ *   values, and a bar with an `na` source keeps the previous result (as in PineScript)
+ * - Returns NaN until `length` non-`na` values are available
+ * - The sum is a compensated running sum, as in PineScript, so the result can differ from the exact window mean in
+ *   the last bits (bit for bit with PineScript)
+ *
+ * @example
+ * ```typescript
+ * const closePrices = [10, 11, 12, 13, 14];
+ * const sma5 = ta.sma(closePrices, 5); // Returns: [NaN, NaN, NaN, NaN, 12]
+ * ```
+ */
+export declare function sma(source: Source, length: simple_int): series_float;
+/**
+ * Exponential Moving Average - returns the exponentially weighted moving average.
+ *
+ * @param source - Series of values to process
+ * @param length - Number of bars (length)
+ * @returns Exponential moving average of source with alpha = 2 / (length + 1)
+ *
+ * @remarks
+ * - In EMA, weighting factors decrease exponentially
+ * - Formula: `EMA = alpha * source + (1 - alpha) * EMA[1]`, where `alpha = 2 / (length + 1)`
+ * - `na` values (also +/-Infinity) in the source series are ignored
+ * - The function calculates on the `length` quantity of non-`na` values
+ * - May cause indicator repainting
+ *
+ * @example
+ * ```typescript
+ * const closePrices = [10, 11, 12, 13, 14];
+ * const ema5 = ta.ema(closePrices, 5);
+ * ```
+ */
+export declare function ema(source: Source, length: simple_int): series_float;
+/**
+ * Relative Strength Index - momentum oscillator measuring speed and magnitude of price changes.
+ *
+ * @param source - Series of values to process
+ * @param length - Number of bars (length)
+ * @returns RSI series (values range from 0 to 100)
+ *
+ * @remarks
+ * - RSI values above 70 typically indicate overbought conditions
+ * - RSI values below 30 typically indicate oversold conditions
+ * - Uses `ta.rma()` (Relative Moving Average) for smoothing, matching PineScript v6
+ * - Formula: RSI = 100 - (100 / (1 + RS)), where RS = Average Gain / Average Loss
+ * - Average Gain and Average Loss are calculated using RMA (alpha = 1 / length)
+ * - `na` values in the source series are ignored
+ *
+ * @example
+ * ```typescript
+ * const rsi14 = ta.rsi(closePrices, 14);
+ * // Identify overbought/oversold conditions
+ * const overbought = rsi14.map(v => v > 70);
+ * const oversold = rsi14.map(v => v < 30);
+ * ```
+ */
+export declare function rsi(source: Source, length: simple_int): series_float;
+/**
+ * Moving Average Convergence Divergence - trend-following momentum indicator showing relationship
+ * between two moving averages.
+ *
+ * @param source - Series of values to process
+ * @param fastLength - Fast EMA length (typically 12)
+ * @param slowLength - Slow EMA length (typically 26)
+ * @param signalLength - Signal line EMA length (typically 9)
+ * @returns Tuple of [macdLine, signalLine, histogram]
+ *
+ * @remarks
+ * - MACD Line = Fast EMA - Slow EMA
+ * - Signal Line = EMA of MACD Line
+ * - Histogram = MACD Line - Signal Line
+ * - Crossovers between MACD and signal line indicate potential buy/sell signals
+ *
+ * @example
+ * ```typescript
+ * const [macdLine, signal, histogram] = ta.macd(closePrices, 12, 26, 9);
+ * ```
+ */
+export declare function macd(source: Source, fastLength: simple_int, slowLength: simple_int, signalLength: simple_int): [series_float, series_float, series_float];
+/**
+ * Bollinger Bands - a technical analysis tool defined by lines plotted two standard deviations
+ * away from a simple moving average.
+ *
+ * @param series - Series of values to process
+ * @param length - Number of bars (length)
+ * @param mult - Standard deviation factor
+ * @returns Tuple of [middle, upper, lower] bands
+ *
+ * @remarks
+ * - Middle band is the SMA of the source
+ * - Upper band = middle + (mult * standard deviation)
+ * - Lower band = middle - (mult * standard deviation)
+ * - `na` values in the source series are ignored
+ *
+ * @example
+ * ```typescript
+ * const [middle, upper, lower] = ta.bb(closePrices, 20, 2);
+ * ```
+ */
+export declare function bb(series: Source, length: simple_int, mult: simple_float): [series_float, series_float, series_float];
+/**
+ * Standard deviation over the last `length` non-na values.
+ *
+ * @param source - Series of values to process
+ * @param length - Number of values
+ * @param biased - true (default): biased estimate (divides by `length`); false: unbiased (by `length - 1`)
+ * @returns Standard deviation series (na until `length` non-na values exist)
+ *
+ * @remarks
+ * As in PineScript: `na` values (also +/-Infinity) are skipped, the window holds the last
+ * `length` non-na values, and a bar whose own value is `na` keeps the previous result.
+ * The result is the square root of {@link variance} (0 when the variance is not positive), computed from
+ * compensated running sums of the values and of their squares, bit for bit as PineScript.
+ */
+export declare function stdev(source: Source, length: simple_int, biased?: simple_bool): series_float;
+/**
+ * Crossover - returns true when series1 crosses over series2 (moves from below to above).
+ *
+ * @param series1 - First series
+ * @param series2 - Second series
+ * @returns Boolean series (true at crossover points)
+ *
+ * @remarks
+ * - True when: series1[i]! > series2[i]! AND series1[i-1] <= series2[i-1]
+ * - First value is always false (no previous value to compare)
+ * - Useful for detecting bullish signals (e.g., fast MA crossing over slow MA)
+ *
+ * @example
+ * ```typescript
+ * const crossUp = ta.crossover(fastMA, slowMA);
+ * ```
+ */
+export declare function crossover(series1: Source, series2: Source): series_bool;
+/**
+ * Crossunder - returns true when series1 crosses under series2 (moves from above to below).
+ *
+ * @param series1 - First series
+ * @param series2 - Second series
+ * @returns Boolean series (true at crossunder points)
+ *
+ * @remarks
+ * - True when: series1[i]! < series2[i]! AND series1[i-1] >= series2[i-1]
+ * - First value is always false (no previous value to compare)
+ * - Useful for detecting bearish signals (e.g., fast MA crossing under slow MA)
+ *
+ * @example
+ * ```typescript
+ * const crossDown = ta.crossunder(fastMA, slowMA);
+ * ```
+ */
+export declare function crossunder(series1: Source, series2: Source): series_bool;
+/**
+ * Change - calculates the difference between the current value and its value length bars ago.
+ *
+ * @param source - Series of values to process
+ * @param length - Number of bars back (default: 1)
+ * @returns Change series (source[i]! - source[i - length])
+ *
+ * @remarks
+ * - Returns NaN for the first `length` values
+ * - Default length is 1 (difference from previous bar)
+ * - Positive values indicate increase, negative values indicate decrease
+ *
+ * @example
+ * ```typescript
+ * const change1 = ta.change(closePrices); // Daily change
+ * const change5 = ta.change(closePrices, 5); // 5-day change
+ * ```
+ */
+export declare function change(source: Source, length?: simple_int): series_float;
+/**
+ * True Range - measures market volatility by calculating the greatest of three price ranges.
+ *
+ * @param handle_na - Defines how the function calculates when previous close is na (default: false)
+ * @param high - High price series (required when not using context API)
+ * @param low - Low price series (required when not using context API)
+ * @param close - Close price series (required when not using context API)
+ * @returns True range series
+ *
+ * @remarks
+ * - **PineScript v6 signature**: `ta.tr(handle_na?)` - uses implicit chart data
+ * - **JavaScript signature**: Requires explicit `high`, `low`, `close` OR use `createContext()`
+ * - True Range = max(high - low, abs(high - close[1]), abs(low - close[1]))
+ * - When `handle_na` is true: returns `high - low` if previous close is na
+ * - When `handle_na` is false: returns na if previous close is na
+ * - Used as a component in ATR calculations
+ *
+ * @example
+ * ```typescript
+ * // Direct call with explicit data
+ * const trueRange = ta.tr(false, high, low, close);
+ *
+ * // Or use context API for cleaner syntax
+ * const { ta } = createContext({ chart: { high, low, close } });
+ * const trueRange = ta.tr(); // Matches PineScript!
+ * ```
+ */
+export declare function tr(handle_na?: simple_bool, high?: Source, low?: Source, close?: Source): series_float;
+/**
+ * Average True Range - returns the RMA (Relative Moving Average) of true range.
+ *
+ * @param length - Number of bars (length)
+ * @param high - High price series (required when not using context API)
+ * @param low - Low price series (required when not using context API)
+ * @param close - Close price series (required when not using context API)
+ * @returns Average true range series
+ *
+ * @remarks
+ * - **PineScript v6 signature**: `ta.atr(length)` - uses implicit chart data
+ * - **JavaScript signature**: Requires explicit `high`, `low`, `close` OR use `createContext()`
+ * - Uses `ta.rma()` (Relative Moving Average) for smoothing, matching PineScript v6
+ * - True range is max(high - low, abs(high - close[1]), abs(low - close[1]))
+ * - ATR is a measure of volatility, higher values indicate greater volatility
+ * - `na` values in the source series are ignored
+ * - The function calculates on the `length` quantity of non-`na` values
+ *
+ * @example
+ * ```typescript
+ * // Direct call with explicit data
+ * const atr14 = ta.atr(14, high, low, close);
+ *
+ * // Or use context API for cleaner syntax
+ * const { ta } = createContext({ chart: { high, low, close } });
+ * const atr14 = ta.atr(14); // Matches PineScript!
+ * ```
+ */
+export declare function atr(length: simple_int, high?: Source, low?: Source, close?: Source): series_float;
+/**
+ * SuperTrend Indicator - a trend-following indicator that helps identify trend direction.
+ *
+ * @param factor - The multiplier by which the ATR will get multiplied (series int/float)
+ * @param atrPeriod - Length of ATR (simple int)
+ * @param high - High price series (required when not using context API)
+ * @param low - Low price series (required when not using context API)
+ * @param close - Close price series (required when not using context API)
+ * @param wicks - Whether to use wicks for trend reversal (NOT in PineScript v6 API, default: false)
+ * @returns Tuple of [supertrend, direction] where direction is 1 (downtrend) or -1 (uptrend)
+ *
+ * @remarks
+ * - **PineScript v6 signature**: `ta.supertrend(factor, atrPeriod)` - uses implicit chart data
+ * - **JavaScript signature**: Requires explicit `high`, `low`, `close` OR use `createContext()`
+ * - The `wicks` parameter is NOT part of the official PineScript v6 API
+ * - Direction: 1 = downtrend (red), -1 = uptrend (green)
+ * - Uses hl2 (average of high and low) as the source
+ * - SuperTrend helps identify the current market trend and potential reversal points
+ *
+ * @example
+ * ```typescript
+ * // Direct call with explicit data
+ * const [supertrend, direction] = ta.supertrend(3, 10, high, low, close);
+ * // Plot uptrend when direction < 0
+ * // Plot downtrend when direction > 0
+ *
+ * // Or use context API for cleaner syntax
+ * const { ta } = createContext({ chart: { high, low, close } });
+ * const [supertrend, direction] = ta.supertrend(3, 10); // Matches PineScript!
+ * ```
+ */
+export declare function supertrend(factor: simple_float, atrPeriod: simple_int, high?: Source, low?: Source, close?: Source, wicks?: simple_bool): [series_float, series_int];
+/**
+ * Relative Moving Average (RMA) - exponentially weighted moving average with alpha = 1 / length.
+ *
+ * @param source - Series of values to process
+ * @param length - Number of bars (length)
+ * @returns RMA of source for length bars back
+ *
+ * @remarks
+ * - Moving average used in RSI calculation
+ * - Alpha = 1 / length (different from EMA which uses alpha = 2 / (length + 1))
+ * - First value is initialized with SMA, then uses exponential smoothing
+ * - Formula: `RMA = (source + (length - 1) * RMA[1]) / length`, evaluated in this order as in PineScript
+ *   (equal to `alpha * source + (1 - alpha) * RMA[1]`, but bit for bit)
+ * - `na` values (also +/-Infinity) in the source series are ignored
+ * - The function calculates on the `length` quantity of non-`na` values
+ *
+ * @example
+ * ```typescript
+ * const rma14 = ta.rma(closePrices, 14);
+ * // Used internally by RSI:
+ * // avgGain = ta.rma(gains, 14);
+ * // avgLoss = ta.rma(losses, 14);
+ * ```
+ */
+export declare function rma(source: Source, length: simple_int): series_float;
+/**
+ * Weighted Moving Average (WMA) - moving average with linearly decreasing weights.
+ *
+ * @param source - Series of values to process
+ * @param length - Number of bars (length)
+ * @returns WMA of source for length bars back
+ *
+ * @remarks
+ * - Weighting factors decrease in arithmetical progression
+ * - Most recent value has weight `length`, previous has `length-1`, etc.
+ * - Formula: `sum(source[i]! * (length - i)) / sum(length - i)` for i = 0 to length-1
+ * - As in PineScript: na on a bar whose source is `na` (also +/-Infinity) and until `length` non-`na` values were
+ *   received; an `na` value inside the window is replaced by the previous non-`na` value
+ * - More responsive to recent price changes than SMA
+ *
+ * @example
+ * ```typescript
+ * const wma20 = ta.wma(closePrices, 20);
+ * // WMA gives more weight to recent prices
+ * ```
+ */
+export declare function wma(source: Source, length: simple_int): series_float;
+/**
+ * Highest value over the last `length` bars.
+ *
+ * @param source - Series of values to process
+ * @param length - Number of bars
+ * @returns Highest value series (na on the first `length - 1` bars)
+ *
+ * @remarks
+ * As in PineScript: an `na` value ends the window, so only the values after the last `na`
+ * count, and a bar whose own value is `na` gives `na`.
+ * PineScript `ta.highest(length)` (source = high) is `ta.highest(length)` in the script API.
+ */
+export declare function highest(source: Source, length: simple_int): series_float;
+/**
+ * Lowest value over the last `length` bars.
+ *
+ * @param source - Series of values to process
+ * @param length - Number of bars
+ * @returns Lowest value series (na on the first `length - 1` bars)
+ *
+ * @remarks
+ * As in PineScript: an `na` value ends the window, so only the values after the last `na`
+ * count, and a bar whose own value is `na` gives `na`.
+ */
+export declare function lowest(source: Source, length: simple_int): series_float;
+/**
+ * Cumulative Sum - returns the total sum of all elements from the beginning.
+ *
+ * @param source - Series of values to process
+ * @returns Series containing the cumulative sum at each bar
+ *
+ * @remarks
+ * - Returns the running total of all values from index 0 to current index
+ * - As in PineScript: an `na` value adds nothing to the sum,
+ *   and the result is `na` on that bar only; the sum continues on the next bars
+ * - Useful for calculating total volume, total trades, etc.
+ *
+ * @example
+ * ```typescript
+ * const cumulativeVolume = ta.cum(volume);
+ * const totalGains = ta.cum(gains);
+ * ```
+ */
+export declare function cum(source: Source): series_float;
+/**
+ * Cross - returns true when two series cross each other (either direction).
+ *
+ * @param source1 - First series
+ * @param source2 - Second series
+ * @returns Boolean series (true at cross points)
+ *
+ * @remarks
+ * - True when: (source1[i]! > source2[i]! AND source1[i-1] <= source2[i-1]) OR
+ *              (source1[i]! < source2[i]! AND source1[i-1] >= source2[i-1])
+ * - First value is always false (no previous value to compare)
+ * - Detects any crossing (either over or under)
+ * - Use `ta.crossover()` or `ta.crossunder()` for directional crosses
+ *
+ * @example
+ * ```typescript
+ * const crossed = ta.cross(fastMA, slowMA);
+ * // Detect any MA crossover
+ * ```
+ */
+export declare function cross(source1: Source, source2: Source): series_bool;
+/**
+ * Rising - returns true if source is rising for length bars.
+ *
+ * @param source - Series of values to process
+ * @param length - Number of bars (length)
+ * @returns Boolean series (true when rising)
+ *
+ * @remarks
+ * PineScript rules:
+ * - each of the `length` steps is a rise larger than the 1e-10 tolerance
+ * - `na` values are skipped: the steps are between the last `length + 1` non-`na` values up to the current bar
+ *   (on an `na` bar, the result of the last non-`na` bar)
+ * - false while there are fewer than `length + 1` non-`na` values
+ *
+ * @example
+ * ```typescript
+ * const isRising = ta.rising(close, 3);
+ * // Detect upward momentum
+ * ```
+ */
+export declare function rising(source: Source, length: simple_int): series_bool;
+/**
+ * Falling - returns true if source is falling for length bars.
+ *
+ * @param source - Series of values to process
+ * @param length - Number of bars (length)
+ * @returns Boolean series (true when falling)
+ *
+ * @remarks
+ * PineScript rules:
+ * - each of the `length` steps is a fall larger than the 1e-10 tolerance
+ * - `na` values are skipped: the steps are between the last `length + 1` non-`na` values up to the current bar
+ *   (on an `na` bar, the result of the last non-`na` bar)
+ * - false while there are fewer than `length + 1` non-`na` values
+ *
+ * @example
+ * ```typescript
+ * const isFalling = ta.falling(close, 3);
+ * // Detect downward momentum
+ * ```
+ */
+export declare function falling(source: Source, length: simple_int): series_bool;
+/**
+ * Rate of Change (ROC) - percentage change between current value and value length bars ago.
+ *
+ * @param source - Series of values to process
+ * @param length - Number of bars (length)
+ * @returns ROC series as percentage
+ *
+ * @remarks
+ * - Formula: `100 * change(source, length) / source[length]`
+ * - Equivalent to: `100 * (source - source[length]) / source[length]`
+ * - Returns percentage change, e.g., 5.0 means 5% increase
+ * - `na` values in the source series are included in calculations and will produce an `na` result
+ * - Useful for momentum analysis and trend strength measurement
+ *
+ * @example
+ * ```typescript
+ * const roc10 = ta.roc(closePrices, 10);
+ * // Positive ROC indicates upward momentum
+ * // Negative ROC indicates downward momentum
+ * ```
+ */
+export declare function roc(source: Source, length: simple_int): series_float;
+/**
+ * Momentum (MOM) - difference between current value and value length bars ago.
+ *
+ * @param source - Series of values to process
+ * @param length - Offset from current bar to previous bar
+ * @returns Momentum series
+ *
+ * @remarks
+ * - Formula: `source - source[length]`
+ * - Equivalent to `ta.change(source, length)`
+ * - Positive momentum indicates upward movement
+ * - Negative momentum indicates downward movement
+ * - `na` values in the source series are included in calculations and will produce an `na` result
+ *
+ * @example
+ * ```typescript
+ * const mom10 = ta.mom(closePrices, 10);
+ * // Measures raw price momentum over 10 bars
+ * ```
+ */
+export declare function mom(source: Source, length: simple_int): series_float;
+/**
+ * Mean Absolute Deviation - measure of difference between series and its SMA.
+ *
+ * @param source - Series of values to process
+ * @param length - Number of bars (length)
+ * @returns Mean absolute deviation series
+ *
+ * @remarks
+ * - Measures average absolute distance from the mean
+ * - Formula: `sum(abs(source[i]! - sma)) / length` for i in 0 to length-1
+ * - Less sensitive to outliers than standard deviation
+ * - `na` values in the source series are ignored
+ * - The function calculates on the `length` quantity of non-`na` values
+ *
+ * @example
+ * ```typescript
+ * const dev10 = ta.dev(closePrices, 10);
+ * // Measures volatility using mean absolute deviation
+ * ```
+ */
+export declare function dev(source: Source, length: simple_int): series_float;
+/**
+ * Variance - expectation of squared deviation from mean.
+ *
+ * @param source - Series of values to process
+ * @param length - Number of bars (length)
+ * @param biased - Use biased (true) or unbiased (false) estimate (default: true)
+ * @returns Variance series
+ *
+ * @remarks
+ * - Measures how far values are spread out from their mean
+ * - If `biased` is true: divides by `length` (population variance)
+ * - If `biased` is false: divides by `length - 1` (sample variance)
+ * - Formula (biased): `sum((source[i]! - mean)^2) / length`
+ * - Formula (unbiased): `sum((source[i]! - mean)^2) / (length - 1)`
+ * - `na` values in the source series are ignored
+ * - The function calculates on the `length` quantity of non-`na` values
+ * - Relationship: `stdev = sqrt(variance)`
+ * - Computed as PineScript, bit for bit, from compensated running sums of the values and of their squares:
+ *   biased `sumSq / length - mean * mean`, unbiased `sumSq / (length - 1) - mean * sum / (length - 1)`
+ *
+ * @example
+ * ```typescript
+ * const variance20 = ta.variance(closePrices, 20);
+ * const sampleVariance = ta.variance(closePrices, 20, false);
+ * ```
+ */
+export declare function variance(source: Source, length: simple_int, biased?: simple_bool): series_float;
+/**
+ * Median - returns the median (middle value) of the series.
+ *
+ * @param source - Series of values to process
+ * @param length - Number of bars (length)
+ * @returns Median series
+ *
+ * @remarks
+ * - Returns the middle value when values are sorted
+ * - For an even length, returns the average of the two middle values
+ * - As in PineScript: `na` values are skipped, the window holds the last `length` non-na values
+ *   (going back as many bars as needed), and a bar whose own value is `na` still gets a result
+ * - Returns NaN until `length` non-na values exist
+ * - More robust to outliers than mean (SMA)
+ *
+ * @example
+ * ```typescript
+ * const median20 = ta.median(closePrices, 20);
+ * // Median is less affected by extreme values than SMA
+ * ```
+ */
+export declare function median(source: Source, length: simple_int): series_float;
+/**
+ * Symmetrically Weighted Moving Average (SWMA) - fixed length 4 with symmetric weights.
+ *
+ * @param source - Series of values to process
+ * @returns SWMA series
+ *
+ * @remarks
+ * - Fixed length of 4 bars
+ * - Weights: [1/6, 2/6, 2/6, 1/6] (symmetric)
+ * - Formula: `source[3] * 1/6 + source[2] * 2/6 + source[1] * 2/6 + source[0] * 1/6`
+ * - More weight given to middle values
+ * - `na` values in the source series are included in calculations and will produce an `na` result
+ * - Returns NaN for the first 3 bars
+ *
+ * @example
+ * ```typescript
+ * const swma = ta.swma(closePrices);
+ * // Smoothed price with symmetric weighting
+ * ```
+ */
+export declare function swma(source: Source): series_float;
+/**
+ * Volume Weighted Moving Average (VWMA) - moving average weighted by volume.
+ *
+ * @param source - Series of values to process
+ * @param length - Number of bars (length)
+ * @param volume - Volume series (required when not using context API)
+ * @returns VWMA series
+ *
+ * @remarks
+ * - **PineScript v6 signature**: `ta.vwma(source, length)` - uses implicit volume data
+ * - **JavaScript signature**: Requires explicit `volume` OR use `createContext()`
+ * - Formula: `sma(source * volume, length) / sma(volume, length)`
+ * - Gives more weight to bars with higher volume
+ * - `na` values in the source series are ignored
+ * - Useful for price analysis considering volume significance
+ *
+ * @example
+ * ```typescript
+ * // Direct call with explicit volume
+ * const vwma20 = ta.vwma(closePrices, 20, volumeData);
+ *
+ * // Or use context API for cleaner syntax
+ * const { ta } = createContext({ chart: { high, low, close, volume } });
+ * const vwma20 = ta.vwma(close, 20); // Matches PineScript!
+ * ```
+ */
+export declare function vwma(source: Source, length: simple_int, volume?: Source): series_float;
+/**
+ * Linear Regression - line that best fits prices using least squares method.
+ *
+ * @param source - Series of values to process
+ * @param length - Number of bars (length)
+ * @param offset - Offset (default: 0)
+ * @returns Linear regression value
+ *
+ * @remarks
+ * - Calculates line of best fit using least squares method
+ * - Formula: `linreg = intercept + slope * (length - 1 - offset)`
+ * - offset=0 gives current fitted value, offset<0 gives future projection
+ * - `na` values in the source series are included in calculations and will produce an `na` result
+ * - Useful for trend detection and prediction
+ *
+ * @example
+ * ```typescript
+ * const linreg20 = ta.linreg(closePrices, 20, 0);
+ * const linregFuture = ta.linreg(closePrices, 20, -5); // Project 5 bars ahead
+ * ```
+ */
+export declare function linreg(source: Source, length: simple_int, offset?: simple_int): series_float;
+/**
+ * Correlation Coefficient - measures degree to which two series deviate from their means together.
+ *
+ * @param source1 - First series
+ * @param source2 - Second series
+ * @param length - Number of bars (length)
+ * @returns Correlation coefficient (-1 to +1)
+ *
+ * @remarks
+ * - Returns value between -1 and +1
+ * - +1 = perfect positive correlation
+ * - -1 = perfect negative correlation
+ * - 0 = no correlation
+ * - Measures linear relationship between two series
+ * - `na` values in the source series are ignored
+ * - The function calculates on the `length` quantity of non-`na` values
+ *
+ * @example
+ * ```typescript
+ * const corr = ta.correlation(series1, series2, 20);
+ * // Values close to +1 or -1 indicate strong relationship
+ * ```
+ */
+export declare function correlation(source1: Source, source2: Source, length: simple_int): series_float;
+/**
+ * Percent Rank - percentage of how many previous values were less than or equal to current value.
+ *
+ * @param source - Series of values to process
+ * @param length - Number of bars (length)
+ * @returns Percent rank (0 to 100)
+ *
+ * @remarks
+ * - Returns value between 0 and 100
+ * - 0 = current value is lowest in the period
+ * - 100 = current value is highest in the period
+ * - 50 = current value is at median
+ * - Useful for identifying relative strength within a period
+ *
+ * PineScript rules:
+ * - percentrank = count(source[k] <= source, k = 1..length) / length * 100
+ * - a value from bar `length` on, when the current source is not `na`; an `na` value in the window counts as not
+ *   `<=` the current value
+ * - the comparison uses the 1e-10 tolerance
+ *
+ * @example
+ * ```typescript
+ * const pctrank = ta.percentrank(closePrices, 100);
+ * // Values near 100 indicate recent strength
+ * // Values near 0 indicate recent weakness
+ * ```
+ */
+export declare function percentrank(source: Source, length: simple_int): series_float;
+/**
+ * Commodity Channel Index (CCI) - measures deviation from average price.
+ *
+ * @param source - Series of values to process
+ * @param length - Number of bars (length)
+ * @returns CCI series
+ *
+ * @remarks
+ * - CCI = (Typical Price - SMA of TP) / (0.015 * Mean Deviation)
+ * - Typical Price = (High + Low + Close) / 3
+ * - Mean Deviation = Average of absolute differences from mean
+ * - Scaled by 0.015 to provide more readable numbers
+ * - Values above +100 indicate overbought conditions
+ * - Values below -100 indicate oversold conditions
+ * - \`na\` values in the source series are ignored
+ *
+ * @example
+ * \`\`\`typescript
+ * const cci20 = ta.cci(typicalPrice, 20);
+ * // Overbought when cci > 100
+ * // Oversold when cci < -100
+ * \`\`\`
+ */
+export declare function cci(source: Source, length: simple_int): series_float;
+/**
+ * Stochastic Oscillator - momentum indicator comparing closing price to price range.
+ *
+ * @param source - Source series (typically close)
+ * @param high - High price series
+ * @param low - Low price series
+ * @param length - Number of bars (length)
+ * @returns Stochastic %K series (values range from 0 to 100)
+ *
+ * @remarks
+ * - Formula: 100 * (close - lowest(low, length)) / (highest(high, length) - lowest(low, length))
+ * - Measures where close is relative to the high-low range
+ * - Values above 80 typically indicate overbought
+ * - Values below 20 typically indicate oversold
+ * - Returns NaN when range is zero (high equals low)
+ * - \`na\` values in the source series are ignored
+ *
+ * @example
+ * \`\`\`typescript
+ * const stochK = ta.stoch(close, high, low, 14);
+ * // Smooth with SMA for %D line:
+ * const stochD = ta.sma(stochK, 3);
+ * \`\`\`
+ */
+export declare function stoch(source: Source, high: Source, low: Source, length: simple_int): series_float;
+/**
+ * Money Flow Index (MFI) - volume-weighted RSI measuring buying and selling pressure.
+ *
+ * @param source - Source series (typically hlc3 or close)
+ * @param length - Number of bars (length)
+ * @param volume - Volume series (required when not using context API)
+ * @returns MFI series (values range from 0 to 100)
+ *
+ * @remarks
+ * - **PineScript v6 signature**: `ta.mfi(source, length)` - uses implicit volume data
+ * - **JavaScript signature**: Requires explicit `volume` OR use `createContext()`
+ * - Combines price and volume to identify overbought/oversold conditions
+ * - Formula: 100 - (100 / (1 + Positive Money Flow / Negative Money Flow))
+ * - Values above 80 indicate overbought
+ * - Values below 20 indicate oversold
+ * - `na` values in the source series are ignored
+ *
+ * @example
+ * ```typescript
+ * // Direct call with explicit volume
+ * const mfi14 = ta.mfi(hlc3, 14, volume);
+ *
+ * // Or use context API for cleaner syntax
+ * const { ta } = createContext({ chart: { high, low, close, volume } });
+ * const mfi14 = ta.mfi(hlc3, 14); // Matches PineScript!
+ * ```
+ */
+export declare function mfi(source: Source, length: simple_int, volume?: Source): series_float;
+/**
+ * Hull Moving Average (HMA) - improved moving average with reduced lag.
+ *
+ * @param source - Series of values to process
+ * @param length - Number of bars (length)
+ * @returns Hull moving average series
+ *
+ * @remarks
+ * - Formula: WMA(2 * WMA(src, len/2) - WMA(src, len), sqrt(len))
+ * - Significantly reduces lag compared to traditional moving averages
+ * - Smoother than WMA while being more responsive
+ * - Created by Alan Hull
+ * - `na` values in the source series are ignored
+ *
+ * @example
+ * ```typescript
+ * const hma20 = ta.hma(closePrices, 20);
+ * // Faster response to price changes than SMA or EMA
+ * ```
+ */
+export declare function hma(source: Source, length: simple_int): series_float;
+/**
+ * Parabolic SAR (Stop and Reverse) - trend-following indicator.
+ *
+ * @param start - Acceleration factor start value (typically 0.02)
+ * @param inc - Acceleration factor increment (typically 0.02)
+ * @param max - Maximum acceleration factor (typically 0.2)
+ * @param high - High price series (required when not using context API)
+ * @param low - Low price series (required when not using context API)
+ * @param close - Close price series (required when not using context API)
+ * @returns SAR series
+ *
+ * @remarks
+ * - **PineScript v6 signature**: `ta.sar(start, inc, max)` - uses implicit chart data
+ * - **JavaScript signature**: Requires explicit `high`, `low`, `close` OR use `createContext()`
+ * - SAR below price indicates uptrend, above price indicates downtrend
+ * - Created by J. Welles Wilder Jr.
+ *
+ * @example
+ * ```typescript
+ * const sar = ta.sar(0.02, 0.02, 0.2, high, low, close);
+ * ```
+ */
+export declare function sar(start: simple_float, inc: simple_float, max: simple_float, high?: Source, low?: Source, close?: Source): series_float;
+/**
+ * Pivot High - detects pivot high points in the price series.
+ *
+ * @param sourceOrLeftbars - Source series or leftbars (overloaded)
+ * @param leftbarsOrRightbars - Leftbars or rightbars (overloaded)
+ * @param rightbars - Number of bars to the right (optional)
+ * @param high - High price series (used in 2-param version)
+ * @returns Series with the pivot high value on the bar where the pivot is confirmed
+ *   (`rightbars` bars after the pivot bar), NaN elsewhere
+ *
+ * @remarks
+ * - As in PineScript, the value appears `rightbars` bars after the pivot bar: the pivot bar
+ *   index is `i - rightbars`
+ * - A pivot high may equal values on its left but must be higher than all values on its right
+ * - An `na` neighbour ends the check on its side
+ *
+ * @example
+ * ```typescript
+ * const pivotHighs = ta.pivothigh(high, 2, 2);
+ * // pivotHighs[i] is high[i - 2] when bar i - 2 is a pivot high
+ * ```
+ */
+export declare function pivothigh(sourceOrLeftbars: Source | simple_int, leftbarsOrRightbars: simple_int, rightbars?: simple_int, high?: Source): series_float;
+/**
+ * Pivot Low - detects pivot low points in the price series.
+ *
+ * @param sourceOrLeftbars - Source series or leftbars (overloaded)
+ * @param leftbarsOrRightbars - Leftbars or rightbars (overloaded)
+ * @param rightbars - Number of bars to the right (optional)
+ * @param low - Low price series (used in 2-param version)
+ * @returns Series with the pivot low value on the bar where the pivot is confirmed
+ *   (`rightbars` bars after the pivot bar), NaN elsewhere
+ *
+ * @remarks
+ * - As in PineScript, the value appears `rightbars` bars after the pivot bar: the pivot bar
+ *   index is `i - rightbars`
+ * - A pivot low may equal values on its left but must be lower than all values on its right
+ * - An `na` neighbour ends the check on its side
+ *
+ * @example
+ * ```typescript
+ * const pivotLows = ta.pivotlow(low, 2, 2);
+ * // pivotLows[i] is low[i - 2] when bar i - 2 is a pivot low
+ * ```
+ */
+export declare function pivotlow(sourceOrLeftbars: Source | simple_int, leftbarsOrRightbars: simple_int, rightbars?: simple_int, low?: Source): series_float;
+/**
+ * Bars Since - returns number of bars since condition was true.
+ *
+ * @param condition - Boolean series condition
+ * @returns Series with number of bars since condition was last true
+ *
+ * @remarks
+ * - Returns 0 when condition is currently true
+ * - Increments by 1 for each bar condition remains false
+ * - Returns NaN if condition has never been true
+ *
+ * @example
+ * ```typescript
+ * const crossovers = ta.crossover(fastMA, slowMA);
+ * const barsSinceCross = ta.barssince(crossovers);
+ * ```
+ */
+export declare function barssince(condition: series_bool): series_float;
+/**
+ * Value When - returns the value when condition was true.
+ *
+ * @param condition - Boolean series condition
+ * @param source - Source series to get value from
+ * @param occurrence - Which occurrence to get (0 = most recent)
+ * @returns Series with values from when condition was true
+ *
+ * @remarks
+ * - occurrence=0 returns value from most recent true condition
+ * - occurrence=1 returns value from second most recent, etc.
+ * - Returns NaN if condition hasn't been true occurrence+1 times yet
+ *
+ * @example
+ * ```typescript
+ * const crossovers = ta.crossover(fastMA, slowMA);
+ * const lastCrossPrice = ta.valuewhen(crossovers, close, 0);
+ * ```
+ */
+export declare function valuewhen(condition: series_bool, source: Source, occurrence: simple_int): series_float;
+/**
+ * Directional Movement Index - returns Directional Movement indicators.
+ *
+ * @param diLength - DI averaging length
+ * @param adxSmoothing - ADX smoothing length
+ * @returns Tuple of [plusDI, minusDI, ADX]
+ *
+ * @remarks
+ * - +DI and -DI measure directional movement
+ * - ADX measures trend strength (0-100)
+ * - ADX above 25 typically indicates strong trend
+ * - Requires high, low, and close data from context
+ *
+ * @example
+ * ```typescript
+ * const [plusDI, minusDI, adx] = ta.dmi(14, 14);
+ * // When +DI > -DI and ADX > 25, strong uptrend
+ * // When -DI > +DI and ADX > 25, strong downtrend
+ * ```
+ */
+export declare function dmi(diLength: simple_int, adxSmoothing: simple_int, high: Source, low: Source, close: Source): [series_float, series_float, series_float];
+/**
+ * True Strength Index - momentum oscillator based on double smoothed momentum.
+ *
+ * @param source - Series of values to process
+ * @param shortLength - Short smoothing length
+ * @param longLength - Long smoothing length
+ * @returns TSI series
+ *
+ * @remarks
+ * - TSI oscillates between +100 and -100
+ * - Positive values indicate bullish momentum
+ * - Negative values indicate bearish momentum
+ * - Crossovers of zero line can signal trend changes
+ * - Less sensitive to short-term price fluctuations than RSI
+ *
+ * @example
+ * ```typescript
+ * const tsi = ta.tsi(close, 13, 25);
+ * // TSI > 0: bullish momentum
+ * // TSI < 0: bearish momentum
+ * ```
+ */
+export declare function tsi(source: Source, shortLength: simple_int, longLength: simple_int): series_float;
+/**
+ * Chande Momentum Oscillator - momentum indicator similar to RSI.
+ *
+ * @param source - Series of values to process
+ * @param length - Number of bars
+ * @returns CMO series
+ *
+ * @remarks
+ * - CMO oscillates between +100 and -100
+ * - CMO > +50: overbought conditions
+ * - CMO < -50: oversold conditions
+ * - Unlike RSI, CMO uses sum of gains/losses instead of averages
+ * - More volatile than RSI
+ *
+ * @example
+ * ```typescript
+ * const cmo = ta.cmo(close, 14);
+ * // CMO > 50: overbought
+ * // CMO < -50: oversold
+ * ```
+ */
+export declare function cmo(source: Source, length: simple_int): series_float;
+/**
+ * Keltner Channels - volatility-based envelope indicator.
+ *
+ * @param source - Series of values to process
+ * @param length - Number of bars for EMA
+ * @param mult - Multiplier for the range
+ * @param useTrueRange - Use True Range (default: true) or high-low
+ * @returns Tuple of [middle, upper, lower]
+ *
+ * @remarks
+ * - Middle band is EMA of source
+ * - Upper/lower bands are middle ± (range EMA × multiplier)
+ * - When useTrueRange=true, uses ATR for volatility
+ * - When useTrueRange=false, uses high-low range
+ * - Price breaking out of bands may signal trend continuation
+ * - Requires high, low, close data from context when useTrueRange=true
+ *
+ * @example
+ * ```typescript
+ * const [middle, upper, lower] = ta.kc(close, 20, 2, true);
+ * // Price above upper: potential uptrend
+ * // Price below lower: potential downtrend
+ * ```
+ */
+export declare function kc(source: Source, length: simple_int, mult: simple_float, useTrueRange?: simple_bool, high?: Source, low?: Source, close?: Source): [series_float, series_float, series_float];
+/**
+ * Bollinger Bands Width - measures the width of Bollinger Bands.
+ *
+ * @param source - Series of values to process
+ * @param length - Number of bars
+ * @param mult - Standard deviation multiplier
+ * @returns BBW series (percentage)
+ *
+ * @remarks
+ * - BBW = ((upper band - lower band) / middle band) × 100
+ * - Low BBW values indicate low volatility (potential breakout setup)
+ * - High BBW values indicate high volatility
+ * - BBW squeeze (narrowing bands) often precedes strong moves
+ * - Works with existing bb() function
+ *
+ * @example
+ * ```typescript
+ * const bbw = ta.bbw(close, 20, 2);
+ * // Low BBW: potential breakout coming
+ * // High BBW: high volatility period
+ * ```
+ */
+export declare function bbw(source: Source, length: simple_int, mult: simple_float): series_float;
+/**
+ * Williams %R (Williams Percent Range)
+ *
+ * Williams %R is a momentum indicator that measures overbought/oversold levels.
+ * It compares the closing price to the high-low range over a specified period.
+ *
+ * Values range from -100 (oversold) to 0 (overbought):
+ * - Above -20: Overbought
+ * - Below -80: Oversold
+ *
+ * @param high - High price series
+ * @param low - Low price series
+ * @param close - Close price series
+ * @param length - Lookback period (default: 14)
+ * @returns Williams %R series
+ *
+ * @example
+ * ```typescript
+ * const wpr = ta.wpr(high, low, close, 14);
+ * // wpr < -80: oversold
+ * // wpr > -20: overbought
+ * ```
+ */
+export declare function wpr(high: Source, low: Source, close: Source, length?: simple_int): series_float;
+/**
+ * Volume Weighted Average Price, restarted on each bar where `anchor` is true.
+ *
+ * @param source - Source series (PineScript default `hlc3`)
+ * @param volume - Volume series
+ * @param anchor - Reset condition per bar (PineScript `anchor`). Without it the sums never restart;
+ *   PineScript's default anchor is a new day (`timeframe.change("1D")`), which needs the exchange session
+ * @param stdev_mult - When given, also returns the bands `vwap ± stdev_mult × stdev`
+ * @returns The VWAP series, or `[vwap, upper, lower]` when `stdev_mult` is given
+ *
+ * @remarks
+ * As in PineScript: the sums restart on anchor bars; the standard deviation is
+ * `sqrt(Σ(volume × source²) / Σvolume − vwap²)`.
+ */
+export declare function vwap(source: Source, volume: Source, anchor?: ArrayLike<boolean | number>): series_float;
+export declare function vwap(source: Source, volume: Source, anchor: ArrayLike<boolean | number> | undefined, stdev_mult: simple_float): [series_float, series_float, series_float];
+/**
+ * Arnaud Legoux Moving Average (ALMA)
+ *
+ * ALMA uses a Gaussian distribution for weighting, reducing lag while maintaining smoothness.
+ * It's particularly good at tracking price action with minimal lag.
+ *
+ * @param source - Source series
+ * @param length - Window size (default: 9)
+ * @param offset - Controls the center of the Gaussian curve. 0.85 = focus on recent prices (default: 0.85)
+ * @param sigma - Standard deviation of the Gaussian. Controls smoothness (default: 6)
+ * @returns ALMA series
+ *
+ * @example
+ * ```typescript
+ * const alma = ta.alma(close, 9, 0.85, 6);
+ * // offset closer to 1: more responsive
+ * // offset closer to 0: smoother
+ * ```
+ */
+export declare function alma(source: Source, length?: simple_int, offset?: simple_float, sigma?: simple_float, floor?: boolean): series_float;
+/**
+ * Keltner Channels Width (KCW)
+ *
+ * Measures the width of Keltner Channels as a percentage of the middle line.
+ * Similar to BBW but uses ATR instead of standard deviation.
+ *
+ * Low KCW suggests consolidation/low volatility.
+ * High KCW suggests expansion/high volatility.
+ *
+ * @param source - Source series
+ * @param length - Number of bars for EMA and ATR (default: 20)
+ * @param mult - ATR multiplier (default: 2)
+ * @param useTrueRange - Use True Range instead of high-low (default: true)
+ * @param high - High price series
+ * @param low - Low price series
+ * @param close - Close price series
+ * @returns KCW series
+ *
+ * @example
+ * ```typescript
+ * const kcw = ta.kcw(close, 20, 2, true, high, low, close);
+ * // Low KCW: potential breakout coming
+ * // High KCW: high volatility period
+ * ```
+ */
+export declare function kcw(source: Source, length?: simple_int, mult?: simple_float, useTrueRange?: simple_bool, high?: Source, low?: Source, close?: Source): series_float;
+/**
+ * Difference between the highest and the lowest value over the last `length` non-na values
+ * (PineScript `ta.range(source, length)`).
+ *
+ * @remarks
+ * As in PineScript: `na` values are skipped (the window holds the last `length` non-na
+ * values), and a bar whose own value is `na` still gets a result.
+ */
+export declare function range(source: Source, length: simple_int): series_float;
+/**
+ * Offset to the bar with the highest value over the last `length` bars: 0 for the current bar,
+ * -1 for the previous bar, and so on (as in PineScript, the offset is negative).
+ *
+ * @remarks
+ * As in PineScript: on equal values the oldest bar wins; an `na` value ends the window;
+ * 0 when the window has no value.
+ */
+export declare function highestbars(source: Source, length: simple_int): series_int;
+/**
+ * Offset to the bar with the lowest value over the last `length` bars: 0 for the current bar,
+ * -1 for the previous bar, and so on (as in PineScript, the offset is negative).
+ *
+ * @remarks
+ * As in PineScript: on equal values the oldest bar wins; an `na` value ends the window;
+ * 0 when the window has no value.
+ */
+export declare function lowestbars(source: Source, length: simple_int): series_int;
+/**
+ * All-time highest value of `source` up to each bar (PineScript `ta.max(source)`).
+ *
+ * @remarks
+ * As in PineScript: `na` values are skipped, the value carries over `na` bars, and the
+ * result is `na` until the first non-na value.
+ */
+export declare function max(source: Source): series_float;
+/**
+ * All-time lowest value of `source` up to each bar (PineScript `ta.min(source)`).
+ *
+ * @remarks
+ * As in PineScript: `na` values are skipped, the value carries over `na` bars, and the
+ * result is `na` until the first non-na value.
+ */
+export declare function min(source: Source): series_float;
+/**
+ * Center of Gravity (COG)
+ *
+ * The Center of Gravity indicator is an oscillator developed by John Ehlers.
+ * It identifies turning points with minimal lag and provides clear signals.
+ *
+ * The COG calculates a weighted average where more recent prices have higher weights,
+ * similar to a moving average but with a focus on momentum shifts.
+ *
+ * @param source - Source series (typically close)
+ * @param length - Lookback period (default: 10)
+ * @returns COG series
+ *
+ * @example
+ * ```typescript
+ * const cogValue = ta.cog(close, 10);
+ * // Use COG crossovers as signals:
+ * // - COG crossing above 0: potential buy signal
+ * // - COG crossing below 0: potential sell signal
+ * ```
+ */
+export declare function cog(source: Source, length?: simple_int): series_float;
+/**
+ * Mode (Most Frequent Value)
+ *
+ * Returns the mode of the series - the most frequently occurring value.
+ * If there are several values with the same frequency, it returns the smallest value.
+ *
+ * @param source - Series of values to process
+ * @param length - Number of bars to look back
+ * @returns The most frequently occurring value
+ *
+ * @example
+ * ```typescript
+ * const values = [1, 2, 2, 3, 3, 3, 4, 4];
+ * const modeValue = ta.mode(values, 8); // Returns 3 (most frequent)
+ * ```
+ *
+ * @remarks
+ * - `na` values in the source series are ignored
+ * - If no mode exists, returns the smallest value
+ * - Returns NaN for the first (length - 1) values where there's insufficient data
+ */
+export declare function mode(source: Source, length: simple_int): series_float;
+/**
+ * Percentile (Linear Interpolation Method)
+ *
+ * Calculates the percentile using the method of linear interpolation between
+ * the two nearest ranks. This method may return values that are not members
+ * of the input data set.
+ *
+ * @param source - Series of values to process
+ * @param length - Number of bars to look back
+ * @param percentage - Percentile to calculate (0-100)
+ * @returns The calculated percentile value
+ *
+ * @example
+ * ```typescript
+ * const p50 = ta.percentile_linear_interpolation(close, 20, 50); // Median
+ * const p75 = ta.percentile_linear_interpolation(close, 20, 75); // 75th percentile
+ * ```
+ *
+ * @remarks
+ * - The result will NOT always be a member of the input data set
+ * - Uses linear interpolation between adjacent values when needed
+ * - Returns NaN for the first (length - 1) values where there's insufficient data
+ *
+ * PineScript rules:
+ * - position in the sorted window: `percentage / 100 * length - 0.5`, clamped to the first / last value, linear
+ *   interpolation between the two neighbours (na when a neighbour is na, also at an exact position)
+ * - `na` values stay in the window (window size = `length`). The window is kept sorted from bar to bar: the new
+ *   value is inserted before the first value `>=` it, passing the `na` values (an `na` goes last), then the value
+ *   leaving the window is removed. So the place of an `na` depends on the history: at the start of a series the
+ *   `na` values are before all numbers
+ */
+export declare function percentile_linear_interpolation(source: Source, length: simple_int, percentage: number): series_float;
+/**
+ * Percentile (Nearest Rank Method)
+ *
+ * Calculates the percentile using the Nearest Rank method. This method
+ * always returns a value that is a member of the input data set.
+ *
+ * @param source - Series of values to process
+ * @param length - Number of bars to look back
+ * @param percentage - Percentile to calculate (0-100)
+ * @returns The calculated percentile value
+ *
+ * @example
+ * ```typescript
+ * const p50 = ta.percentile_nearest_rank(close, 20, 50); // Median
+ * const p90 = ta.percentile_nearest_rank(close, 20, 90); // 90th percentile
+ * ```
+ *
+ * @remarks
+ * - The result will ALWAYS be a member of the input data set
+ * - The 100th percentile is defined as the largest value
+ * - Using this method on lengths < 100 may result in the same value for multiple percentiles
+ * - Returns NaN for the first (length - 1) values where there's insufficient data
+ *
+ * PineScript rules:
+ * - the value at rank `ceil(percentage / 100 * length)` of the sorted window (na when that rank holds an `na`)
+ * - `na` values stay in the window, sorted from bar to bar as in `ta.percentile_linear_interpolation`
+ */
+export declare function percentile_nearest_rank(source: Source, length: simple_int, percentage: number): series_float;
+/**
+ * Rank Correlation Index (RCI)
+ *
+ * Calculates the Rank Correlation Index using Spearman's rank correlation coefficient.
+ * RCI measures the directional consistency of price movements, indicating whether
+ * the source consistently increased (positive values) or decreased (negative values).
+ *
+ * @param source - Series of values to process
+ * @param length - Number of bars to look back
+ * @returns RCI value scaled to range -100 to 100
+ *
+ * @example
+ * ```typescript
+ * const rci9 = ta.rci(close, 9);
+ * // RCI near +100: strong upward consistency
+ * // RCI near -100: strong downward consistency
+ * // RCI near 0: no clear trend
+ * ```
+ *
+ * @remarks
+ * - Result is scaled to -100 to 100 range
+ * - +100 indicates source consistently increased over the period
+ * - -100 indicates source consistently decreased over the period
+ * - 0 indicates no directional consistency
+ * - Returns NaN for the first (length - 1) values where there's insufficient data
+ */
+export declare function rci(source: Source, length: simple_int): series_float;
+/**
+ * Pivot Point Levels
+ *
+ * Calculates pivot point levels using various calculation methods.
+ * Returns an array containing: [P, R1, S1, R2, S2, R3, S3, R4, S4, R5, S5]
+ *
+ * @param type - Calculation type: "Traditional", "Fibonacci", "Woodie", "Classic", "DM", "Camarilla"
+ * @param anchor - Condition that triggers reset of calculations
+ * @param developing - If true, pivots recalculate continuously; if false, use last anchor values
+ * @param high - High price series (optional, uses context if not provided)
+ * @param low - Low price series (optional, uses context if not provided)
+ * @param close - Close price series (optional, uses context if not provided)
+ * @param open - Open price series (optional, uses context if not provided)
+ * @returns Array of 11 pivot levels
+ *
+ * @example
+ * ```typescript
+ * const weekChange = [false, false, false, false, true, false, ...]; // Weekly anchor
+ * const pivots = ta.pivot_point_levels("Traditional", weekChange, false, high, low, close);
+ * // pivots[i]! = [P, R1, S1, R2, S2, R3, S3, R4, S4, R5, S5]
+ * ```
+ *
+ * @remarks
+ * - Woodie type cannot use developing=true (will error in PineScript)
+ * - DM type only calculates P, R1, S1 (other levels are NaN)
+ * - All calculations follow PineScript v6 specifications
+ */
+export declare function pivot_point_levels(type: series_float | string, anchor: series_bool, developing?: series_bool | boolean, high?: Source, low?: Source, close?: Source, open?: Source): series_float[];
+/**
+ * Ichimoku Kinko Hyo (Ichimoku Cloud) - Japanese charting technique for trend identification.
+ *
+ * @param conversionPeriods - Period for Tenkan-sen (Conversion Line), default: 9
+ * @param basePeriods - Period for Kijun-sen (Base Line), default: 26
+ * @param laggingSpan2Periods - Period for Senkou Span B (Leading Span B), default: 52
+ * @param displacement - Displacement for Senkou Spans and Chikou Span, default: 26
+ * @param high - High price series
+ * @param low - Low price series
+ * @param close - Close price series
+ * @returns Tuple of [tenkanSen, kijunSen, senkouSpanA, senkouSpanB, chikouSpan]
+ *
+ * @remarks
+ * - **Tenkan-sen (Conversion Line)**: `(highest(high, conversionPeriods) + lowest(low, conversionPeriods)) / 2`
+ * - **Kijun-sen (Base Line)**: `(highest(high, basePeriods) + lowest(low, basePeriods)) / 2`
+ * - **Senkou Span A (Leading Span A)**: `(tenkan + kijun) / 2` offset forward by `displacement` periods
+ * - **Senkou Span B (Leading Span B)**: `(highest(high, laggingSpan2Periods) + lowest(low, laggingSpan2Periods)) / 2` offset forward by `displacement` periods
+ * - **Chikou Span (Lagging Span)**: `close` offset backward by `displacement` periods
+ *
+ * The forward offset for Senkou Spans means they are projected into the future (NaN values at the end).
+ * The backward offset for Chikou Span means it shows past prices (NaN values at the beginning).
+ *
+ * @example
+ * ```typescript
+ * const [tenkan, kijun, senkouA, senkouB, chikou] = ta.ichimoku(9, 26, 52, 26, high, low, close);
+ *
+ * // Tenkan-sen crosses above Kijun-sen = bullish signal
+ * const bullishSignal = ta.crossover(tenkan, kijun);
+ *
+ * // Price above cloud = bullish trend
+ * // Cloud = area between senkouSpanA and senkouSpanB
+ * ```
+ */
+export declare function ichimoku(conversionPeriods: simple_int, basePeriods: simple_int, laggingSpan2Periods: simple_int, displacement: simple_int, high: Source, low: Source, close: Source): [series_float, series_float, series_float, series_float, series_float];
+/**
+ * ZigZag indicator - identifies significant trend reversals by filtering out minor price movements.
+ *
+ * @param deviation - Minimum percentage price change to form a new pivot (default: 5.0)
+ * @param depth - Minimum bars between pivots for pivot detection (default: 10)
+ * @param backstep - Bars to look back for confirmation (default: 3)
+ * @param source - Price source (optional, typically close)
+ * @param high - High price series (optional, for high/low mode)
+ * @param low - Low price series (optional, for high/low mode)
+ * @returns Tuple of [zigzag values, direction, pivot flags (boolean)]
+ *
+ * @remarks
+ * - **Parameter order differs from PineScript**: JavaScript signature puts deviation first,
+ *   while PineScript uses `ta.zigzag(source, deviation, depth, backstep)`. This allows
+ *   deviation to have a default value and makes the API more ergonomic for JS users.
+ * - **JavaScript signature**: Requires explicit `source`, `high`, `low` OR use `createContext()`
+ * - Returns the pivot price at pivot points, NaN for non-pivot bars
+ * - Direction: 1 = uptrend (from low to high), -1 = downtrend (from high to low)
+ * - The ZigZag indicator **repaints** by design - the last segment can change as new data arrives
+ * - Supports two modes:
+ *   - Single source mode: uses same series for highs and lows
+ *   - High/Low mode: uses high for pivot highs, low for pivot lows
+ *
+ * @example
+ * ```typescript
+ * // Using high/low for more accurate pivots
+ * const [zigzag, direction, isPivot] = ta.zigzag(5, 10, 3, undefined, high, low);
+ *
+ * // Find pivot prices
+ * for (let i = 0; i < zigzag.length; i++) {
+ *   if (!isNaN(zigzag[i]!)) {
+ *     console.log(`Pivot at bar ${i}: ${zigzag[i]!}, direction: ${direction[i]! === 1 ? 'UP' : 'DOWN'}`);
+ *   }
+ * }
+ * ```
+ */
+export declare function zigzag(deviation?: simple_float, depth?: simple_int, backstep?: simple_int, source?: Source, high?: Source, low?: Source): [series_float, series_int, series_bool];
+/**
+ * On Balance Volume: `ta.cum(math.sign(ta.change(close)) * volume)`.
+ *
+ * @param close - Close price series
+ * @param volume - Volume series
+ * @returns OBV series (`na` on the first bar, and on bars without volume)
+ */
+export declare function obv(close: Source, volume: Source): series_float;
+/**
+ * Price-Volume Trend: `ta.cum((ta.change(close) / close[1]) * volume)`.
+ *
+ * @param close - Close price series
+ * @param volume - Volume series
+ * @returns PVT series (`na` on the first bar, and on bars without volume)
+ */
+export declare function pvt(close: Source, volume: Source): series_float;
+/**
+ * Accumulation/Distribution index: the running sum of
+ * `(2 * close - low - high) / (high - low) * volume`, with 0 on bars where `high == low`.
+ */
+export declare function accdist(high: Source, low: Source, close: Source, volume: Source): series_float;
+/**
+ * Intraday Intensity Index: `(2 * close - high - low) / (high - low) * volume`.
+ *
+ * The PineScript built-in value is this formula. The formula shown in the PineScript reference,
+ * `(2 * close - high - low) / ((high - low) * volume)`, gives other values.
+ *
+ * @returns III series (`na` where `high == low`)
+ */
+export declare function iii(high: Source, low: Source, close: Source, volume: Source): series_float;
+/**
+ * Williams Variable Accumulation/Distribution: `(close - open) / (high - low) * volume`.
+ *
+ * @returns WVAD series (`na` where `high == low`)
+ */
+export declare function wvad(open: Source, high: Source, low: Source, close: Source, volume: Source): series_float;
+/**
+ * Williams Accumulation/Distribution: the running sum of `close - min(low, close[1])` on up
+ * closes, `close - max(high, close[1])` on down closes, and 0 otherwise (first bar included).
+ */
+export declare function wad(high: Source, low: Source, close: Source): series_float;
+/**
+ * Negative Volume Index: moves with the close change only on bars where volume falls.
+ * Starts at 1.
+ */
+export declare function nvi(close: Source, volume: Source): series_float;
+/**
+ * Positive Volume Index: moves with the close change only on bars where volume rises.
+ * Starts at 1.
+ */
+export declare function pvi(close: Source, volume: Source): series_float;
+//# sourceMappingURL=index.d.ts.map