qntjs-lib 1.0.0

package/dist/untyped/index.d.ts

@@ -0,0 +1,1194 @@
+// Generated untyped declarations with JSDoc preserved
+
+export type UltoscOptions = {
+    s1?: number;
+    s2?: number;
+    s3?: number;
+};
+
+/**
+ * Know Sure Thing (KST) momentum oscillator
+ * Default parameters match common KST configuration
+ */
+export type KstOptions = {
+    r1?: number;
+    r2?: number;
+    r3?: number;
+    r4?: number;
+    n1?: number;
+    n2?: number;
+    n3?: number;
+    n4?: number;
+    w1?: number;
+    w2?: number;
+    w3?: number;
+    w4?: number;
+};
+
+export type IchimokuOptions = {
+    tenkan?: number;
+    kijun?: number;
+    senkouB?: number;
+};
+
+declare namespace math {
+  /**
+   * Element-wise absolute value.
+   * @param source Input array
+   * @returns Float64Array of absolute values
+   */
+  export function abs(source: ArrayLike<number>): number[];
+  /**
+   * Element-wise addition.
+   * - If `b` is a number, returns `a + b` for each element.
+   * - If `b` is an array, returns element-wise sum up to the shorter length.
+   * @param a Left operand array
+   * @param b Right operand array or scalar
+   * @returns Float64Array of sums
+   */
+  export function add(a: ArrayLike<number>, b: ArrayLike<number> | number): number[];
+  /**
+   * Logical AND for boolean masks (Uint8Array) or with a scalar.
+   * Returns a Uint8Array of 1/0 values.
+   * @param a Left boolean mask
+   * @param b Right boolean mask or scalar
+   * @returns Uint8Array mask result
+   */
+  export function and(a: Uint8Array, b: Uint8Array | number): number[];
+  /**
+   * Index of the first maximum value (ignores NaNs). Returns -1 if none found.
+   * @param source Input array
+   * @returns Index of maximum or -1
+   */
+  export function argmax(source: ArrayLike<number>): number;
+  /**
+   * Index of the first minimum value (ignores NaNs). Returns -1 if none found.
+   * @param source Input array
+   * @returns Index of minimum or -1
+   */
+  export function argmin(source: ArrayLike<number>): number;
+  /**
+   * Element-wise average: (a + b) / 2.
+   * Computes the average without allocating temporaries.
+   * @param a First array
+   * @param b Second array or scalar
+   * @returns Float64Array of averages
+   */
+  export function avg(a: ArrayLike<number>, b: ArrayLike<number> | number): number[];
+  /**
+   * Element-wise ceil operation.
+   * @param source Input array
+   * @returns Float64Array of ceiled values
+   */
+  export function ceil(source: ArrayLike<number>): number[];
+  /**
+   * Clamp values to the inclusive range [lo, hi]. Preserves NaN entries.
+   * @param source Input array
+   * @param lo Lower bound
+   * @param hi Upper bound
+   * @returns Float64Array with values clamped or NaN preserved
+   */
+  export function clamp(source: ArrayLike<number>, lo: number, hi: number): number[];
+  /**
+   * Cumulative maximum: at each index the maximum over all prior valid elements.
+   * NaNs are preserved in the output at positions where input is NaN.
+   * @param source Input array
+   * @returns Float64Array of cumulative maxima
+   */
+  export function cummax(source: ArrayLike<number>): number[];
+  /**
+   * Cumulative minimum: at each index the minimum over all prior valid elements.
+   * NaNs are preserved in the output at positions where input is NaN.
+   * @param source Input array
+   * @returns Float64Array of cumulative minima
+   */
+  export function cummin(source: ArrayLike<number>): number[];
+  /**
+   * Cumulative product (NaN-preserving). At each index the product of all prior valid elements.
+   * @param source Input array
+   * @returns Float64Array of cumulative products (NaN where input was NaN)
+   */
+  export function cumprod(source: ArrayLike<number>): number[];
+  /**
+   * Cumulative sum preserving NaNs: NaN entries do not increase the running sum
+   * but are represented as the running total up to that point.
+   * @param source Input array
+   * @returns Float64Array of cumulative sums
+   */
+  export function cumsum(source: ArrayLike<number>): number[];
+  /**
+   * First difference: output[i] = source[i] - source[i-1].
+   * The first element is NaN (no previous value).
+   * @param source Input array
+   * @returns Float64Array of differences (first element NaN)
+   */
+  export function diff(source: ArrayLike<number>): number[];
+  /**
+   * Element-wise division.
+   * - If `b` is a number, divides each element of `a` by `b`.
+   * - If `b` is an array, returns element-wise quotients up to the shorter length.
+   * @param a Numerator array
+   * @param b Denominator array or scalar
+   * @returns Float64Array of quotients
+   */
+  export function div(a: ArrayLike<number>, b: ArrayLike<number> | number): number[];
+  /**
+   * Dot product of two vectors: sum_i x[i] * y[i].
+   * Operates up to the shorter length of the inputs.
+   * @param x First vector
+   * @param y Second vector
+   * @returns Scalar dot product
+   */
+  export function dot(x: ArrayLike<number>, y: ArrayLike<number>): number;
+  /**
+   * Element-wise equality comparison using `Number.EPSILON` tolerance.
+   * @param a Left operand
+   * @param b Right operand or scalar
+   * @returns Uint8Array mask of equality tests
+   */
+  export function eq(a: ArrayLike<number>, b: ArrayLike<number> | number): number[];
+  /**
+   * Element-wise floor operation.
+   * @param source Input array
+   * @returns Float64Array of floored values
+   */
+  export function floor(source: ArrayLike<number>): number[];
+  /**
+   * Element-wise greater-than comparison. Returns `Uint8Array` mask with 1 where true.
+   * @param a Left operand
+   * @param b Right operand or scalar
+   * @returns Uint8Array mask of comparisons
+   */
+  export function gt(a: ArrayLike<number>, b: ArrayLike<number> | number): number[];
+  /**
+   * Element-wise greater-than-or-equal comparison (with epsilon tolerance).
+   * @param a Left operand
+   * @param b Right operand or scalar
+   * @returns Uint8Array mask of comparisons
+   */
+  export function gte(a: ArrayLike<number>, b: ArrayLike<number> | number): number[];
+  /**
+   * Element-wise less-than comparison. Returns `Uint8Array` mask with 1 where true.
+   * @param a Left operand
+   * @param b Right operand or scalar
+   * @returns Uint8Array mask of comparisons
+   */
+  export function lt(a: ArrayLike<number>, b: ArrayLike<number> | number): number[];
+  /**
+   * Element-wise less-than-or-equal comparison (with epsilon tolerance).
+   * @param a Left operand
+   * @param b Right operand or scalar
+   * @returns Uint8Array mask of comparisons
+   */
+  export function lte(a: ArrayLike<number>, b: ArrayLike<number> | number): number[];
+  /**
+   * Maximum of an array, ignoring NaNs. Returns NaN if no valid entries.
+   * @param source Input array
+   * @returns Maximum value or NaN
+   */
+  export function max(source: ArrayLike<number>): number;
+  /**
+   * Minimum of an array, ignoring NaNs. Returns NaN if no valid entries.
+   * @param source Input array
+   * @returns Minimum value or NaN
+   */
+  export function min(source: ArrayLike<number>): number;
+  /**
+   * Element-wise multiplication.
+   * - If `b` is a number, scales each element of `a` by `b`.
+   * - If `b` is an array, returns element-wise products up to the shorter length.
+   * @param a Left operand array
+   * @param b Right operand array or scalar
+   * @returns Float64Array of products
+   */
+  export function mul(a: ArrayLike<number>, b: ArrayLike<number> | number): number[];
+  /**
+   * Element-wise inequality comparison.
+   * @param a Left operand
+   * @param b Right operand or scalar
+   * @returns Uint8Array mask where elements are not equal
+   */
+  export function neq(a: ArrayLike<number>, b: ArrayLike<number> | number): number[];
+  /**
+   * Vector p-norm. Supports common p values (1, 2, Infinity) with a fast dense path.
+   * When `skipna` is true the implementation ignores NaNs and returns NaN if no valid entries exist.
+   * @param x Input vector
+   * @param p Norm order (default 2)
+   * @param skipna Whether to ignore NaNs (default true)
+   * @returns Norm value or NaN
+   */
+  export function norm(x: ArrayLike<number>, p?: number, skipna?: boolean): number;
+  /**
+   * Logical NOT for a boolean mask (Uint8Array).
+   * @param a Input boolean mask
+   * @returns Uint8Array mask with bits inverted
+   */
+  export function not(a: Uint8Array): number[];
+  /**
+   * Ordinary least squares for a simple linear model y = intercept + slope * x.
+   * Ignores paired NaN entries and returns NaN coefficients if no valid pairs or singular design.
+   * @param x Predictor values
+   * @param y Response values
+   * @returns Object with `intercept` and `slope` or NaNs on failure
+   */
+  export function ols(x: ArrayLike<number>, y: ArrayLike<number>): {
+    intercept: number;
+    slope: number;
+};
+  /**
+   * Multiple linear regression using normal equations (adds intercept column internally).
+   * Returns coefficient vector or null if the normal matrix is singular or inputs are empty.
+   * @param X Design matrix (rows = observations, cols = features)
+   * @param y Response vector
+   * @returns Coefficient array [intercept, beta1, beta2, ...] or null
+   */
+  export function olsMulti(X: number[][], y: number[]): number[] | null;
+  /**
+   * Logical OR for boolean masks (Uint8Array) or with a scalar.
+   * Returns a Uint8Array of 1/0 values.
+   * @param a Left boolean mask
+   * @param b Right boolean mask or scalar
+   * @returns Uint8Array mask result
+   */
+  export function or(a: Uint8Array, b: Uint8Array | number): number[];
+  /**
+   * Product of array elements, ignoring NaNs. Returns NaN if no valid entries.
+   * @param source Input array
+   * @returns Product of values or NaN
+   */
+  export function prod(source: ArrayLike<number>): number;
+  /**
+   * Generate `n` standard normal samples using the Box-Muller transform.
+   * Uses `Math.random()`; tests should stub `Math.random` for determinism.
+   * @param n Number of samples to generate
+   * @param options Optional `{ mean, sd }` to shift/scale samples
+   * @returns Float64Array of length `n`
+   */
+  export function randnormal(n: number, options?: {
+    mean?: number;
+    sd?: number;
+}): number[];
+  /**
+   * Generate `n` uniform random values in [lo, hi).
+   * Uses `Math.random()`; tests should stub `Math.random` for determinism.
+   * @param n Number of samples to generate
+   * @param options Optional `{ lo, hi }` bounds (defaults to 0..1)
+   * @returns Float64Array of length `n`
+   */
+  export function randuniform(n: number, options?: {
+    lo?: number;
+    hi?: number;
+}): number[];
+  /**
+   * Rolling argmax: returns the index (into `source`) of the maximum value in each window.
+   * Positions before the window fills are NaN.
+   * @param source Input array
+   * @param period Window length
+   * @returns Float64Array of argmax indices (NaN when not available)
+   */
+  export function rollargmax(source: ArrayLike<number>, period: number): number[];
+  /**
+   * Rolling argmin: returns the index (into `source`) of the minimum value in each window.
+   * Positions before the window fills are NaN.
+   * @param source Input array
+   * @param period Window length
+   * @returns Float64Array of argmin indices (NaN when not available)
+   */
+  export function rollargmin(source: ArrayLike<number>, period: number): number[];
+  /**
+   * Rolling maximum over a window. NaN-aware: windows containing only NaNs produce NaN.
+   * @param source Input values
+   * @param period Window length (must be > 0)
+   * @returns Float64Array of rolling maxima (NaN for positions before the window fills)
+   */
+  export function rollmax(source: ArrayLike<number>, period: number): number[];
+  /**
+   * Rolling minimum over a window. NaN-aware: windows containing only NaNs produce NaN.
+   * @param source Input values
+   * @param period Window length (must be > 0)
+   * @returns Float64Array of rolling minima (NaN for positions before the window fills)
+   */
+  export function rollmin(source: ArrayLike<number>, period: number): number[];
+  /**
+   * Compute rolling minima and maxima pairwise over two input series.
+   * Optional callback `cb(minVal, maxVal, i)` is invoked for each computed window.
+   * @param minSource Input for minima
+   * @param maxSource Input for maxima
+   * @param period Window length (must be > 0)
+   * @param cb Optional callback invoked per window
+   * @returns Object with `min` and `max` Float64Array results
+   */
+  export function rollminmax(minSource: ArrayLike<number>, maxSource: ArrayLike<number>, period: number, cb?: (minVal: number, maxVal: number, i: number) => void): {
+    min: number[];
+    max: number[];
+};
+  /**
+   * Rolling product over a window. NaN-aware: windows with no valid entries produce NaN.
+   * Zeros are handled efficiently by tracking counts.
+   * @param source Input array
+   * @param period Window length (must be > 0)
+   * @returns Float64Array of rolling products (NaN for positions before window fills)
+   */
+  export function rollprod(source: ArrayLike<number>, period: number): number[];
+  /**
+   * Rolling sum over a window with optional NaN-skipping.
+   * If `skipna` is true, windows with no valid values produce NaN.
+   * Supports a fast dense path when inputs contain no NaNs.
+   * @param source Input array
+   * @param period Window length (must be > 0)
+   * @param skipna Whether to ignore NaNs (default: true)
+   * @returns Float64Array of rolling sums (NaN for positions before window fills)
+   */
+  export function rollsum(source: ArrayLike<number>, period: number, skipna?: boolean): number[];
+  /**
+   * Round values to nearest integer. Ties are rounded away from zero.
+   * @param source Input array
+   * @returns Float64Array of rounded integers
+   */
+  export function round(source: ArrayLike<number>): number[];
+  /**
+   * Scale an array by a scalar: `source * s`.
+   * @param source Input array
+   * @param s Scale factor
+   * @returns Float64Array scaled values
+   */
+  export function scale(source: ArrayLike<number>, s: number): number[];
+  /**
+   * Element-wise sign (-1, 0, 1) for each entry.
+   * @param source Input array
+   * @returns Float64Array of sign values
+   */
+  export function sign(source: ArrayLike<number>): number[];
+  /**
+   * Element-wise subtraction.
+   * - If `b` is a number, returns `a - b` for each element.
+   * - If `b` is an array, returns element-wise difference up to the shorter length.
+   * @param a Left operand array
+   * @param b Right operand array or scalar
+   * @returns Float64Array of differences
+   */
+  export function sub(a: ArrayLike<number>, b: ArrayLike<number> | number): number[];
+  /**
+   * Sum of array elements with optional NaN-skipping.
+   * When `skipna` is true (default) NaNs are ignored; returns NaN if no valid samples.
+   * Uses a fast dense path when global optimization allows it.
+   * @param source Input array
+   * @param skipna Whether to ignore NaNs (default: true)
+   * @returns Sum or NaN
+   */
+  export function sum(source: ArrayLike<number>, skipna?: boolean): number;
+}
+
+declare namespace ta {
+  /**
+   * Accumulation/Distribution (AD) line.
+   * Computes the cumulative money flow: AD[i] = AD[i-1] + MFM[i] * volume[i],
+   * where MFM = ((close - low) - (high - close)) / (high - low).
+   * NaNs propagate for invalid input tuples and the accumulator only updates on finite values.
+   * @param high High price series
+   * @param low Low price series
+   * @param close Close price series
+   * @param volume Volume series
+   * @returns Float64Array of AD values
+   */
+  export function ad(high: ArrayLike<number>, low: ArrayLike<number>, close: ArrayLike<number>, volume: ArrayLike<number>): number[];
+  /**
+   * Accumulation/Distribution Oscillator (ADOSC).
+   * Computes the difference between short- and long-term EMAs of the cumulative
+   * money flow (AD). Supports NaN-aware and dense fast-paths; outputs are NaN
+   * until the long EMA seeding is complete.
+   * @param high High price series
+   * @param low Low price series
+   * @param close Close price series
+   * @param volume Volume series
+   * @param shortPeriod Short EMA period
+   * @param longPeriod Long EMA period
+   * @param skipna Whether to ignore NaNs during computation (default: true)
+   * @returns Float64Array of ADOSC values (NaN where undefined)
+   */
+  export function adosc(high: ArrayLike<number>, low: ArrayLike<number>, close: ArrayLike<number>, volume: ArrayLike<number>, shortPeriod: number, longPeriod: number, skipna?: boolean): number[];
+  /**
+   * Average Directional Index (ADX).
+   * @param high High price series
+   * @param low Low price series
+   * @param close Close price series
+   * @param period Lookback period (must be > 0)
+   * @returns Float64Array of ADX values (NaN where undefined)
+   */
+  export function adx(high: ArrayLike<number>, low: ArrayLike<number>, close: ArrayLike<number>, period: number): number[];
+  /**
+   * ADXR (Average DX Rating) - smoothed ADX.
+   * @param high High price series
+   * @param low Low price series
+   * @param close Close price series
+   * @param period Lookback period (must be > 0)
+   * @returns Float64Array of ADXR values (NaN where undefined)
+   */
+  export function adxr(high: ArrayLike<number>, low: ArrayLike<number>, close: ArrayLike<number>, period: number): number[];
+  /**
+   * Awesome Oscillator (AO): difference between short and long simple moving averages
+   * of the median price ((high + low)/2). Supports NaN-aware and dense fast-paths.
+   * @param high High price series
+   * @param low Low price series
+   * @param shortPeriod Short SMA period (default 5)
+   * @param longPeriod Long SMA period (default 34)
+   * @param skipna When true, ignore NaNs inside windows; false forces dense path
+   * @returns Float64Array AO series (NaN where undefined)
+   */
+  export function ao(high: ArrayLike<number>, low: ArrayLike<number>, shortPeriod?: number, longPeriod?: number, skipna?: boolean): number[];
+  /**
+   * Absolute Price Oscillator (APO).
+   * Computes the difference between a short and a long EMA of `src`.
+   * Skips NaNs and seeds EMAs on the first valid value; returns NaN
+   * for indices before both EMAs have filled.
+   * @param src Input series
+   * @param shortPeriod Short EMA period
+   * @param longPeriod Long EMA period
+   * @returns Float64Array of APO values (NaN where undefined)
+   */
+  export function apo(src: ArrayLike<number>, shortPeriod: number, longPeriod: number): number[];
+  /**
+   * Aroon indicator: returns `[up, down]` arrays in percentage form (0-100)
+   * describing the time since the highest/lowest value within the lookback
+   * `period`. Supports NaN-aware and dense fast-paths.
+   * @param high High price series
+   * @param low Low price series
+   * @param period Lookback period (>0)
+   * @param skipna When true ignore NaNs in windows; false forces dense path
+   * @returns Tuple `[up, down]` Float64Array indicators
+   */
+  export function aroon(high: ArrayLike<number>, low: ArrayLike<number>, period: number, skipna?: boolean): [number[], number[]];
+  /**
+   * Average True Range (ATR).
+   * Computes ATR using Wilder's RMA over the true-range series. Handles NaNs
+   * via the `rma` NaN-aware implementation; returns NaN for indices before the
+   * lookback is filled.
+   * @param high High price series
+   * @param low Low price series
+   * @param close Close price series
+   * @param period Lookback period (must be > 0)
+   * @returns Float64Array of ATR values
+   */
+  export function atr(high: ArrayLike<number>, low: ArrayLike<number>, close: ArrayLike<number>, period: number): number[];
+  /**
+   * Bollinger Bands (BB).
+   * Returns `[middle, upper, lower]` where `middle` is the SMA, and `upper`/`lower`
+   * are `middle ± mult * stddev`. Uses a NaN-aware or dense `rollstdev` depending
+   * on input; positions before the window fills are NaN.
+   * @param source Input series
+   * @param period Window length (must be > 0)
+   * @param mult Standard-deviation multiplier
+   * @returns Tuple `[middle, upper, lower]` as Float64Array
+   */
+  export function bb(source: ArrayLike<number>, period: number, mult: number): [number[], number[], number[]];
+  /**
+   * Bollinger Band Width (BBW).
+   * Returns the normalized width of the Bollinger Bands as percentage: `100*(upper-lower)/middle`.
+   * NaNs propagate and positions with `middle === 0` leave the output unchanged (NaN or 0).
+   * @param source Input series
+   * @param period Window length
+   * @param mult Standard-deviation multiplier used for BB
+   * @returns Float64Array of BB width percentages
+   */
+  export function bbw(source: ArrayLike<number>, period: number, mult: number): number[];
+  /**
+   * Commodity Channel Index (CCI).
+   * Computes the typical price (TP) and compares to a moving average and
+   * mean absolute deviation (MAD) scaled by 0.015. Positions before the
+   * full lookback or with invalid inputs are NaN.
+   * Performance: O(n*p) due to MAD recomputation per window.
+   * @param high High price series
+   * @param low Low price series
+   * @param close Close price series
+   * @param period Lookback period (must be > 0)
+   * @returns Float64Array of CCI values (NaN where undefined)
+   */
+  export function cci(high: ArrayLike<number>, low: ArrayLike<number>, close: ArrayLike<number>, period: number): number[];
+  /**
+   * Simple change over `period`.
+   * Computes `src[i] - src[i-period]` for each index `i >= period`.
+   * Outputs NaN for indices before `period` and propagates NaNs for invalid pairs.
+   * @param src Input series
+   * @param period Lookback period (must be > 0)
+   * @returns Float64Array of simple change values (NaN where undefined)
+   */
+  export function change(src: ArrayLike<number>, period: number): number[];
+  /**
+   * Chande Momentum Oscillator (CMO).
+   * Computes CMO over `period` using percent scaling in [-100, 100].
+   * Ignores NaNs in the input deltas; positions before the first
+   * computable value are NaN.
+   * @param src Input series
+   * @param period Period over which to compute the oscillator
+   * @returns Float64Array of CMO values (NaN where undefined)
+   */
+  export function cmo(src: ArrayLike<number>, period: number): number[];
+  /**
+   * Test whether series `a` crosses `b` (or a scalar) between the previous and
+   * current index. By default uses a symmetric cross test that detects both
+   * upward and downward crossings. Comparisons are strict and require non-NaN
+   * current and previous values for both operands.
+   * @param a Left series
+   * @param b Right series or scalar
+   * @param test Optional custom comparator receiving (ai, aim1, bi, bim1)
+   * @returns Uint8Array mask where 1 indicates a crossing at that index
+   */
+  export function cross(a: ArrayLike<number>, b: ArrayLike<number> | number, test?: (ai: number, aim1: number, bi: number, bim1: number) => boolean): number[];
+  /**
+   * Detect an upward crossover (a crosses above b).
+   */
+  export function crossover(a: ArrayLike<number>, b: ArrayLike<number> | number): number[];
+  /**
+   * Detect a downward crossunder (a crosses below b).
+   */
+  export function crossunder(a: ArrayLike<number>, b: ArrayLike<number> | number): number[];
+  /**
+   * Double Exponential Moving Average (DEMA).
+   * DEMA reduces lag by combining a single EMA and a double-smoothed EMA:
+   * DEMA = 2 * EMA(source, period) - EMA(EMA(source, period), period).
+   * Preserves NaN gaps and follows the same seeding semantics as `ema`.
+   * @param source Input series
+   * @param period Smoothing period (must be > 0)
+   * @returns Float64Array of DEMA values (NaN where undefined)
+   */
+  export function dema(source: ArrayLike<number>, period: number): number[];
+  /**
+   * Directional Indicators (DI+ and DI-).
+   * @param high High price series
+   * @param low Low price series
+   * @param close Close price series
+   * @param period Lookback period (must be > 0)
+   * @returns Tuple `[diplus, diminus]` as Float64Array
+   */
+  export function di(high: ArrayLike<number>, low: ArrayLike<number>, close: ArrayLike<number>, period: number): [number[], number[]];
+  /**
+   * Donchian Channels.
+   * Returns `[upper, lower, middle]` where `upper` is the highest high
+   * and `lower` the lowest low over the lookback `period`. `middle` is the
+   * midpoint. NaNs propagate when inputs are invalid.
+   * @param high High price series
+   * @param low Low price series
+   * @param period Lookback period (must be > 0)
+   * @returns Tuple `[upper, lower, middle]` as Float64Array
+   */
+  export function donchian(high: ArrayLike<number>, low: ArrayLike<number>, period: number): [number[], number[], number[]];
+  /**
+   * Detrended Price Oscillator (DPO).
+   * Computes DPO[i] = source[i - shift] - SMA(source, period)[i], where
+   * shift = floor(period/2) + 1. Outputs are NaN for indices before the
+   * shift or when insufficient data exists.
+   * @param source Input series
+   * @param period Lookback period (must be > 0)
+   * @returns Float64Array of DPO values (NaN where undefined)
+   */
+  export function dpo(source: ArrayLike<number>, period: number): number[];
+  /**
+   * DX (Directional Movement Index).
+   * @param high High price series
+   * @param low Low price series
+   * @param close Close price series
+   * @param period Lookback period (must be > 0)
+   * @returns Float64Array of DX values (NaN where undefined)
+   */
+  export function dx(high: ArrayLike<number>, low: ArrayLike<number>, close: ArrayLike<number>, period: number): number[];
+  /**
+   * Exponential Moving Average (EMA).
+   * Seeds on the first non-NaN value and uses the standard EMA recurrence.
+   * Preserves NaN gaps in the input: outputs are NaN until enough valid samples
+   * have been seen to initialize the EMA.
+   * @param source Input series
+   * @param period Smoothing period (must be > 0)
+   * @returns Float64Array of EMA values (NaN where undefined)
+   */
+  export function ema(source: ArrayLike<number>, period: number): number[];
+  /**
+   * Falling mask: returns a Uint8Array where `1` indicates `source[i]` is
+   * strictly less than the value `length` periods ago (NaN-aware).
+   * When `skipna` is true, NaNs are tolerated and preserved; when false a
+   * dense fast-path is used (assumes no NaNs).
+   * @param source Input numeric series
+   * @param length Lookback length (>0)
+   * @param skipna Whether to ignore NaNs during computation (default: true)
+   * @returns Uint8Array mask with 0/1 values
+   */
+  export function falling(source: ArrayLike<number>, length: number, skipna?: boolean): number[];
+  /**
+   * Hull Moving Average (HMA).
+   * Computes a lower-lag smoothing by combining WMAs at different lengths
+   * and then applying a final WMA on the derived series. Pine-compatible
+   * and NaN-aware: NaNs propagate where insufficient valid samples exist.
+   * @param source Input series
+   * @param period Window length (must be > 0)
+   * @returns Float64Array of HMA values (NaN where undefined)
+   */
+  export function hma(source: ArrayLike<number>, period: number): number[];
+  /**
+   * Ichimoku Kinko Hyo indicator components.
+   * Returns `[tenkan, kijun, senkouA, senkouB, chikou]` where senkou lines
+   * are shifted forward by the `kijun` displacement and chikou is the close
+   * shifted backward. NaN is produced where rolling inputs are invalid.
+   * @param high High price series
+   * @param low Low price series
+   * @param close Close price series
+   * @param options Optional periods `{ tenkan, kijun, senkouB }`
+   * @returns Tuple of Float64Array: `[tenkan, kijun, senkouA, senkouB, chikou]`
+   */
+  export function ichimoku(high: ArrayLike<number>, low: ArrayLike<number>, close: ArrayLike<number>, options?: IchimokuOptions): [number[], number[], number[], number[], number[]];
+  /**
+   * Kaufman Adaptive Moving Average (KAMA).
+   * Adapts smoothing based on the efficiency ratio (market noise vs direction).
+   * This implementation supports NaN-aware and dense fast-paths; when NaNs are
+   * present the compacting + mapping strategy is used, otherwise an O(n)
+   * incremental volatility approach is used for speed.
+   * @param source Input series
+   * @param period Efficiency smoothing lookback (must be > 0)
+   * @param fastPeriod Fast smoothing period (default: 2)
+   * @param slowPeriod Slow smoothing period (default: 30)
+   * @param skipna Whether to ignore NaNs (default: true)
+   * @returns Float64Array of KAMA values (NaN where undefined)
+   */
+  export function kama(source: ArrayLike<number>, period: number, fastPeriod?: number, slowPeriod?: number, skipna?: boolean): number[];
+  /**
+   * Keltner Channels.
+   * Returns `[middle(EMA of typical price), upper, lower]` where upper/lower are `middle ± mult * ATR`.
+   * Preserves NaNs when inputs are invalid.
+   * @param high High price series
+   * @param low Low price series
+   * @param close Close price series
+   * @param period Lookback period (must be > 0)
+   * @param mult Multiplier applied to ATR
+   * @returns Tuple `[middle, upper, lower]` as Float64Array
+   */
+  export function keltner(high: ArrayLike<number>, low: ArrayLike<number>, close: ArrayLike<number>, period: number, mult: number): [number[], number[], number[]];
+  /**
+   * Know Sure Thing (KST) momentum oscillator.
+   * Computes a weighted sum of smoothed rate-of-change series.
+   * Parameters may be supplied via the `options` object or defaults are used.
+   * The output length equals `src.length`; positions before the required
+   * lookback periods are NaN.
+   * @param src Input series
+   * @param options Optional parameters for ROC and smoothing windows
+   * @returns Float64Array of KST values (NaN where insufficient data)
+   */
+  export function kst(src: ArrayLike<number>, options?: KstOptions): number[];
+  /**
+   * Moving Average Convergence Divergence (MACD).
+   * Produces the MACD line (short EMA - long EMA), the signal line (EMA of MACD),
+   * and the histogram (MACD - signal). Skips NaNs and seeds EMAs on first valid
+   * value; outputs are NaN until the EMAs and signal have seeded.
+   * @param src Input series
+   * @param shortPeriod Short EMA period
+   * @param longPeriod Long EMA period
+   * @param signalPeriod Signal EMA period
+   * @returns Tuple `[macdLine, signalLine, histogram]` as Float64Array
+   */
+  export function macd(src: ArrayLike<number>, shortPeriod: number, longPeriod: number, signalPeriod: number): [number[], number[], number[]];
+  /**
+   * Money Flow Index (MFI).
+   * Computes MFI over `period` using typical price and money flow; NaN-aware
+   * sliding-window implementation that emits NaN where insufficient valid data exists.
+   * @param high High price series
+   * @param low Low price series
+   * @param close Close price series
+   * @param volume Volume series
+   * @param period Lookback period (must be > 0)
+   * @returns Float64Array of MFI values in [0,100]
+   */
+  export function mfi(high: ArrayLike<number>, low: ArrayLike<number>, close: ArrayLike<number>, volume: ArrayLike<number>, period: number): number[];
+  /**
+   * Momentum (difference) indicator.
+   * Computes `src[i] - src[i - period]` for each index; positions where
+   * the lagged value is not available are NaN.
+   * @param src Input series
+   * @param period Lag period (must be > 0)
+   * @returns Float64Array of momentum values (NaN where undefined)
+   */
+  export function mom(src: ArrayLike<number>, period: number): number[];
+  export function natr(high: ArrayLike<number>, low: ArrayLike<number>, close: ArrayLike<number>, period: number): number[];
+  /**
+   * On-Balance Volume (OBV).
+   * Accumulates volume by sign of price change: add volume when price rises,
+   * subtract when price falls; NaNs in inputs yield NaN outputs for that index.
+   * @param price Price series
+   * @param volume Volume series
+   * @returns Float64Array of OBV values
+   */
+  export function obv(price: ArrayLike<number>, volume: ArrayLike<number>): number[];
+  /**
+   * Positive/Negative Volume Index (PNVI).
+   * Returns `[pvi, nvi]` series tracking separate indices when volume increases
+   * (PVI) or decreases (NVI). Preserves NaNs and treats zero close as missing.
+   * @param close Close price series
+   * @param volume Volume series
+   * @param start Initial index value (default: 1000)
+   * @returns Tuple `[pvi, nvi]` as Float64Array
+   */
+  export function pnvi(close: ArrayLike<number>, volume: ArrayLike<number>, start?: number): [number[], number[]];
+  /**
+   * Percentage Price Oscillator (PPO).
+   * PPO = 100 * (EMA_short - EMA_long) / EMA_long.
+   * Skips NaNs and seeds EMAs on first valid value; outputs are NaN until the
+   * long EMA has enough data. When EMA_long is zero, returns 0 to avoid division.
+   * @param src Input series
+   * @param shortPeriod Short EMA period
+   * @param longPeriod Long EMA period
+   * @returns Float64Array of PPO values (NaN where undefined)
+   */
+  export function ppo(src: ArrayLike<number>, shortPeriod: number, longPeriod: number): number[];
+  /**
+   * Parabolic SAR (PSAR) indicator.
+   * @param high High price series
+   * @param low Low price series
+   * @param step Acceleration step increment (>0)
+   * @param maxStep Maximum acceleration value (>= step)
+   * @param skipna When true ignore NaNs; when false use dense fast-path
+   * @returns Float64Array PSAR values (NaN for undefined positions)
+   */
+  export function psar(high: ArrayLike<number>, low: ArrayLike<number>, step: number, maxStep: number, skipna?: boolean): number[];
+  /**
+   * Rising mask: returns a Uint8Array where `1` indicates `source[i]` is
+   * strictly greater than the value `length` periods ago (NaN-aware).
+   * When `skipna` is true, NaNs are tolerated and preserved; when false a
+   * dense fast-path is used (assumes no NaNs).
+   * @param source Input numeric series
+   * @param length Lookback length (>0)
+   * @param skipna Whether to ignore NaNs during computation (default: true)
+   * @returns Uint8Array mask with 0/1 values
+   */
+  export function rising(source: ArrayLike<number>, length: number, skipna?: boolean): number[];
+  /**
+   * Wilder's Moving Average / RMA.
+   * Implements the Wilder smoothing recurrence (rma = (rma*(period-1) + x)/period).
+   * When `skipna` is true NaNs are ignored during seeding and updates; otherwise
+   * a dense fast-path is used for NaN-free inputs.
+   * @param source Input series
+   * @param period Smoothing period (must be > 0)
+   * @param skipna Whether to ignore NaNs during computation (default: true)
+   * @returns Float64Array of RMA values (NaN before window fills)
+   */
+  export function rma(source: ArrayLike<number>, period: number, skipna?: boolean): number[];
+  /**
+   * Percentage Rate-of-Change (ROC).
+   * Returns 100 * (src[i] - src[i-period]) / src[i-period]. NaN is returned
+   * for indices before `period` or when a denominator is NaN/zero.
+   * @param src Input series
+   * @param period Lookback period (must be > 0)
+   * @returns Float64Array of ROC values (NaN where undefined)
+   */
+  export function roc(src: ArrayLike<number>, period: number): number[];
+  /**
+   * Relative Strength Index (RSI) with optional NaN-aware behavior.
+   * - `skipna=false` (dense path): assumes inputs contain no NaNs or that NaN
+   *   propagation is desired; uses a dense fast-path implementation.
+   * - `skipna=true` (NaN-aware): skips NaNs when computing deltas and preserves
+   *   gaps in the output where insufficient valid data exists.
+   * Seeding: the implementation seeds on the first valid value and uses Wilder
+   * smoothing once the initial window is filled.
+   * @param src Input series
+   * @param period Lookback period for RSI (must be > 0)
+   * @param skipna Whether to ignore NaNs during computation (default: true)
+   * @returns Float64Array of RSI values (NaN where undefined)
+   */
+  export function rsi(src: ArrayLike<number>, period: number, skipna?: boolean): number[];
+  /**
+   * Simple Moving Average (SMA).
+   * Computes the arithmetic mean over a sliding window.
+   * When `skipna` is true, NaNs inside the window are ignored; when false
+   * a dense fast-path is used (assumes no NaNs).
+   * @param source Input series
+   * @param period Window length (must be > 0)
+   * @param skipna Whether to ignore NaNs inside windows (default: true)
+   * @returns Float64Array of SMA values (NaN before window fills)
+   */
+  export function sma(source: ArrayLike<number>, period: number, skipna?: boolean): number[];
+  /**
+   * Stochastic oscillator (fast %K and %D smoothed outputs).
+   * Computes fast %K based on rolling highest/lowest over `kPeriod`, then
+   * smooths with `kSlow` and `dPeriod` using dense SMA. Assumes input series
+   * length equality and returns NaN when insufficient data exists.
+   * @param high High price series
+   * @param low Low price series
+   * @param close Close price series
+   * @param kPeriod %K lookback period
+   * @param kSlow Smoothing period for %K
+   * @param dPeriod Smoothing period for %D
+   * @returns Tuple `[slowK, slowD]` as Float64Array
+   */
+  export function stoch(high: ArrayLike<number>, low: ArrayLike<number>, close: ArrayLike<number>, kPeriod: number, kSlow: number, dPeriod: number): [number[], number[]];
+  /**
+   * Stochastic RSI.
+   * Applies a stochastic calculation to the RSI series, producing values in [0,1].
+   * This implementation is NaN-aware and maintains deques over valid RSI samples.
+   * @param close Close price series
+   * @param period RSI lookback period
+   * @returns Float64Array of StochRSI values (NaN where undefined)
+   */
+  export function stochrsi(close: ArrayLike<number>, period: number): number[];
+  /**
+   * Supertrend indicator.
+   * Returns `[supertrend, finalUpper, finalLower, isUpMask]`.
+   * `supertrend` contains the plotted trend line (either finalLower when up or finalUpper when down),
+   * `finalUpper`/`finalLower` are the band values, and `isUpMask` is a Uint8Array mask (1 when up).
+   * NaNs are preserved for invalid inputs or before enough data is available.
+   * @param high High price series
+   * @param low Low price series
+   * @param close Close price series
+   * @param period ATR lookback period
+   * @param mult Multiplier applied to ATR to form bands
+   * @returns Tuple `[supertrend, finalUpper, finalLower, isUpMask]`
+   */
+  export function supertrend(high: ArrayLike<number>, low: ArrayLike<number>, close: ArrayLike<number>, period: number, mult: number): [number[], number[], number[], number[]];
+  /**
+   * Triple Exponential Moving Average (T3)
+   *
+   * T3 is a triple-smoothed moving average developed by Tim Tillson that reduces lag
+   * and smoothing compared to traditional EMAs while maintaining responsiveness to price changes.
+   *
+   * @param source - Input data array
+   * @param period - Smoothing period (default: 5)
+   * @param volumeFactor - Volume factor for smoothing (default: 0.7)
+   * @returns T3 values
+   */
+  /**
+   * Triple Exponential Moving Average (T3)
+   *
+   * Implemented following TA‑Lib's algorithm (see TA_T3 C implementation).
+   * This inlines the nested EMA seeding (e1..e6) and performs a single-pass
+   * update, which is significantly faster than calling `ema()` six times.
+   *
+   * Notes:
+   * - Lookback = 6 * (period - 1)
+   * - For inputs containing NaNs we propagate NaN outputs where we cannot
+   *   compute valid seeds or updates.
+   */
+  export function t3(source: ArrayLike<number>, period: number, volumeFactor: number): number[];
+  /**
+   * Triple Exponential Moving Average (TEMA).
+   * Combines three nested EMAs to reduce lag while smoothing:
+   * TEMA = 3*EMA1 - 3*EMA2 + EMA3. Preserves NaN gaps and seeds
+   * each EMA before emitting values.
+   * @param source Input series
+   * @param period Smoothing period (must be > 0)
+   * @returns Float64Array of TEMA values (NaN where undefined)
+   */
+  export function tema(source: ArrayLike<number>, period: number): number[];
+  /**
+   * True Range (TR).
+   * TR[i] = max(high[i]-low[i], |high[i]-close[i-1]|, |low[i]-close[i-1]|).
+   * Preserves NaNs and returns NaN where inputs are invalid.
+   * @param high High price series
+   * @param low Low price series
+   * @param close Close price series
+   * @returns Float64Array of TR values
+   */
+  export function tr(high: ArrayLike<number>, low: ArrayLike<number>, close: ArrayLike<number>): number[];
+  /**
+   * Triangular Moving Average (TRIMA).
+   * A triangular-weighted moving average implemented via two `sma` passes.
+   * Preserves NaN handling by delegating to `sma` implementations.
+   * @param source Input series
+   * @param period Window length (must be > 0)
+   * @returns Float64Array of TRIMA values (NaN where undefined)
+   */
+  export function trima(source: ArrayLike<number>, period: number): number[];
+  /**
+   * Ultimate Oscillator (ULTOSC).
+   * Combines short-, mid-, and long-term averages of the buying pressure / true range
+   * to produce a bounded oscillator in [0,100]. Preserves NaN inputs and returns
+   * NaN for indices before the longest lookback has sufficient data.
+   * @param high High price series
+   * @param low Low price series
+   * @param close Close price series
+   * @param options Optional periods for short/mid/long (s1,s2,s3)
+   * @returns Float64Array of Ultimate Oscillator values (NaN where undefined)
+   */
+  export function ultosc(high: ArrayLike<number>, low: ArrayLike<number>, close: ArrayLike<number>, options?: UltoscOptions): number[];
+  /**
+   * Volume Weighted Moving Average (VWMA).
+   * Computes pvSum / vSum over a sliding window, NaN-aware. When `skipna` is
+   * true NaNs in either series are ignored within the window; when false a
+   * dense fast-path is used (assumes no NaNs).
+   * @param price Price series
+   * @param volume Volume series
+   * @param period Window length (>0)
+   * @param skipna Whether to ignore NaNs inside windows (default: true)
+   * @returns Float64Array of VWMA values (NaN before window fills)
+   */
+  export function vwma(price: ArrayLike<number>, volume: ArrayLike<number>, period: number, skipna?: boolean): number[];
+  /**
+   * Williams Accumulation/Distribution (WAD).
+   * Accumulates the money flow based on price movement using either a dense
+   * fast-path or a NaN-aware path depending on `skipna` and input contents.
+   * @param high High price series
+   * @param low Low price series
+   * @param close Close price series
+   * @param skipna Whether to ignore NaNs (default: true)
+   * @returns Float64Array of WAD values (NaN where undefined)
+   */
+  export function wad(high: ArrayLike<number>, low: ArrayLike<number>, close: ArrayLike<number>, skipna?: boolean): number[];
+  /**
+   * Weighted Moving Average (WMA).
+   * Computes a linearly-weighted average over a sliding window with weights
+   * 1..period (oldest..newest). When `skipna` is true NaNs are ignored
+   * within the window; when false a dense fast-path is used.
+   * @param source Input series
+   * @param period Window length (must be > 0)
+   * @param skipna Whether to ignore NaNs inside windows (default: true)
+   * @returns Float64Array of WMA values (NaN before window fills)
+   */
+  export function wma(source: ArrayLike<number>, period: number, skipna?: boolean): number[];
+  /**
+   * Williams %R (WPR).
+   * Computes %R = (highestHigh - close) / (highestHigh - lowestLow) * -100
+   * over a rolling `period`. Uses `rollminmax` to compute window extrema and
+   * returns NaN for indices before `period` or when the range is zero.
+   * @param high High price series
+   * @param low Low price series
+   * @param close Close price series
+   * @param period Lookback period (must be > 0)
+   * @returns Float64Array of %R values (NaN where undefined)
+   */
+  export function wpr(high: ArrayLike<number>, low: ArrayLike<number>, close: ArrayLike<number>, period: number): number[];
+}
+
+declare namespace arr {
+}
+
+declare namespace stats {
+  /**
+   * Draw `k` bootstrap samples (with replacement) from `arr`.
+   * Uses `Math.random()`; tests should stub `Math.random` for determinism.
+   * @param arr Source array
+   * @param k Number of draws
+   * @returns Array of sampled elements (with replacement)
+   */
+  export function bootstrap<T>(arr: T[], k: number): T[];
+  /**
+   * Pearson correlation between `x` and `y`. When `skipna` is true only
+   * pairwise-valid entries are used; otherwise a dense fast-path is taken.
+   * @param x First input array
+   * @param y Second input array
+   * @param options Optional `{ skipna? }`
+   * @returns Correlation coefficient or NaN
+   */
+  export function corr(x: ArrayLike<number>, y: ArrayLike<number>, skipna?: boolean): number;
+  /**
+   * Pairwise covariance: cov(X,Y) = E[XY] - E[X]E[Y]
+   */
+  export function covar(x: ArrayLike<number>, y: ArrayLike<number>, options?: {
+    ddof?: number;
+}): number;
+  /**
+   * Geometric mean (optionally weighted). Values must be positive; NaNs are
+   * ignored when `skipna` is true. Returns NaN when no valid values.
+   * @param source Input array
+   * @param options Optional `{ weights?, skipna? }`
+   * @returns Geometric mean or NaN
+   */
+  export function gmean(source: ArrayLike<number>, options?: {
+    weights?: ArrayLike<number>;
+    skipna?: boolean;
+}): number;
+  /**
+   * Harmonic mean (optionally weighted). Values must be positive; NaNs are
+   * ignored when `skipna` is true. Returns NaN when no valid values.
+   * @param source Input array
+   * @param options Optional `{ weights?, skipna? }`
+   * @returns Harmonic mean or NaN
+   */
+  export function hmean(source: ArrayLike<number>, options?: {
+    weights?: ArrayLike<number>;
+    skipna?: boolean;
+}): number;
+  /**
+   * Excess kurtosis (kurtosis - 3) for `source` (ignores NaNs). Returns NaN when insufficient data.
+   * @param source Input array
+   * @returns Excess kurtosis or NaN
+   */
+  export function kurtosis(source: ArrayLike<number>): number;
+  /**
+   * Mean absolute deviation from the mean. When `skipna` is true NaNs are
+   * ignored. Returns NaN when the input contains no valid values.
+   * @param source Input array
+   * @param options Optional `{ skipna? }`
+   * @returns Mean absolute deviation or NaN
+   */
+  export function mad(source: ArrayLike<number>, skipna?: boolean): number;
+  /**
+   * Compute the (possibly weighted) mean of `source`.
+   * By default NaNs are skipped (`skipna=true`). When `weights` are provided they
+   * must match `source` length and the function computes the weighted mean.
+   * A dense fast-path is used when the global optimization allows it.
+   * @param source Input array
+   * @param options Optional `{ weights?, skipna? }`
+   * @returns Mean value or NaN when undefined
+   */
+  export function mean(source: ArrayLike<number>, options?: {
+    weights?: ArrayLike<number>;
+    skipna?: boolean;
+}): number;
+  /**
+   * Median of `source` (ignores NaNs). Implemented via `quantile(source, 0.5)`.
+   * @param source Input array
+   * @returns Median value or NaN
+   */
+  export function median(source: ArrayLike<number>): number;
+  /**
+   * Normalize to [0,1] by min/max scaling. Preserves NaNs when `skipna` is true.
+   * @param source Input array
+   * @param options Optional `{ skipna? }`
+   * @returns Float64Array of normalized values
+   */
+  export function norminmax(source: ArrayLike<number>, skipna?: boolean): number[];
+  /**
+   * Compute multiple percentiles (quantiles) for `source`. When `qs.length`
+   * is small, selection is used for each quantile; otherwise the data are
+   * sorted once for efficiency.
+   * @param source Input array
+   * @param qs Array of quantiles in [0,1]
+   * @returns Array of quantile values
+   */
+  export function percentiles(source: ArrayLike<number>, qs: number[]): number[];
+  /**
+   * Compute the quantile `q` of `source`, ignoring NaNs. Implements a
+   * selection-based algorithm using quickselect for expected linear time.
+   * @param source Input array
+   * @param q Quantile in [0,1]
+   * @returns Quantile value or NaN
+   */
+  export function quantile(source: ArrayLike<number>, q: number): number;
+  /**
+   * Rolling Pearson correlation computed from rolling covariance and stddev.
+   * Supports alignment modes via `options.outLength` ('min' or 'max').
+   * @param x First input array
+   * @param y Second input array
+   * @param period Window length
+   * @param options Optional `{ skipna?, outLength? }`
+   * @returns Float64Array of rolling correlations
+   */
+  export function rollcorr(x: ArrayLike<number>, y: ArrayLike<number>, period: number, options?: {
+    skipna?: boolean;
+    outLength?: 'min' | 'max';
+}): number[];
+  export function rollcovar(x: ArrayLike<number>, y: ArrayLike<number>, period: number, options?: {
+    ddof?: number;
+}): number[];
+  /**
+   * Rolling excess kurtosis over a sliding window of length `period`.
+   * @param source Input array
+   * @param period Window length
+   * @returns Float64Array of rolling kurtosis values
+   */
+  export function rollkurtosis(source: ArrayLike<number>, period: number): number[];
+  /**
+   * Rolling mean (moving average) over a sliding window of length `period`.
+   * When `skipna` is true, NaNs inside windows are ignored; windows with no
+   * valid values produce NaN. A fast dense path is used when no NaNs.
+   * @param source Input array
+   * @param period Window length (>0)
+   * @param skipna Whether to ignore NaNs (default: true)
+   * @returns Float64Array of rolling means
+   */
+  export function rollmean(source: ArrayLike<number>, period: number, skipna?: boolean): number[];
+  /**
+   * Compute the rolling median over a sliding window.
+   * Ignores NaNs and validates `period`.
+   * Returns a Float64Array with NaN entries for positions before the window fills.
+   * @param source Input array
+   * @param period Window length
+   * @returns Float64Array of rolling medians
+   */
+  export function rollmedian(source: ArrayLike<number>, period: number): number[];
+  /**
+   * Compute the rolling quantile over a sliding window.
+   * Ignores NaNs and validates `period` and `q`.
+   * Returns a Float64Array with NaN entries for positions before the window fills.
+   * @param source Input array
+   * @param period Window length
+   * @param q Quantile in [0,1]
+   * @returns Float64Array of rolling quantiles
+   */
+  export function rollquantile(source: ArrayLike<number>, period: number, q: number): number[];
+  /**
+   * Rolling skewness over a sliding window of length `period`.
+   * @param source Input array
+   * @param period Window length
+   * @returns Float64Array of rolling skewness values
+   */
+  export function rollskew(source: ArrayLike<number>, period: number): number[];
+  export function rollstdev(source: ArrayLike<number>, period: number, options?: {
+    skipna?: boolean;
+    ddof?: number;
+}): number[];
+  /**
+   * Rolling variance over a sliding window. Accepts `{ skipna?, ddof? }`.
+   * @param source Input array
+   * @param period Window length (>0)
+   * @param options Optional `{ skipna?, ddof? }`
+   * @returns Float64Array of rolling variances
+   */
+  export function rollvar(source: ArrayLike<number>, period: number, options?: {
+    skipna?: boolean;
+    ddof?: number;
+}): number[];
+  /**
+   * Draw `k` unique samples without replacement from `arr`.
+   * If `k` >= arr.length a shallow copy is returned. Uses `Math.random()`.
+   * @param arr Source array
+   * @param k Number of samples to draw
+   * @returns Array of sampled elements
+   */
+  export function sample<T>(arr: T[], k: number): T[];
+  /**
+   * In-place Fisher–Yates shuffle of `arr`.
+   * Uses `Math.random()`; tests should stub `Math.random` for determinism.
+   * @param arr Array to shuffle (mutated)
+   * @returns The shuffled array (same reference)
+   */
+  export function shuffle<T>(arr: T[]): T[];
+  /**
+   * Fisher-Pearson sample skewness (ignores NaNs). Returns NaN when insufficient data.
+   * @param source Input array
+   * @returns Skewness or NaN
+   */
+  export function skew(source: ArrayLike<number>): number;
+  /**
+   * Standard deviation: compute a single standard deviation over the whole series, dropping NaNs.
+   * Uses `ddof` (delta degrees of freedom) like NumPy/pandas: denominator = N - ddof.
+   * Default pandas behavior is sample standard deviation (ddof=1), so the default here is ddof=1.
+   */
+  export function stdev(source: ArrayLike<number>, options?: {
+    ddof?: number;
+    skipna?: boolean;
+}): number;
+  /**
+   * Variance: compute a single variance over the whole series, dropping NaNs.
+   * Uses `ddof` (delta degrees of freedom) like NumPy/pandas: denominator = N - ddof.
+   * Default pandas behavior is sample variance (ddof=1), so the default here is ddof=1.
+   */
+  export function variance(source: ArrayLike<number>, options?: {
+    ddof?: number;
+    skipna?: boolean;
+}): number;
+  /**
+   * Winsorize values to the given lower and upper quantile bounds.
+   * Preserves NaNs when `skipna` is true.
+   * @param source Input array
+   * @param options Optional `{ lower?, upper?, skipna? }` where bounds are in [0,1]
+   * @returns Float64Array of winsorized values
+   */
+  export function winsorize(source: ArrayLike<number>, options?: {
+    lower?: number;
+    upper?: number;
+    skipna?: boolean;
+}): number[];
+  /**
+   * Compute z-scores for `source`: (x - mean) / std (ddof=1). NaNs preserved.
+   * @param source Input array
+   * @param options Optional `{ skipna? }` to ignore NaNs
+   * @returns Float64Array of z-scores
+   */
+  export function zscore(source: ArrayLike<number>, skipna?: boolean): number[];
+}
+
+export { math, ta, arr, stats };