@sipemu/anofox-forecast 0.5.0 → 0.7.6

package/anofox_forecast_js.d.ts

@@ -641,6 +641,45 @@ export class GARCHForecaster {
   readonly name: string;
 }
 
+export class HierarchyTree {
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Names of all nodes in BFS (top-down) order.
+   */
+  nodeNames(): string[];
+  /**
+   * Provide historical actuals for TopDown / MiddleOut proportions.
+   *
+   * Input: `[{name: "A", values: [...]}, ...]`.
+   */
+  setActuals(actuals: any): void;
+  /**
+   * Provide historical residuals for MinTraceShrink / MinTraceVariance.
+   */
+  setResiduals(residuals: any): void;
+  /**
+   * Build a hierarchy from parent → children edges.
+   *
+   * Expects a JS array like `[{parent: "total", children: ["A", "B"]}, ...]`.
+   * The root is inferred as the node that never appears as a child.
+   */
+  constructor(edges: any);
+  /**
+   * Reconcile base forecasts using the specified method.
+   *
+   * @param baseForecasts - `[{name: string, values: number[]}, ...]` covering every node
+   * @param method - "bottomUp" | "topDown" | "middleOut" | "minTraceOls" | "minTraceShrink" | "minTraceVariance" | "minTraceStruct"
+   * @param middleLevel - Required only for "middleOut" (default: 1)
+   * @returns Array of `{name, values}` entries in BFS order
+   */
+  reconcile(base_forecasts: any, method: string, middle_level?: number | null): any;
+  /**
+   * Number of nodes in the tree.
+   */
+  readonly len: number;
+}
+
 export class HoltForecaster {
   free(): void;
   [Symbol.dispose](): void;
@@ -741,6 +780,35 @@ export class JsBacktestResult {
   readonly coverage: number;
 }
 
+export class JsBinnedConformalPredictor {
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Fit the predictor on historical forecasts and actuals.
+   */
+  fit(forecasts: Float64Array, actuals: Float64Array): JsBinnedConformalResult;
+  /**
+   * Create a binned conformal predictor with a target coverage and
+   * number of bins.
+   */
+  constructor(coverage: number, n_bins: number);
+  /**
+   * Apply the fitted result to new point forecasts.
+   */
+  predict(result: JsBinnedConformalResult, point_forecasts: Float64Array): any;
+}
+
+export class JsBinnedConformalResult {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+  readonly binQuantiles: Float64Array;
+  readonly globalQuantile: number;
+  readonly nBins: number;
+  readonly coverage: number;
+  readonly binEdges: Float64Array;
+}
+
 export class JsBootstrapPredictor {
   free(): void;
   [Symbol.dispose](): void;
@@ -940,6 +1008,30 @@ export class JsHistoricalSimulator {
   simulate(forecasts: Float64Array, actuals: Float64Array): JsHistoricalSimResult;
 }
 
+export class JsIDRPredictor {
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Fit on historical forecasts and actuals.
+   */
+  fit(forecasts: Float64Array, actuals: Float64Array): JsIDRResult;
+  /**
+   * Create an IDR predictor with the given target quantiles.
+   */
+  constructor(quantiles: Float64Array);
+  /**
+   * Produce quantile forecasts for new point forecasts.
+   */
+  predict(result: JsIDRResult, point_forecasts: JsPointForecasts): any;
+}
+
+export class JsIDRResult {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+  readonly quantiles: Float64Array;
+}
+
 export class JsModelDiagnostics {
   private constructor();
   free(): void;
@@ -1165,6 +1257,40 @@ export class JsPredictionIntervals {
   readonly coverage: number;
 }
 
+export class JsQRAPredictor {
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Fit the predictor on a matrix of forecasts from multiple models and
+   * the corresponding actual values.
+   *
+   * @param forecastsMatrix - Vec<Vec<f64>>: rows = time, cols = models
+   * @param actuals - Actual values (length == rows of matrix)
+   */
+  fit(forecasts_matrix: any, actuals: Float64Array): JsQRAResult;
+  /**
+   * Create a QRA predictor with the given target quantiles (unregularised).
+   */
+  constructor(quantiles: Float64Array);
+  /**
+   * Create a Lasso-regularised QRA predictor.
+   */
+  static lasso(quantiles: Float64Array, lambda: number): JsQRAPredictor;
+  /**
+   * Produce quantile forecasts for a new matrix of model forecasts.
+   */
+  predict(result: JsQRAResult, forecasts_matrix: any): any;
+}
+
+export class JsQRAResult {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+  readonly hasIntercept: boolean;
+  readonly nForecasters: number;
+  readonly quantiles: Float64Array;
+}
+
 export class JsTrainedModel {
   private constructor();
   free(): void;
@@ -1308,6 +1434,119 @@ export class OptimizedThetaForecaster {
   readonly name: string;
 }
 
+export class Pipeline {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Forecast with confidence intervals.
+   */
+  predictWithIntervals(horizon: number, level: number): Forecast;
+  /**
+   * Fit the pipeline to a time series.
+   */
+  fit(series: TimeSeries): void;
+  /**
+   * Forecast `horizon` steps ahead.
+   */
+  predict(horizon: number): Forecast;
+  readonly name: string;
+}
+
+export class PipelineBuilder {
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Append a differencing transform of order `d` (typically 1 or 2).
+   */
+  difference(d: number): void;
+  /**
+   * Build with an `ARIMA(p, d, q)` inner model.
+   */
+  buildArima(p: number, d: number, q: number): Pipeline;
+  /**
+   * Build the pipeline with a `Naive` forecaster as the inner model.
+   */
+  buildNaive(): Pipeline;
+  /**
+   * Build with a `Theta` inner model.
+   */
+  buildTheta(): Pipeline;
+  /**
+   * Append a Z-score standardisation transform ((x − μ) / σ).
+   */
+  standardize(): void;
+  /**
+   * Append a Box-Cox transform with an automatically selected lambda.
+   */
+  boxCoxAuto(): void;
+  /**
+   * Build with a `SARIMA(p, d, q)(P, D, Q, period)` inner model.
+   */
+  buildSarima(p: number, d: number, q: number, seasonal_p: number, seasonal_d: number, seasonal_q: number, period: number): Pipeline;
+  /**
+   * Append a robust (median / IQR) scaling transform.
+   */
+  robustScale(): void;
+  /**
+   * Build with an `AutoETS` inner model (period is inferred at fit time).
+   */
+  buildAutoEts(): Pipeline;
+  /**
+   * Build with an `AutoARIMA` inner model.
+   */
+  buildAutoArima(): Pipeline;
+  /**
+   * Build with an `AutoTheta` inner model.
+   */
+  buildAutoTheta(): Pipeline;
+  /**
+   * Append a seasonal differencing transform with the given period.
+   */
+  seasonalDifference(period: number): void;
+  /**
+   * Build with a `SeasonalNaive(period)` inner model.
+   */
+  buildSeasonalNaive(period: number): Pipeline;
+  /**
+   * Build with a `RandomWalkWithDrift` inner model.
+   */
+  buildRandomWalkDrift(): Pipeline;
+  /**
+   * Build with an auto-fitted additive `HoltWinters` inner model.
+   */
+  buildHoltWintersAdditive(period: number): Pipeline;
+  /**
+   * Build with an auto-fitted multiplicative `HoltWinters` inner model.
+   */
+  buildHoltWintersMultiplicative(period: number): Pipeline;
+  /**
+   * Append a natural-log transform.
+   */
+  log(): void;
+  /**
+   * Create an empty pipeline builder.
+   */
+  constructor();
+  /**
+   * Append a Box-Cox transform with a fixed lambda (e.g. 0.0 = log,
+   * 1.0 = identity).
+   */
+  boxCox(lambda: number): void;
+  /**
+   * Build with an `ETS::default()` inner model.
+   */
+  buildEts(): Pipeline;
+  /**
+   * Build with a `SimpleExponentialSmoothing(alpha)` inner model.
+   */
+  buildSes(alpha: number): Pipeline;
+  /**
+   * Append a min-max normalisation transform ([0, 1]).
+   */
+  normalize(): void;
+}
+
 export class RandomWalkDriftForecaster {
   free(): void;
   [Symbol.dispose](): void;
@@ -1318,6 +1557,135 @@ export class RandomWalkDriftForecaster {
   readonly name: string;
 }
 
+export class RegressionFeatures {
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Apply regular differencing of order `d` before fitting.
+   */
+  differencing(d: number): void;
+  withEwmStd(window: number, alpha: number): void;
+  /**
+   * Add a rolling statistic with default lag = 1.
+   *
+   * `kind` ∈ "mean" | "std" | "var" | "min" | "max" | "median" | "sum" |
+   *          "ewmMean" | "ewmStd" (EWM kinds require `alpha`)
+   */
+  withRolling(window: number, kind: string, alpha?: number | null): void;
+  specificLags(lags: Uint32Array): void;
+  withEwmMean(window: number, alpha: number): void;
+  /**
+   * Add dummy seasonal encoding.
+   */
+  dummySeasonal(period: number): void;
+  withRollingMax(window: number): void;
+  withRollingMin(window: number): void;
+  withRollingStd(window: number): void;
+  withRollingSum(window: number): void;
+  withRollingVar(window: number): void;
+  /**
+   * Add changepoint features with a specific encoding.
+   *
+   * `encoding` ∈ "stepFunctions" | "regimeIndex" | "cumulativeCount"
+   */
+  withChangepoints(indices: Uint32Array, encoding: string): void;
+  withRollingMean(window: number): void;
+  /**
+   * Add a rolling statistic with an explicit lag (≥ 1).
+   */
+  withRollingLagged(window: number, lag: number, kind: string, alpha?: number | null): void;
+  withRollingMedian(window: number): void;
+  /**
+   * Add a trend component column.
+   *
+   * `trend` ∈ "linear" | "quadratic" | "cubic" | "exponential" | "theilSen"
+   */
+  withTrendComponent(trend: string): void;
+  /**
+   * Apply seasonal differencing.
+   */
+  seasonalDifferencing(d: number, period: number): void;
+  /**
+   * Add step-function changepoint indicators at the given indices.
+   */
+  withChangepointSteps(indices: Uint32Array): void;
+  /**
+   * Apply fractional differencing of order `d` ∈ (0, 1).
+   */
+  fractionalDifferencing(d: number): void;
+  /**
+   * Create default features: trend enabled, no lags, exog enabled.
+   */
+  constructor();
+  exog(): void;
+  lags(max_lag: number): void;
+  trend(): void;
+  /**
+   * Add Fourier seasonality features.
+   */
+  fourier(period: number, order: number): void;
+  noExog(): void;
+  noTrend(): void;
+  autoLags(max_lag: number): void;
+}
+
+export class RegressionForecaster {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Create an ElasticNet regression forecaster (L1+L2 regularization).
+   */
+  static elasticNet(lambda: number, alpha: number, features: RegressionFeatures): RegressionForecaster;
+  /**
+   * Forecast with confidence intervals.
+   */
+  predictWithIntervals(horizon: number, level: number): Forecast;
+  /**
+   * Create a Box-constrained least-squares forecaster.
+   *
+   * Pass `None` for either bound to leave it unconstrained.
+   */
+  static bls(lower: number | null | undefined, upper: number | null | undefined, features: RegressionFeatures): RegressionForecaster;
+  /**
+   * Fit the model on the supplied time series.
+   */
+  fit(series: TimeSeries): void;
+  /**
+   * Create an OLS regression forecaster with the given features.
+   */
+  static ols(features: RegressionFeatures): RegressionForecaster;
+  /**
+   * Create a Recursive Least Squares forecaster with a forgetting factor.
+   */
+  static rls(forgetting_factor: number, features: RegressionFeatures): RegressionForecaster;
+  /**
+   * Create a Ridge regression forecaster (L2 regularization).
+   */
+  static ridge(lambda: number, features: RegressionFeatures): RegressionForecaster;
+  /**
+   * Create a Poisson regression forecaster (count data).
+   */
+  static poisson(features: RegressionFeatures): RegressionForecaster;
+  /**
+   * Generate forecasts for `horizon` steps.
+   */
+  predict(horizon: number): Forecast;
+  /**
+   * Create a Tweedie GLM forecaster.
+   */
+  static tweedie(var_power: number, features: RegressionFeatures): RegressionForecaster;
+  /**
+   * Create a Quantile regression forecaster (τ ∈ (0, 1)).
+   */
+  static quantile(tau: number, features: RegressionFeatures): RegressionForecaster;
+  /**
+   * Create a Weighted Least Squares forecaster with exponential-decay weights.
+   */
+  static wlsDecay(decay: number, features: RegressionFeatures): RegressionForecaster;
+  readonly name: string;
+}
+
 export class SARIMAForecaster {
   free(): void;
   [Symbol.dispose](): void;
@@ -1596,6 +1964,12 @@ export class WindowAverageForecaster {
   readonly name: string;
 }
 
+export function absEnergy(values: Float64Array): number;
+
+export function absoluteMaximum(values: Float64Array): number;
+
+export function absoluteSumOfChanges(values: Float64Array): number;
+
 /**
  * Perform the Augmented Dickey-Fuller (ADF) test for unit root.
  *
@@ -1609,6 +1983,23 @@ export class WindowAverageForecaster {
  */
 export function adfTest(values: Float64Array, max_lags?: number | null): any;
 
+export function aggAutocorrelation(values: Float64Array, max_lag: number, agg_func: string): number;
+
+export function aggLinearTrend(values: Float64Array, chunk_len: number, agg_func: string, attribute: string): number;
+
+/**
+ * Automatic Identification of Demand: distribution fitting, demand type
+ * classification, and per-observation anomaly detection (stockouts,
+ * lifecycle events, outliers).
+ *
+ * @param values - Array of demand observations
+ * @param anomalyAlpha - Significance level for anomaly detection (default: 0.05)
+ * @param intermittentThreshold - Zero-proportion threshold for "intermittent" (default: 0.3)
+ * @returns Object with `summary` (demand type, distribution, params) and
+ *          `anomalies` (per-observation labels)
+ */
+export function analyzeDemand(values: Float64Array, anomaly_alpha?: number | null, intermittent_threshold?: number | null): any;
+
 /**
  * Compute the approximate entropy of a time series.
  *
@@ -1621,6 +2012,25 @@ export function adfTest(values: Float64Array, max_lags?: number | null): any;
  */
 export function approximateEntropy(values: Float64Array, m: number, r: number): number;
 
+export function arCoefficient(values: Float64Array, k: number, coeff: number): number;
+
+export function arCoefficientYuleWalker(values: Float64Array, k: number): number;
+
+export function augmentedDickeyFuller(values: Float64Array): number;
+
+/**
+ * Automatically detect changepoints with data-driven penalty selection.
+ *
+ * Uses CROPS (Changepoints for a Range of Penalties) to evaluate ~30 penalties
+ * and selects the optimal one via elbow detection.
+ *
+ * @param values - Array of numeric values
+ * @param costFunction - Cost function (default: "l2")
+ * @param minSegmentLength - Minimum segment length (default: 5)
+ * @returns Object with changepoints, penalty, and CROPS results
+ */
+export function autoDetectChangepoints(values: Float64Array, cost_function?: string | null, min_segment_length?: number | null): any;
+
 /**
  * Compute the autocorrelation of a time series at a specific lag.
  *
@@ -1640,6 +2050,19 @@ export function autocorrelation(values: Float64Array, lag: number): number;
  */
 export function backtestPostProcessor(processor: JsPostProcessor, forecasts: JsPointForecasts, actuals: Float64Array, config: JsBacktestConfig): JsBacktestResult;
 
+export function binnedEntropy(values: Float64Array, max_bins: number): number;
+
+/**
+ * Baxter-King band-pass filter — symmetric, loses `2k` observations at each edge.
+ *
+ * @param values - Array of numeric values
+ * @param lowPeriod - Lower bound of the passband in periods
+ * @param highPeriod - Upper bound of the passband in periods
+ * @param k - Half-length of the filter (default: 12 for quarterly data)
+ * @returns Object with `trend`, `cycle`, `lowPeriod`, `highPeriod`
+ */
+export function bkFilter(values: Float64Array, low_period: number, high_period: number, k?: number | null): any;
+
 /**
  * Generate a bootstrap forecast with empirical prediction intervals.
  *
@@ -1657,6 +2080,29 @@ export function backtestPostProcessor(processor: JsPostProcessor, forecasts: JsP
  */
 export function bootstrapForecast(values: Float64Array, timestamps: Float64Array | null | undefined, model_type: string, horizon: number, level: number, n_samples?: number | null): any;
 
+export function c3(values: Float64Array, lag: number): number;
+
+/**
+ * Christiano-Fitzgerald band-pass filter — asymmetric, preserves series length.
+ *
+ * @param values - Array of numeric values
+ * @param lowPeriod - Lower bound of the passband in periods (e.g., 6 quarters)
+ * @param highPeriod - Upper bound of the passband in periods (e.g., 32 quarters)
+ * @param drift - If `true`, remove linear drift before filtering (default: true)
+ * @returns Object with `trend`, `cycle`, `lowPeriod`, `highPeriod`
+ */
+export function cfFilter(values: Float64Array, low_period: number, high_period: number, drift?: boolean | null): any;
+
+export function cidCe(values: Float64Array, normalize: boolean): number;
+
+export function countAbove(values: Float64Array, threshold: number): number;
+
+export function countAboveMean(values: Float64Array): number;
+
+export function countBelow(values: Float64Array, threshold: number): number;
+
+export function countBelowMean(values: Float64Array): number;
+
 /**
  * Perform time series cross-validation with expanding window.
  *
@@ -1698,6 +2144,29 @@ export function detectChangepoints(values: Float64Array, penalty: number, cost_f
  */
 export function detectChangepointsBic(values: Float64Array, cost_function?: string | null): any;
 
+/**
+ * Detect the dominant seasonal period in a time series.
+ *
+ * @param values - Array of numeric values
+ * @returns The detected period, or `undefined` if no strong period is found
+ */
+export function detectDominantPeriod(values: Float64Array): number | undefined;
+
+/**
+ * Detect outliers in a time series.
+ *
+ * @param values - Array of numeric values
+ * @param method - "iqr" (default), "zScore", or "modifiedZScore"
+ * @param threshold - Method-specific threshold (default: 1.5 IQR / 3.0 Z / 3.5 MZ)
+ * @returns Object with `outlierIndices`, `scores`, `threshold`, `method`, `nOutliers`, `outlierPercentage`
+ */
+export function detectOutliers(values: Float64Array, method?: string | null, threshold?: number | null): any;
+
+/**
+ * Detect outliers with default configuration (IQR method, 1.5 multiplier).
+ */
+export function detectOutliersAuto(values: Float64Array): any;
+
 /**
  * Run comprehensive residual diagnostics.
  *
@@ -1723,6 +2192,36 @@ export function diagnoseResiduals(residuals: Float64Array, fitted_params?: numbe
  */
 export function durbinWatson(residuals: Float64Array): any;
 
+export function energyRatioByChunks(values: Float64Array, n_chunks: number, chunk_index: number): number;
+
+/**
+ * Find the minimum fractional differencing order `d` that makes the series
+ * stationary according to the Augmented Dickey-Fuller test.
+ *
+ * @param values - Array of numeric values
+ * @param significance - ADF p-value threshold (default: 0.05)
+ * @param threshold - Weight truncation threshold for the inner differencing (default: 1e-4)
+ * @returns Object with `d` (the minimum differencing order) and `pValue` (the ADF p-value at that d)
+ */
+export function findMinFractionalD(values: Float64Array, significance?: number | null, threshold?: number | null): any;
+
+export function firstLocationOfMaximum(values: Float64Array): number;
+
+export function firstLocationOfMinimum(values: Float64Array): number;
+
+export function fourierEntropy(values: Float64Array): number;
+
+/**
+ * Fractional differencing — removes just enough memory to achieve
+ * stationarity while preserving predictive signal.
+ *
+ * @param values - Array of numeric values
+ * @param d - Differencing order, typically `0 < d < 1`
+ * @param threshold - Weight truncation threshold (default: 1e-4)
+ * @returns Array of differenced values (shorter than input)
+ */
+export function fractionalDifference(values: Float64Array, d: number, threshold?: number | null): Float64Array;
+
 /**
  * Generate future timestamps starting after a given last timestamp.
  *
@@ -1734,6 +2233,77 @@ export function durbinWatson(residuals: Float64Array): any;
  */
 export function generateFutureTimestamps(last_timestamp_ms: number, frequency: string, horizon: number): Float64Array;
 
+/**
+ * Fit a GlobalAutoETS model: automatic model selection across many series.
+ *
+ * @param series - Array of arrays (each inner array is one series)
+ * @param period - Seasonal period
+ * @param horizon - Forecast horizon
+ * @param pool - Model pool: "complete", "reduced", "dampedTrendOnly", "matchErrorSeasonal" (default: "complete")
+ * @returns Object with forecasts and selectedSpecs arrays
+ */
+export function globalAutoEts(series: any, period: number, horizon: number, pool?: string | null): any;
+
+/**
+ * Fit a GlobalCroston model: shared α across many intermittent demand series.
+ *
+ * @param series - Array of arrays (each inner array is one series)
+ * @param horizon - Forecast horizon
+ * @param variant - "classic" or "sba" (default: "classic")
+ * @returns Object with forecasts array and alpha
+ */
+export function globalCroston(series: any, horizon: number, variant?: string | null): any;
+
+/**
+ * Fit a GlobalETS model: shared smoothing parameters across many series.
+ *
+ * @param series - Array of arrays (each inner array is one series)
+ * @param spec - ETS specification string (e.g., "ANA", "AAdA", "MNM")
+ * @param period - Seasonal period
+ * @param horizon - Forecast horizon
+ * @returns Object with forecasts array and fitted parameters
+ */
+export function globalEts(series: any, spec: string, period: number, horizon: number): any;
+
+/**
+ * Fit a GlobalTheta model: shared α for the Standard Theta Method across
+ * many series.
+ *
+ * @param series - Array of arrays (each inner array is one series)
+ * @param horizon - Forecast horizon
+ * @returns Object with forecasts array and shared alpha
+ */
+export function globalTheta(series: any, horizon: number): any;
+
+/**
+ * Hamilton filter — regression-based trend-cycle decomposition that avoids
+ * the HP filter's endpoint bias.
+ *
+ * @param values - Array of numeric values
+ * @param h - Forecast horizon used in the regression (default: 8)
+ * @param p - Number of lags in the regression (default: 4)
+ * @returns Object with `trend`, `cycle`, `h`, `p`
+ */
+export function hamiltonFilter(values: Float64Array, h?: number | null, p?: number | null): any;
+
+export function hasDuplicate(values: Float64Array): boolean;
+
+export function hasDuplicateMax(values: Float64Array): boolean;
+
+export function hasDuplicateMin(values: Float64Array): boolean;
+
+/**
+ * Apply the Hodrick-Prescott filter to a series.
+ *
+ * @param values - Array of numeric values
+ * @param lambda - Smoothing parameter (default: 1600 for quarterly data).
+ *                 Common values: 1600 (quarterly), 129600 (monthly), 6.25 (annual).
+ * @returns Object with `trend`, `cycle`, `lambda`
+ */
+export function hpFilter(values: Float64Array, lambda?: number | null): any;
+
+export function indexMassQuantile(values: Float64Array, q: number): number;
+
 /**
  * Initialize the WASM module.
  *
@@ -1741,6 +2311,31 @@ export function generateFutureTimestamps(last_timestamp_ms: number, frequency: s
  */
 export function init(): void;
 
+/**
+ * Intermittent demand diagnostics: Syntetos-Boylan classification +
+ * recommended model.
+ *
+ * @param actuals - Actual demand values
+ * @returns Object with `adi`, `cvSquared`, `classification`, `recommendedModel`, `zeroFraction`
+ */
+export function intermittentDiagnostics(actuals: Float64Array): any;
+
+/**
+ * Intermittent demand diagnostics with a forecast — adds bias and
+ * periods-in-stock tracking.
+ *
+ * @param actuals - Actual demand values
+ * @param forecast - Forecast values (length ≤ actuals)
+ * @returns Object with full diagnostics including `bias` and `periodsInStock`
+ */
+export function intermittentDiagnosticsWithForecast(actuals: Float64Array, forecast: Float64Array): any;
+
+/**
+ * Intermittent diagnostics with a forecast and prediction intervals —
+ * additionally computes coverage rate.
+ */
+export function intermittentDiagnosticsWithIntervals(actuals: Float64Array, forecast: Float64Array, lower: Float64Array, upper: Float64Array): any;
+
 /**
  * Perform the Jarque-Bera test for normality of residuals.
  *
@@ -1780,6 +2375,16 @@ export function kpssTest(values: Float64Array, lags?: number | null): any;
  */
 export function kurtosis(values: Float64Array): number;
 
+export function largeStandardDeviation(values: Float64Array, r: number): boolean;
+
+export function lastLocationOfMaximum(values: Float64Array): number;
+
+export function lastLocationOfMinimum(values: Float64Array): number;
+
+export function lempelZivComplexity(values: Float64Array, bins: number): number;
+
+export function lempelZivComplexityBinary(values: Float64Array): number;
+
 /**
  * Perform the Ljung-Box test for autocorrelation in residuals.
  *
@@ -1793,6 +2398,12 @@ export function kurtosis(values: Float64Array): number;
  */
 export function ljungBox(residuals: Float64Array, lags?: number | null, fitted_params?: number | null): any;
 
+export function longestStrikeAboveMean(values: Float64Array): number;
+
+export function longestStrikeBelowMean(values: Float64Array): number;
+
+export function maximum(values: Float64Array): number;
+
 /**
  * Compute the arithmetic mean of a time series.
  *
@@ -1801,6 +2412,37 @@ export function ljungBox(residuals: Float64Array, lags?: number | null, fitted_p
  */
 export function mean(values: Float64Array): number;
 
+export function meanAbsChange(values: Float64Array): number;
+
+export function meanChange(values: Float64Array): number;
+
+export function meanNAbsoluteMax(values: Float64Array, n: number): number;
+
+export function meanSecondDerivativeCentral(values: Float64Array): number;
+
+export function median(values: Float64Array): number;
+
+export function minimum(values: Float64Array): number;
+
+/**
+ * Run sequential CUSUM monitoring on a vector of forecast errors.
+ *
+ * Returns an object containing the full detector state. Pass it back to
+ * [`updateForecastMonitor`] (alongside any new errors) to continue
+ * monitoring without recomputing the training window.
+ *
+ * @param errors - Vector of forecast errors (residuals)
+ * @param m - Length of training window (must satisfy 2 ≤ m < errors.length)
+ * @param detector - Detector variant: `"pageCusum"` (default), `"pageCusum1"`, `"cusum"`, `"cusum1"`
+ * @param errorType - Error transformation: `"both"` (default), `"raw"`, `"squared"`
+ * @param gamma - Weight tuning parameter, `0 ≤ γ < 0.5` (default: `0`)
+ * @param alpha - Nominal type-I error rate (default: `0.05`)
+ * @param sigma2 - Optional override for the training-window variance
+ * @param critValue - Optional fixed critical value (skips lookup/simulation)
+ * @returns Detector state object with `tau`, `tauSquared`, `cusum`, `threshold`, etc.
+ */
+export function monitorForecastErrors(errors: Float64Array, m: number, detector?: string | null, error_type?: string | null, gamma?: number | null, alpha?: number | null, sigma2?: number | null, crit_value?: number | null): any;
+
 /**
  * Perform MSTL (Multiple Seasonal-Trend decomposition using LOESS).
  *
@@ -1813,6 +2455,10 @@ export function mean(values: Float64Array): number;
  */
 export function mstlDecompose(values: Float64Array, periods: Uint32Array): any;
 
+export function numberCrossingM(values: Float64Array, m: number): number;
+
+export function numberPeaks(values: Float64Array, support: number): number;
+
 /**
  * Compute the partial autocorrelation of a time series at a specific lag.
  *
@@ -1824,6 +2470,42 @@ export function mstlDecompose(values: Float64Array, periods: Uint32Array): any;
  */
 export function partialAutocorrelation(values: Float64Array, lag: number): number;
 
+export function percentageOfReoccurringDatapointsToAllDatapoints(values: Float64Array): number;
+
+export function percentageOfReoccurringValuesToAllValues(values: Float64Array): number;
+
+export function permutationEntropy(values: Float64Array, order: number, delay: number): number;
+
+export function permutationEntropyNormalized(values: Float64Array, order: number, delay: number): number;
+
+export function quantile(values: Float64Array, q: number): number;
+
+export function rangeCount(values: Float64Array, min: number, max: number): number;
+
+export function ratioBeyondRSigma(values: Float64Array, r: number): number;
+
+export function ratioValueNumberToTimeSeriesLength(values: Float64Array): number;
+
+/**
+ * Walk-forward rolling / expanding window forecast evaluation.
+ *
+ * Trains a model on a historical window, forecasts `horizon` steps,
+ * records predictions vs actuals, advances the origin by `stepSize`, and
+ * repeats. Produces realistic out-of-sample accuracy estimates.
+ *
+ * @param values - Array of numeric values
+ * @param timestamps - Optional array of timestamps as milliseconds since epoch
+ * @param modelType - Model type: "naive", "ses", "holt", "autoarima", "autoets", "autotheta", "sma<N>"
+ * @param initialTrainSize - Size of the first training window
+ * @param horizon - Number of steps to forecast at each origin
+ * @param stepSize - Steps between successive origins (default: `horizon`)
+ * @param expanding - `true` for expanding window (default), `false` for rolling window
+ * @returns Object with `allPredictions`, `allActuals`, `nWindows`, `mae`, `rmse`, `mape`, `smape`
+ */
+export function rollingForecast(values: Float64Array, timestamps: Float64Array | null | undefined, model_type: string, initial_train_size: number, horizon: number, step_size?: number | null, expanding?: boolean | null): any;
+
+export function rootMeanSquare(values: Float64Array): number;
+
 /**
  * Compute the sample entropy of a time series.
  *
@@ -1847,6 +2529,8 @@ export function sampleEntropy(values: Float64Array, m: number, r: number): numbe
  */
 export function skewness(values: Float64Array): number;
 
+export function standardDeviation(values: Float64Array): number;
+
 /**
  * Perform STL (Seasonal-Trend decomposition using LOESS).
  *
@@ -1859,6 +2543,32 @@ export function skewness(values: Float64Array): number;
  */
 export function stlDecompose(values: Float64Array, period: number, robust?: boolean | null): any;
 
+export function sumOfReoccurringDataPoints(values: Float64Array): number;
+
+export function sumOfReoccurringValues(values: Float64Array): number;
+
+export function sumValues(values: Float64Array): number;
+
+export function symmetryLooking(values: Float64Array, r: number): boolean;
+
+export function timeReversalAsymmetryStatistic(values: Float64Array, lag: number): number;
+
+/**
+ * Continue monitoring with new errors using a previously returned state.
+ *
+ * Pass the `state` object exactly as returned from
+ * [`monitorForecastErrors`] (or a previous `updateForecastMonitor` call).
+ * The new errors are processed in order, the CUSUM stream is extended, and
+ * the updated state is returned.
+ *
+ * @param state - Detector state from a previous call
+ * @param newErrors - Additional forecast errors to monitor
+ * @returns Updated detector state object
+ */
+export function updateForecastMonitor(state: any, new_errors: Float64Array): any;
+
+export function valueCount(values: Float64Array, value: number): number;
+
 /**
  * Compute the population variance of a time series.
  *
@@ -1869,11 +2579,27 @@ export function stlDecompose(values: Float64Array, period: number, robust?: bool
  */
 export function variance(values: Float64Array): number;
 
+export function varianceLargerThanStandardDeviation(values: Float64Array): boolean;
+
+export function varianceSample(values: Float64Array): number;
+
+export function variationCoefficient(values: Float64Array): number;
+
 /**
  * Get the library version.
  */
 export function version(): string;
 
+/**
+ * Welch's periodogram for spectral density estimation.
+ *
+ * @param values - Array of numeric values
+ * @param windowSize - Window size for the segmented FFT
+ * @param overlap - Fractional overlap between windows in [0, 1) (default: 0.5)
+ * @returns Array of {period, power} entries sorted by frequency
+ */
+export function welchPeriodogram(values: Float64Array, window_size: number, overlap?: number | null): any;
+
 export type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembly.Module;
 
 export interface InitOutput {
@@ -1895,23 +2621,28 @@ export interface InitOutput {
   readonly __wbg_featuregenerator_free: (a: number, b: number) => void;
   readonly __wbg_forecast_free: (a: number, b: number) => void;
   readonly __wbg_garchforecaster_free: (a: number, b: number) => void;
+  readonly __wbg_hierarchytree_free: (a: number, b: number) => void;
   readonly __wbg_holtforecaster_free: (a: number, b: number) => void;
   readonly __wbg_holtwintersforecaster_free: (a: number, b: number) => void;
   readonly __wbg_imapaforecaster_free: (a: number, b: number) => void;
   readonly __wbg_jsbacktestconfig_free: (a: number, b: number) => void;
   readonly __wbg_jsbacktestresult_free: (a: number, b: number) => void;
+  readonly __wbg_jsbinnedconformalpredictor_free: (a: number, b: number) => void;
+  readonly __wbg_jsbinnedconformalresult_free: (a: number, b: number) => void;
   readonly __wbg_jsbootstrappredictor_free: (a: number, b: number) => void;
   readonly __wbg_jsbootstrapresult_free: (a: number, b: number) => void;
   readonly __wbg_jsconformalpredictor_free: (a: number, b: number) => void;
   readonly __wbg_jshistoricalsimresult_free: (a: number, b: number) => void;
   readonly __wbg_jshistoricalsimulator_free: (a: number, b: number) => void;
+  readonly __wbg_jsidrpredictor_free: (a: number, b: number) => void;
+  readonly __wbg_jsidrresult_free: (a: number, b: number) => void;
   readonly __wbg_jsmodeldiagnostics_free: (a: number, b: number) => void;
-  readonly __wbg_jsnormalpredictor_free: (a: number, b: number) => void;
-  readonly __wbg_jsnormalresult_free: (a: number, b: number) => void;
   readonly __wbg_jsperstepconformalresult_free: (a: number, b: number) => void;
   readonly __wbg_jspointforecasts_free: (a: number, b: number) => void;
   readonly __wbg_jspostprocessor_free: (a: number, b: number) => void;
   readonly __wbg_jspredictionintervals_free: (a: number, b: number) => void;
+  readonly __wbg_jsqrapredictor_free: (a: number, b: number) => void;
+  readonly __wbg_jsqraresult_free: (a: number, b: number) => void;
   readonly __wbg_jstrainedmodel_free: (a: number, b: number) => void;
   readonly __wbg_kalmanforecaster_free: (a: number, b: number) => void;
   readonly __wbg_meanforecaster_free: (a: number, b: number) => void;
@@ -1919,7 +2650,11 @@ export interface InitOutput {
   readonly __wbg_mstlforecasterwrapper_free: (a: number, b: number) => void;
   readonly __wbg_naiveforecaster_free: (a: number, b: number) => void;
   readonly __wbg_optimizedthetaforecaster_free: (a: number, b: number) => void;
+  readonly __wbg_pipeline_free: (a: number, b: number) => void;
+  readonly __wbg_pipelinebuilder_free: (a: number, b: number) => void;
   readonly __wbg_randomwalkdriftforecaster_free: (a: number, b: number) => void;
+  readonly __wbg_regressionfeatures_free: (a: number, b: number) => void;
+  readonly __wbg_regressionforecaster_free: (a: number, b: number) => void;
   readonly __wbg_sarimaforecaster_free: (a: number, b: number) => void;
   readonly __wbg_seasonalesforecaster_free: (a: number, b: number) => void;
   readonly __wbg_seasonalnaiveforecaster_free: (a: number, b: number) => void;
@@ -1929,18 +2664,28 @@ export interface InitOutput {
   readonly __wbg_thetaforecaster_free: (a: number, b: number) => void;
   readonly __wbg_timeseries_free: (a: number, b: number) => void;
   readonly __wbg_varforecaster_free: (a: number, b: number) => void;
+  readonly absEnergy: (a: number, b: number) => number;
+  readonly absoluteMaximum: (a: number, b: number) => number;
+  readonly absoluteSumOfChanges: (a: number, b: number) => number;
   readonly adfTest: (a: number, b: number, c: number) => [number, number, number];
   readonly adidaforecaster_fit: (a: number, b: number) => [number, number];
   readonly adidaforecaster_name: (a: number) => [number, number];
   readonly adidaforecaster_new: () => number;
   readonly adidaforecaster_predict: (a: number, b: number) => [number, number, number];
   readonly adidaforecaster_predictWithIntervals: (a: number, b: number, c: number) => [number, number, number];
+  readonly aggAutocorrelation: (a: number, b: number, c: number, d: number, e: number) => number;
+  readonly aggLinearTrend: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => number;
+  readonly analyzeDemand: (a: number, b: number, c: number, d: number, e: number, f: number) => [number, number, number];
   readonly approximateEntropy: (a: number, b: number, c: number, d: number) => number;
+  readonly arCoefficient: (a: number, b: number, c: number, d: number) => number;
+  readonly arCoefficientYuleWalker: (a: number, b: number, c: number) => number;
   readonly arimaforecaster_fit: (a: number, b: number) => [number, number];
   readonly arimaforecaster_name: (a: number) => [number, number];
   readonly arimaforecaster_new: (a: number, b: number, c: number) => number;
   readonly arimaforecaster_predict: (a: number, b: number) => [number, number, number];
   readonly arimaforecaster_predictWithIntervals: (a: number, b: number, c: number) => [number, number, number];
+  readonly augmentedDickeyFuller: (a: number, b: number) => number;
+  readonly autoDetectChangepoints: (a: number, b: number, c: number, d: number, e: number) => [number, number, number];
   readonly autoarimaforecaster_fit: (a: number, b: number) => [number, number];
   readonly autoarimaforecaster_name: (a: number) => [number, number];
   readonly autoarimaforecaster_new: () => number;
@@ -1988,7 +2733,10 @@ export interface InitOutput {
   readonly autothetaforecaster_predict: (a: number, b: number) => [number, number, number];
   readonly autothetaforecaster_predictWithIntervals: (a: number, b: number, c: number) => [number, number, number];
   readonly backtestPostProcessor: (a: number, b: number, c: number, d: number, e: number) => [number, number, number];
+  readonly binnedEntropy: (a: number, b: number, c: number) => number;
+  readonly bkFilter: (a: number, b: number, c: number, d: number, e: number) => [number, number, number];
   readonly bootstrapForecast: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number) => [number, number, number];
+  readonly c3: (a: number, b: number, c: number) => number;
   readonly calendarannotations_addHoliday: (a: number, b: number) => void;
   readonly calendarannotations_addRegressor: (a: number, b: number, c: number, d: number, e: number) => void;
   readonly calendarannotations_fromJSON: (a: number, b: number) => [number, number, number];
@@ -2003,6 +2751,12 @@ export interface InitOutput {
   readonly calendarannotations_regressorNames: (a: number) => [number, number, number];
   readonly calendarannotations_setHolidays: (a: number, b: number, c: number) => void;
   readonly calendarannotations_toJSON: (a: number) => [number, number, number, number];
+  readonly cfFilter: (a: number, b: number, c: number, d: number, e: number) => [number, number, number];
+  readonly cidCe: (a: number, b: number, c: number) => number;
+  readonly countAbove: (a: number, b: number, c: number) => number;
+  readonly countAboveMean: (a: number, b: number) => number;
+  readonly countBelow: (a: number, b: number, c: number) => number;
+  readonly countBelowMean: (a: number, b: number) => number;
   readonly crossValidate: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number) => [number, number, number];
   readonly crostonforecaster_fit: (a: number, b: number) => [number, number];
   readonly crostonforecaster_name: (a: number) => [number, number];
@@ -2011,6 +2765,9 @@ export interface InitOutput {
   readonly crostonforecaster_predictWithIntervals: (a: number, b: number, c: number) => [number, number, number];
   readonly detectChangepoints: (a: number, b: number, c: number, d: number, e: number, f: number) => [number, number, number];
   readonly detectChangepointsBic: (a: number, b: number, c: number, d: number) => [number, number, number];
+  readonly detectDominantPeriod: (a: number, b: number) => number;
+  readonly detectOutliers: (a: number, b: number, c: number, d: number, e: number, f: number) => [number, number, number];
+  readonly detectOutliersAuto: (a: number, b: number) => [number, number, number];
   readonly diagnoseResiduals: (a: number, b: number, c: number) => [number, number, number];
   readonly durbinWatson: (a: number, b: number) => [number, number, number];
   readonly dynamicthetaforecaster_fit: (a: number, b: number) => [number, number];
@@ -2020,6 +2777,7 @@ export interface InitOutput {
   readonly dynamicthetaforecaster_predict: (a: number, b: number) => [number, number, number];
   readonly dynamicthetaforecaster_predictWithIntervals: (a: number, b: number, c: number) => [number, number, number];
   readonly dynamicthetaforecaster_seasonal: (a: number) => number;
+  readonly energyRatioByChunks: (a: number, b: number, c: number, d: number) => number;
   readonly ensembleforecaster_fit: (a: number, b: number) => [number, number];
   readonly ensembleforecaster_modelCount: (a: number) => number;
   readonly ensembleforecaster_name: (a: number) => [number, number];
@@ -2049,6 +2807,9 @@ export interface InitOutput {
   readonly featuregenerator_monthOfYear: (a: number) => void;
   readonly featuregenerator_new: () => number;
   readonly featuregenerator_quarter: (a: number) => void;
+  readonly findMinFractionalD: (a: number, b: number, c: number, d: number, e: number, f: number) => [number, number, number];
+  readonly firstLocationOfMaximum: (a: number, b: number) => number;
+  readonly firstLocationOfMinimum: (a: number, b: number) => number;
   readonly forecast_clamp: (a: number, b: number, c: number) => number;
   readonly forecast_hasLower: (a: number) => number;
   readonly forecast_hasUpper: (a: number) => number;
@@ -2058,12 +2819,28 @@ export interface InitOutput {
   readonly forecast_roundToInteger: (a: number) => number;
   readonly forecast_upper: (a: number) => [number, number];
   readonly forecast_values: (a: number) => [number, number];
+  readonly fourierEntropy: (a: number, b: number) => number;
+  readonly fractionalDifference: (a: number, b: number, c: number, d: number, e: number) => [number, number];
   readonly garchforecaster_fit: (a: number, b: number) => [number, number];
   readonly garchforecaster_name: (a: number) => [number, number];
   readonly garchforecaster_new: (a: number, b: number) => number;
   readonly garchforecaster_predict: (a: number, b: number) => [number, number, number];
   readonly garchforecaster_predictWithIntervals: (a: number, b: number, c: number) => [number, number, number];
   readonly generateFutureTimestamps: (a: number, b: number, c: number, d: number) => [number, number, number, number];
+  readonly globalAutoEts: (a: any, b: number, c: number, d: number, e: number) => [number, number, number];
+  readonly globalCroston: (a: any, b: number, c: number, d: number) => [number, number, number];
+  readonly globalEts: (a: any, b: number, c: number, d: number, e: number) => [number, number, number];
+  readonly globalTheta: (a: any, b: number) => [number, number, number];
+  readonly hamiltonFilter: (a: number, b: number, c: number, d: number) => [number, number, number];
+  readonly hasDuplicate: (a: number, b: number) => number;
+  readonly hasDuplicateMax: (a: number, b: number) => number;
+  readonly hasDuplicateMin: (a: number, b: number) => number;
+  readonly hierarchytree_len: (a: number) => number;
+  readonly hierarchytree_new: (a: any) => [number, number, number];
+  readonly hierarchytree_nodeNames: (a: number) => [number, number];
+  readonly hierarchytree_reconcile: (a: number, b: any, c: number, d: number, e: number) => [number, number, number];
+  readonly hierarchytree_setActuals: (a: number, b: any) => [number, number];
+  readonly hierarchytree_setResiduals: (a: number, b: any) => [number, number];
   readonly holtforecaster_fit: (a: number, b: number) => [number, number];
   readonly holtforecaster_name: (a: number) => [number, number];
   readonly holtforecaster_new: (a: number, b: number) => number;
@@ -2076,12 +2853,17 @@ export interface InitOutput {
   readonly holtwintersforecaster_new: (a: number, b: number, c: number, d: number) => number;
   readonly holtwintersforecaster_predict: (a: number, b: number) => [number, number, number];
   readonly holtwintersforecaster_predictWithIntervals: (a: number, b: number, c: number) => [number, number, number];
+  readonly hpFilter: (a: number, b: number, c: number, d: number) => [number, number, number];
   readonly imapaforecaster_fit: (a: number, b: number) => [number, number];
   readonly imapaforecaster_name: (a: number) => [number, number];
   readonly imapaforecaster_new: () => number;
   readonly imapaforecaster_predict: (a: number, b: number) => [number, number, number];
   readonly imapaforecaster_predictWithIntervals: (a: number, b: number, c: number) => [number, number, number];
+  readonly indexMassQuantile: (a: number, b: number, c: number) => number;
   readonly init: () => void;
+  readonly intermittentDiagnostics: (a: number, b: number) => [number, number, number];
+  readonly intermittentDiagnosticsWithForecast: (a: number, b: number, c: number, d: number) => [number, number, number];
+  readonly intermittentDiagnosticsWithIntervals: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number) => [number, number, number];
   readonly jarqueBera: (a: number, b: number) => [number, number, number];
   readonly jsbacktestconfig_expanding: (a: number, b: number) => number;
   readonly jsbacktestconfig_horizon: (a: number, b: number) => number;
@@ -2092,6 +2874,14 @@ export interface InitOutput {
   readonly jsbacktestresult_coverage: (a: number) => number;
   readonly jsbacktestresult_intervalWidths: (a: number) => number;
   readonly jsbacktestresult_numFolds: (a: number) => number;
+  readonly jsbinnedconformalpredictor_fit: (a: number, b: number, c: number, d: number, e: number) => [number, number, number];
+  readonly jsbinnedconformalpredictor_new: (a: number, b: number) => number;
+  readonly jsbinnedconformalpredictor_predict: (a: number, b: number, c: number, d: number) => [number, number, number];
+  readonly jsbinnedconformalresult_binEdges: (a: number) => [number, number];
+  readonly jsbinnedconformalresult_binQuantiles: (a: number) => [number, number];
+  readonly jsbinnedconformalresult_coverage: (a: number) => number;
+  readonly jsbinnedconformalresult_globalQuantile: (a: number) => number;
+  readonly jsbinnedconformalresult_nBins: (a: number) => number;
   readonly jsbootstrappredictor_blockSize: (a: number, b: number) => number;
   readonly jsbootstrappredictor_fit: (a: number, b: number, c: number, d: number, e: number) => [number, number, number];
   readonly jsbootstrappredictor_nReplicates: (a: number, b: number) => number;
@@ -2116,10 +2906,12 @@ export interface InitOutput {
   readonly jshistoricalsimulator_predictIntervals: (a: number, b: number, c: number, d: number) => [number, number, number];
   readonly jshistoricalsimulator_simulate: (a: number, b: number, c: number, d: number, e: number) => [number, number, number];
   readonly jshistoricalsimulator_withWindow: (a: number, b: number, c: number) => number;
+  readonly jsidrpredictor_fit: (a: number, b: number, c: number, d: number, e: number) => [number, number, number];
+  readonly jsidrpredictor_new: (a: number, b: number) => number;
+  readonly jsidrpredictor_predict: (a: number, b: number, c: number) => [number, number, number];
+  readonly jsidrresult_quantiles: (a: number) => [number, number];
   readonly jsmodeldiagnostics_fromResiduals: (a: number, b: number, c: number) => number;
-  readonly jsmodeldiagnostics_jarqueBeraStatistic: (a: number) => number;
   readonly jsmodeldiagnostics_ljungBoxLags: (a: number) => number;
-  readonly jsmodeldiagnostics_ljungBoxPvalue: (a: number) => number;
   readonly jsmodeldiagnostics_passesAll: (a: number) => number;
   readonly jsmodeldiagnostics_residualAcf: (a: number) => [number, number];
   readonly jsmodeldiagnostics_residualMean: (a: number) => number;
@@ -2148,6 +2940,13 @@ export interface InitOutput {
   readonly jspredictionintervals_midpoints: (a: number) => [number, number];
   readonly jspredictionintervals_upper: (a: number) => [number, number];
   readonly jspredictionintervals_widths: (a: number) => [number, number];
+  readonly jsqrapredictor_fit: (a: number, b: any, c: number, d: number) => [number, number, number];
+  readonly jsqrapredictor_lasso: (a: number, b: number, c: number) => number;
+  readonly jsqrapredictor_new: (a: number, b: number) => number;
+  readonly jsqrapredictor_predict: (a: number, b: number, c: any) => [number, number, number];
+  readonly jsqraresult_hasIntercept: (a: number) => number;
+  readonly jsqraresult_nForecasters: (a: number) => number;
+  readonly jsqraresult_quantiles: (a: number) => [number, number];
   readonly kalmanforecaster_custom: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number) => [number, number, number];
   readonly kalmanforecaster_fit: (a: number, b: number) => [number, number];
   readonly kalmanforecaster_localLevel: (a: number, b: number) => number;
@@ -2161,18 +2960,33 @@ export interface InitOutput {
   readonly kalmanforecaster_smooth: (a: number, b: number) => [number, number, number, number];
   readonly kpssTest: (a: number, b: number, c: number) => [number, number, number];
   readonly kurtosis: (a: number, b: number) => number;
+  readonly largeStandardDeviation: (a: number, b: number, c: number) => number;
+  readonly lastLocationOfMaximum: (a: number, b: number) => number;
+  readonly lastLocationOfMinimum: (a: number, b: number) => number;
+  readonly lempelZivComplexity: (a: number, b: number, c: number) => number;
+  readonly lempelZivComplexityBinary: (a: number, b: number) => number;
   readonly ljungBox: (a: number, b: number, c: number, d: number) => [number, number, number];
+  readonly longestStrikeAboveMean: (a: number, b: number) => number;
+  readonly longestStrikeBelowMean: (a: number, b: number) => number;
+  readonly maximum: (a: number, b: number) => number;
   readonly mean: (a: number, b: number) => number;
+  readonly meanAbsChange: (a: number, b: number) => number;
+  readonly meanChange: (a: number, b: number) => number;
+  readonly meanNAbsoluteMax: (a: number, b: number, c: number) => number;
+  readonly meanSecondDerivativeCentral: (a: number, b: number) => number;
   readonly meanforecaster_fit: (a: number, b: number) => [number, number];
   readonly meanforecaster_name: (a: number) => [number, number];
   readonly meanforecaster_new: () => number;
   readonly meanforecaster_predict: (a: number, b: number) => [number, number, number];
   readonly meanforecaster_predictWithIntervals: (a: number, b: number, c: number) => [number, number, number];
+  readonly median: (a: number, b: number) => number;
   readonly mflesforecaster_fit: (a: number, b: number) => [number, number];
   readonly mflesforecaster_name: (a: number) => [number, number];
   readonly mflesforecaster_new: (a: number, b: number) => number;
   readonly mflesforecaster_predict: (a: number, b: number) => [number, number, number];
   readonly mflesforecaster_predictWithIntervals: (a: number, b: number, c: number) => [number, number, number];
+  readonly minimum: (a: number, b: number) => number;
+  readonly monitorForecastErrors: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number, k: number, l: number, m: number, n: number, o: number) => [number, number, number];
   readonly mstlDecompose: (a: number, b: number, c: number, d: number) => [number, number, number];
   readonly mstlforecasterwrapper_fit: (a: number, b: number) => [number, number];
   readonly mstlforecasterwrapper_name: (a: number) => [number, number];
@@ -2183,17 +2997,94 @@ export interface InitOutput {
   readonly naiveforecaster_new: () => number;
   readonly naiveforecaster_predict: (a: number, b: number) => [number, number, number];
   readonly naiveforecaster_predictWithIntervals: (a: number, b: number, c: number) => [number, number, number];
+  readonly numberCrossingM: (a: number, b: number, c: number) => number;
+  readonly numberPeaks: (a: number, b: number, c: number) => number;
   readonly optimizedthetaforecaster_fit: (a: number, b: number) => [number, number];
   readonly optimizedthetaforecaster_name: (a: number) => [number, number];
   readonly optimizedthetaforecaster_new: () => number;
   readonly optimizedthetaforecaster_predict: (a: number, b: number) => [number, number, number];
   readonly optimizedthetaforecaster_predictWithIntervals: (a: number, b: number, c: number) => [number, number, number];
   readonly partialAutocorrelation: (a: number, b: number, c: number) => number;
+  readonly percentageOfReoccurringDatapointsToAllDatapoints: (a: number, b: number) => number;
+  readonly percentageOfReoccurringValuesToAllValues: (a: number, b: number) => number;
+  readonly permutationEntropy: (a: number, b: number, c: number, d: number) => number;
+  readonly permutationEntropyNormalized: (a: number, b: number, c: number, d: number) => number;
+  readonly pipeline_fit: (a: number, b: number) => [number, number];
+  readonly pipeline_name: (a: number) => [number, number];
+  readonly pipeline_predict: (a: number, b: number) => [number, number, number];
+  readonly pipeline_predictWithIntervals: (a: number, b: number, c: number) => [number, number, number];
+  readonly pipelinebuilder_boxCox: (a: number, b: number) => void;
+  readonly pipelinebuilder_boxCoxAuto: (a: number) => void;
+  readonly pipelinebuilder_buildArima: (a: number, b: number, c: number, d: number) => number;
+  readonly pipelinebuilder_buildAutoArima: (a: number) => number;
+  readonly pipelinebuilder_buildAutoEts: (a: number) => number;
+  readonly pipelinebuilder_buildAutoTheta: (a: number) => number;
+  readonly pipelinebuilder_buildEts: (a: number) => number;
+  readonly pipelinebuilder_buildHoltWintersAdditive: (a: number, b: number) => number;
+  readonly pipelinebuilder_buildHoltWintersMultiplicative: (a: number, b: number) => number;
+  readonly pipelinebuilder_buildNaive: (a: number) => number;
+  readonly pipelinebuilder_buildRandomWalkDrift: (a: number) => number;
+  readonly pipelinebuilder_buildSarima: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number) => number;
+  readonly pipelinebuilder_buildSeasonalNaive: (a: number, b: number) => number;
+  readonly pipelinebuilder_buildSes: (a: number, b: number) => number;
+  readonly pipelinebuilder_buildTheta: (a: number) => number;
+  readonly pipelinebuilder_difference: (a: number, b: number) => void;
+  readonly pipelinebuilder_log: (a: number) => void;
+  readonly pipelinebuilder_normalize: (a: number) => void;
+  readonly pipelinebuilder_robustScale: (a: number) => void;
+  readonly pipelinebuilder_seasonalDifference: (a: number, b: number) => void;
+  readonly pipelinebuilder_standardize: (a: number) => void;
+  readonly quantile: (a: number, b: number, c: number) => number;
   readonly randomwalkdriftforecaster_fit: (a: number, b: number) => [number, number];
   readonly randomwalkdriftforecaster_name: (a: number) => [number, number];
   readonly randomwalkdriftforecaster_new: () => number;
   readonly randomwalkdriftforecaster_predict: (a: number, b: number) => [number, number, number];
   readonly randomwalkdriftforecaster_predictWithIntervals: (a: number, b: number, c: number) => [number, number, number];
+  readonly rangeCount: (a: number, b: number, c: number, d: number) => number;
+  readonly ratioBeyondRSigma: (a: number, b: number, c: number) => number;
+  readonly ratioValueNumberToTimeSeriesLength: (a: number, b: number) => number;
+  readonly regressionfeatures_autoLags: (a: number, b: number) => void;
+  readonly regressionfeatures_differencing: (a: number, b: number) => void;
+  readonly regressionfeatures_dummySeasonal: (a: number, b: number) => void;
+  readonly regressionfeatures_exog: (a: number) => void;
+  readonly regressionfeatures_fourier: (a: number, b: number, c: number) => void;
+  readonly regressionfeatures_fractionalDifferencing: (a: number, b: number) => void;
+  readonly regressionfeatures_lags: (a: number, b: number) => void;
+  readonly regressionfeatures_new: () => number;
+  readonly regressionfeatures_noExog: (a: number) => void;
+  readonly regressionfeatures_noTrend: (a: number) => void;
+  readonly regressionfeatures_seasonalDifferencing: (a: number, b: number, c: number) => void;
+  readonly regressionfeatures_specificLags: (a: number, b: number, c: number) => void;
+  readonly regressionfeatures_trend: (a: number) => void;
+  readonly regressionfeatures_withChangepointSteps: (a: number, b: number, c: number) => void;
+  readonly regressionfeatures_withChangepoints: (a: number, b: number, c: number, d: number, e: number) => [number, number];
+  readonly regressionfeatures_withEwmMean: (a: number, b: number, c: number) => [number, number];
+  readonly regressionfeatures_withEwmStd: (a: number, b: number, c: number) => [number, number];
+  readonly regressionfeatures_withRolling: (a: number, b: number, c: number, d: number, e: number, f: number) => [number, number];
+  readonly regressionfeatures_withRollingLagged: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => [number, number];
+  readonly regressionfeatures_withRollingMax: (a: number, b: number) => [number, number];
+  readonly regressionfeatures_withRollingMean: (a: number, b: number) => [number, number];
+  readonly regressionfeatures_withRollingMedian: (a: number, b: number) => [number, number];
+  readonly regressionfeatures_withRollingMin: (a: number, b: number) => [number, number];
+  readonly regressionfeatures_withRollingStd: (a: number, b: number) => [number, number];
+  readonly regressionfeatures_withRollingSum: (a: number, b: number) => [number, number];
+  readonly regressionfeatures_withRollingVar: (a: number, b: number) => [number, number];
+  readonly regressionfeatures_withTrendComponent: (a: number, b: number, c: number) => [number, number];
+  readonly regressionforecaster_bls: (a: number, b: number, c: number, d: number, e: number) => number;
+  readonly regressionforecaster_elasticNet: (a: number, b: number, c: number) => number;
+  readonly regressionforecaster_fit: (a: number, b: number) => [number, number];
+  readonly regressionforecaster_name: (a: number) => [number, number];
+  readonly regressionforecaster_ols: (a: number) => number;
+  readonly regressionforecaster_poisson: (a: number) => number;
+  readonly regressionforecaster_predict: (a: number, b: number) => [number, number, number];
+  readonly regressionforecaster_predictWithIntervals: (a: number, b: number, c: number) => [number, number, number];
+  readonly regressionforecaster_quantile: (a: number, b: number) => number;
+  readonly regressionforecaster_ridge: (a: number, b: number) => number;
+  readonly regressionforecaster_rls: (a: number, b: number) => number;
+  readonly regressionforecaster_tweedie: (a: number, b: number) => number;
+  readonly regressionforecaster_wlsDecay: (a: number, b: number) => number;
+  readonly rollingForecast: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number) => [number, number, number];
+  readonly rootMeanSquare: (a: number, b: number) => number;
   readonly sampleEntropy: (a: number, b: number, c: number, d: number) => number;
   readonly sarimaforecaster_fit: (a: number, b: number) => [number, number];
   readonly sarimaforecaster_name: (a: number) => [number, number];
@@ -2223,7 +3114,12 @@ export interface InitOutput {
   readonly smaforecaster_name: (a: number) => [number, number];
   readonly smaforecaster_new: (a: number) => number;
   readonly smaforecaster_predict: (a: number, b: number) => [number, number, number];
+  readonly standardDeviation: (a: number, b: number) => number;
   readonly stlDecompose: (a: number, b: number, c: number, d: number) => [number, number, number];
+  readonly sumOfReoccurringDataPoints: (a: number, b: number) => number;
+  readonly sumOfReoccurringValues: (a: number, b: number) => number;
+  readonly sumValues: (a: number, b: number) => number;
+  readonly symmetryLooking: (a: number, b: number, c: number) => number;
   readonly tbatsforecaster_fit: (a: number, b: number) => [number, number];
   readonly tbatsforecaster_name: (a: number) => [number, number];
   readonly tbatsforecaster_new: (a: number, b: number) => number;
@@ -2238,6 +3134,7 @@ export interface InitOutput {
   readonly thetaforecaster_new: () => number;
   readonly thetaforecaster_predict: (a: number, b: number) => [number, number, number];
   readonly thetaforecaster_predictWithIntervals: (a: number, b: number, c: number) => [number, number, number];
+  readonly timeReversalAsymmetryStatistic: (a: number, b: number, c: number) => number;
   readonly timeseries_clearCalendar: (a: number) => void;
   readonly timeseries_futureTimestamps: (a: number, b: number) => [number, number, number, number];
   readonly timeseries_hasCalendar: (a: number) => number;
@@ -2254,6 +3151,8 @@ export interface InitOutput {
   readonly tsbforecaster_new: () => number;
   readonly tsbforecaster_predict: (a: number, b: number) => [number, number, number];
   readonly tsbforecaster_predictWithIntervals: (a: number, b: number, c: number) => [number, number, number];
+  readonly updateForecastMonitor: (a: any, b: number, c: number) => [number, number, number];
+  readonly valueCount: (a: number, b: number, c: number) => number;
   readonly varforecaster_fitMultivariate: (a: number, b: any) => [number, number];
   readonly varforecaster_grangerCausalityTest: (a: number, b: number, c: number) => [number, number, number];
   readonly varforecaster_name: (a: number) => [number, number];
@@ -2261,7 +3160,11 @@ export interface InitOutput {
   readonly varforecaster_order: (a: number) => number;
   readonly varforecaster_predictMultivariate: (a: number, b: number) => [number, number, number];
   readonly variance: (a: number, b: number) => number;
+  readonly varianceLargerThanStandardDeviation: (a: number, b: number) => number;
+  readonly varianceSample: (a: number, b: number) => number;
+  readonly variationCoefficient: (a: number, b: number) => number;
   readonly version: () => [number, number];
+  readonly welchPeriodogram: (a: number, b: number, c: number, d: number, e: number) => [number, number, number];
   readonly windowaverageforecaster_fit: (a: number, b: number) => [number, number];
   readonly windowaverageforecaster_name: (a: number) => [number, number];
   readonly windowaverageforecaster_new: (a: number) => number;
@@ -2270,15 +3173,20 @@ export interface InitOutput {
   readonly __wbg_smaforecaster_free: (a: number, b: number) => void;
   readonly __wbg_tsbforecaster_free: (a: number, b: number) => void;
   readonly __wbg_windowaverageforecaster_free: (a: number, b: number) => void;
-  readonly jsconformalresult_scores: (a: number) => [number, number];
+  readonly __wbg_jsconformalresult_free: (a: number, b: number) => void;
+  readonly __wbg_jsnormalpredictor_free: (a: number, b: number) => void;
+  readonly pipelinebuilder_new: () => number;
   readonly jsconformalresult_coverage: (a: number) => number;
   readonly jsmodeldiagnostics_heteroscedasticityPvalue: (a: number) => number;
   readonly jsmodeldiagnostics_jarqueBeraPvalue: (a: number) => number;
+  readonly jsmodeldiagnostics_jarqueBeraStatistic: (a: number) => number;
+  readonly jsmodeldiagnostics_ljungBoxPvalue: (a: number) => number;
   readonly jsnormalresult_mean: (a: number) => number;
   readonly jsnormalresult_stdDev: (a: number) => number;
   readonly jsperstepconformalresult_coverage: (a: number) => number;
   readonly jspredictionintervals_coverage: (a: number) => number;
-  readonly __wbg_jsconformalresult_free: (a: number, b: number) => void;
+  readonly __wbg_jsnormalresult_free: (a: number, b: number) => void;
+  readonly jsconformalresult_scores: (a: number) => [number, number];
   readonly __wbindgen_malloc: (a: number, b: number) => number;
   readonly __wbindgen_realloc: (a: number, b: number, c: number, d: number) => number;
   readonly __wbindgen_exn_store: (a: number) => void;
@@ -2286,6 +3194,7 @@ export interface InitOutput {
   readonly __wbindgen_externrefs: WebAssembly.Table;
   readonly __externref_table_dealloc: (a: number) => void;
   readonly __wbindgen_free: (a: number, b: number, c: number) => void;
+  readonly __externref_drop_slice: (a: number, b: number) => void;
   readonly __wbindgen_start: () => void;
 }