@sipemu/anofox-forecast 0.4.4 → 0.4.6

package/anofox_forecast_js.d.ts

@@ -4,6 +4,7 @@
 export class ADIDAForecaster {
   free(): void;
   [Symbol.dispose](): void;
+  predictWithIntervals(horizon: number, level: number): Forecast;
   fit(series: TimeSeries): void;
   constructor();
   predict(horizon: number): Forecast;
@@ -61,6 +62,179 @@ export class AutoETSForecaster {
   readonly name: string;
 }
 
+export class AutoEnsembleForecaster {
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Get all candidate scores as a JSON object.
+   *
+   * Returns an array of `{ name, score }` objects sorted by score (ascending).
+   */
+  allScores(): any;
+  /**
+   * Get the number of models in the ensemble.
+   */
+  modelCount(): number;
+  /**
+   * Create with custom configuration.
+   *
+   * @param topK - Number of top models to include in ensemble (default: 3)
+   * @param seasonalPeriod - Seasonal period (0 or undefined for non-seasonal)
+   */
+  static withConfig(top_k?: number | null, seasonal_period?: number | null): AutoEnsembleForecaster;
+  /**
+   * Predict with prediction intervals.
+   *
+   * @param horizon - Number of steps to forecast
+   * @param level - Confidence level (e.g., 0.95 for 95% intervals)
+   * @returns Forecast with combined predictions and intervals
+   */
+  predictWithIntervals(horizon: number, level: number): Forecast;
+  /**
+   * Fit the ensemble to a time series.
+   *
+   * Fits all candidate models, selects the top-K, and builds the ensemble.
+   *
+   * @param series - TimeSeries to fit
+   */
+  fit(series: TimeSeries): void;
+  /**
+   * Create a new AutoEnsembleForecaster with default configuration.
+   *
+   * By default, uses top-3 models with weighted MSE combination.
+   */
+  constructor();
+  /**
+   * Predict future values.
+   *
+   * @param horizon - Number of steps to forecast
+   * @returns Forecast with combined point predictions
+   */
+  predict(horizon: number): Forecast;
+  /**
+   * Create a seasonal AutoEnsembleForecaster.
+   *
+   * @param period - Seasonal period
+   */
+  static seasonal(period: number): AutoEnsembleForecaster;
+  /**
+   * Get the model name.
+   */
+  readonly name: string;
+}
+
+export class AutoForecastBuilder {
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Include or exclude AutoETS from the candidate set.
+   *
+   * @param include - Whether to include AutoETS (default: true)
+   */
+  includeEts(include: boolean): AutoForecastBuilder;
+  /**
+   * Include or exclude AutoARIMA from the candidate set.
+   *
+   * @param include - Whether to include AutoARIMA (default: true)
+   */
+  includeArima(include: boolean): AutoForecastBuilder;
+  /**
+   * Include or exclude AutoTheta from the candidate set.
+   *
+   * @param include - Whether to include AutoTheta (default: true)
+   */
+  includeTheta(include: boolean): AutoForecastBuilder;
+  /**
+   * Set the seasonal period.
+   *
+   * @param period - Seasonal period (e.g., 12 for monthly data)
+   */
+  seasonalPeriod(period: number): AutoForecastBuilder;
+  /**
+   * Use cross-validation instead of in-sample MSE for model selection.
+   *
+   * @param useCv - Whether to use cross-validation (default: false)
+   */
+  useCrossValidation(use_cv: boolean): AutoForecastBuilder;
+  /**
+   * Create a new builder with all defaults enabled.
+   */
+  constructor();
+  /**
+   * Build the AutoForecaster with the configured parameters.
+   *
+   * @returns A new AutoForecaster ready to fit
+   */
+  build(): AutoForecaster;
+}
+
+export class AutoForecaster {
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Get all candidate scores as a JSON object.
+   *
+   * Returns an array of `{ name, score }` objects sorted by score (ascending).
+   */
+  allScores(): any;
+  /**
+   * Create an AutoForecaster with custom configuration.
+   *
+   * @param seasonalPeriod - Seasonal period (0 or undefined for non-seasonal)
+   * @param includeArima - Include AutoARIMA candidate (default: true)
+   * @param includeEts - Include AutoETS candidate (default: true)
+   * @param includeTheta - Include AutoTheta candidate (default: true)
+   * @param useCrossValidation - Use cross-validation instead of in-sample MSE (default: false)
+   */
+  static withConfig(seasonal_period?: number | null, include_arima?: boolean | null, include_ets?: boolean | null, include_theta?: boolean | null, use_cross_validation?: boolean | null): AutoForecaster;
+  /**
+   * Get the name of the selected model.
+   *
+   * @returns Name of the best model, or undefined if not yet fitted
+   */
+  selectedModelName(): string | undefined;
+  /**
+   * Predict with prediction intervals.
+   *
+   * @param horizon - Number of steps to forecast
+   * @param level - Confidence level (e.g., 0.95 for 95% intervals)
+   * @returns Forecast with point predictions and intervals
+   */
+  predictWithIntervals(horizon: number, level: number): Forecast;
+  /**
+   * Fit the model to a time series.
+   *
+   * Fits all candidate models and selects the best one.
+   *
+   * @param series - TimeSeries to fit
+   */
+  fit(series: TimeSeries): void;
+  /**
+   * Create a new AutoForecaster with default configuration.
+   *
+   * By default, includes AutoARIMA, AutoETS, and AutoTheta candidates
+   * and uses in-sample MSE for model selection.
+   */
+  constructor();
+  /**
+   * Predict future values.
+   *
+   * @param horizon - Number of steps to forecast
+   * @returns Forecast with point predictions
+   */
+  predict(horizon: number): Forecast;
+  /**
+   * Create a seasonal AutoForecaster.
+   *
+   * @param period - Seasonal period (e.g., 12 for monthly data with yearly seasonality)
+   */
+  static seasonal(period: number): AutoForecaster;
+  /**
+   * Get the model name.
+   */
+  readonly name: string;
+}
+
 export class AutoTBATSForecaster {
   free(): void;
   [Symbol.dispose](): void;
@@ -83,9 +257,98 @@ export class AutoThetaForecaster {
   readonly name: string;
 }
 
+export class CalendarAnnotations {
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Check if a specific date is a holiday.
+   *
+   * @param timestamp_ms - Date to check as milliseconds since Unix epoch
+   * @returns true if the date matches any registered holiday
+   */
+  isHoliday(timestamp_ms: number): boolean;
+  /**
+   * Add a single holiday date.
+   *
+   * @param timestamp_ms - Holiday date as milliseconds since Unix epoch
+   */
+  addHoliday(timestamp_ms: number): void;
+  /**
+   * Get holiday dates as milliseconds since Unix epoch.
+   */
+  getHolidays(): Float64Array;
+  /**
+   * Set multiple holiday dates at once (replaces any existing holidays).
+   *
+   * @param timestamps_ms - Array of holiday dates as milliseconds since Unix epoch
+   */
+  setHolidays(timestamps_ms: Float64Array): void;
+  /**
+   * Add a named regressor with values aligned to the time series.
+   *
+   * The values array must have the same length as the time series this
+   * will be attached to. Common examples: promotional flags (0/1),
+   * temperature, price changes, etc.
+   *
+   * @param name - Name of the regressor (e.g., "promo", "temperature")
+   * @param values - Array of numeric values, one per time step
+   */
+  addRegressor(name: string, values: Float64Array): void;
+  /**
+   * Get values for a named regressor.
+   *
+   * @param name - Regressor name
+   * @returns Array of values, or undefined if the regressor does not exist
+   */
+  getRegressor(name: string): Float64Array | undefined;
+  /**
+   * Get the number of holidays.
+   */
+  holidayCount(): number;
+  /**
+   * Check whether any regressors have been added.
+   */
+  hasRegressors(): boolean;
+  /**
+   * Check if a specific date is a business day (not weekend, not holiday).
+   *
+   * @param timestamp_ms - Date to check as milliseconds since Unix epoch
+   * @returns true if the date is a weekday and not a holiday
+   */
+  isBusinessDay(timestamp_ms: number): boolean;
+  /**
+   * Get the number of named regressors.
+   */
+  regressorCount(): number;
+  /**
+   * Get the names of all registered regressors.
+   */
+  regressorNames(): any;
+  /**
+   * Create an empty CalendarAnnotations instance.
+   */
+  constructor();
+  /**
+   * Serialize the calendar annotations to a JSON string.
+   *
+   * Useful for persisting or transferring annotations between contexts.
+   *
+   * @returns JSON string with `{ holidays: number[], regressors: { [name]: number[] } }`
+   */
+  toJSON(): string;
+  /**
+   * Deserialize calendar annotations from a JSON string.
+   *
+   * @param json - JSON string produced by `toJSON()`
+   * @returns A new CalendarAnnotations instance
+   */
+  static fromJSON(json: string): CalendarAnnotations;
+}
+
 export class CrostonForecaster {
   free(): void;
   [Symbol.dispose](): void;
+  predictWithIntervals(horizon: number, level: number): Forecast;
   fit(series: TimeSeries): void;
   constructor();
   predict(horizon: number): Forecast;
@@ -165,104 +428,926 @@ export class ETSForecaster {
   readonly name: string;
 }
 
+export class EnsembleForecaster {
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Set the combination method to median.
+   */
+  setMedian(): void;
+  /**
+   * Set the combination method by name string.
+   *
+   * Supported values: "mean", "median", "weighted_mse", "inverse_aic",
+   * "stacking", "horizon_adaptive".
+   *
+   * @param method - Combination method name
+   */
+  setMethod(method: string): void;
+  /**
+   * Get the number of models in the ensemble.
+   */
+  modelCount(): number;
+  /**
+   * Set custom combination weights.
+   *
+   * Weights are normalized to sum to 1. Length must match number of models.
+   *
+   * @param weights - Array of combination weights
+   */
+  setWeights(weights: Float64Array): void;
+  /**
+   * Set the combination method to stacking (projected gradient descent).
+   *
+   * Trains non-negative weights that sum to one on validation data.
+   *
+   * @param folds - Number of folds (default: 5)
+   */
+  setStacking(folds?: number | null): void;
+  /**
+   * Set the combination method to inverse AIC weighting.
+   *
+   * Computes Akaike weights from in-sample residuals.
+   */
+  setInverseAic(): void;
+  /**
+   * Set the combination method to weighted MSE.
+   */
+  setWeightedMse(): void;
+  /**
+   * Set the combination method to per-horizon adaptive weighting.
+   *
+   * Computes separate weight vectors for each forecast horizon step
+   * based on rolling-origin evaluation.
+   */
+  setHorizonAdaptive(): void;
+  /**
+   * Predict with prediction intervals.
+   *
+   * @param horizon - Number of steps to forecast
+   * @param level - Confidence level (e.g., 0.95 for 95% intervals)
+   * @returns Forecast with combined predictions and intervals
+   */
+  predictWithIntervals(horizon: number, level: number): Forecast;
+  /**
+   * Fit all models in the ensemble.
+   *
+   * @param series - TimeSeries to fit
+   */
+  fit(series: TimeSeries): void;
+  /**
+   * Create an ensemble from an array of model name strings.
+   *
+   * Supported names: "naive", "mean", "rwdrift", "ses", "holt",
+   * "autoarima", "autoets", "autotheta", "sma5", "wa10", etc.
+   *
+   * @param modelNames - Array of model name strings
+   */
+  constructor(model_names: string[]);
+  /**
+   * Predict future values using the combined ensemble.
+   *
+   * @param horizon - Number of steps to forecast
+   * @returns Forecast with combined point predictions
+   */
+  predict(horizon: number): Forecast;
+  /**
+   * Get the model name.
+   */
+  readonly name: string;
+}
+
 export class Forecast {
   private constructor();
   free(): void;
   [Symbol.dispose](): void;
   /**
-   * Check if lower prediction interval is available.
-   */
-  hasLower(): boolean;
-  /**
-   * Check if upper prediction interval is available.
+   * Return a new forecast with all values clamped to be non-negative.
+   */
+  nonNegative(): Forecast;
+  /**
+   * Return a new forecast with point values rounded to the nearest integer,
+   * lower intervals floored, and upper intervals ceiled.
+   */
+  roundToInteger(): Forecast;
+  /**
+   * Return a new forecast with all values clamped to `[lower, upper]`.
+   *
+   * @param lower - Lower bound
+   * @param upper - Upper bound
+   */
+  clamp(lower: number, upper: number): Forecast;
+  /**
+   * Check if lower prediction interval is available.
+   */
+  hasLower(): boolean;
+  /**
+   * Check if upper prediction interval is available.
+   */
+  hasUpper(): boolean;
+  /**
+   * Get lower prediction interval bounds.
+   *
+   * @returns Array of lower bounds, or undefined if not available
+   */
+  readonly lower: Float64Array | undefined;
+  /**
+   * Get upper prediction interval bounds.
+   *
+   * @returns Array of upper bounds, or undefined if not available
+   */
+  readonly upper: Float64Array | undefined;
+  /**
+   * Get point predictions.
+   */
+  readonly values: Float64Array;
+  /**
+   * Get the forecast horizon (number of predictions).
+   */
+  readonly horizon: number;
+}
+
+export class GARCHForecaster {
+  free(): void;
+  [Symbol.dispose](): void;
+  predictWithIntervals(horizon: number, level: number): Forecast;
+  fit(series: TimeSeries): void;
+  /**
+   * @param p - GARCH order (lagged variance terms)
+   * @param q - ARCH order (lagged squared residuals)
+   */
+  constructor(p: number, q: number);
+  predict(horizon: number): Forecast;
+  readonly name: string;
+}
+
+export class HoltForecaster {
+  free(): void;
+  [Symbol.dispose](): void;
+  predictWithIntervals(horizon: number, level: number): Forecast;
+  fit(series: TimeSeries): void;
+  /**
+   * @param alpha - Level smoothing parameter (0 < alpha <= 1)
+   * @param beta - Trend smoothing parameter (0 < beta <= 1)
+   */
+  constructor(alpha: number, beta: number);
+  predict(horizon: number): Forecast;
+  readonly name: string;
+}
+
+export class HoltWintersForecaster {
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Create with multiplicative seasonality.
+   */
+  static multiplicative(alpha: number, beta: number, gamma: number, period: number): HoltWintersForecaster;
+  predictWithIntervals(horizon: number, level: number): Forecast;
+  fit(series: TimeSeries): void;
+  /**
+   * Create with additive seasonality.
+   * @param alpha - Level smoothing parameter
+   * @param beta - Trend smoothing parameter
+   * @param gamma - Seasonal smoothing parameter
+   * @param period - Seasonal period
+   */
+  constructor(alpha: number, beta: number, gamma: number, period: number);
+  /**
+   * Create with automatic parameter optimization.
+   * @param period - Seasonal period
+   * @param seasonal_type - "additive" or "multiplicative"
+   */
+  static auto(period: number, seasonal_type: string): HoltWintersForecaster;
+  predict(horizon: number): Forecast;
+  readonly name: string;
+}
+
+export class IMAPAForecaster {
+  free(): void;
+  [Symbol.dispose](): void;
+  predictWithIntervals(horizon: number, level: number): Forecast;
+  fit(series: TimeSeries): void;
+  constructor();
+  predict(horizon: number): Forecast;
+  readonly name: string;
+}
+
+export class JsBacktestConfig {
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Set the initial training window size.
+   */
+  initialWindow(size: number): JsBacktestConfig;
+  /**
+   * Create a new backtest configuration with default settings.
+   *
+   * Defaults: initial_window=50, step=1, horizon=1, expanding=true.
+   */
+  constructor();
+  /**
+   * Set the step size between folds.
+   */
+  step(step: number): JsBacktestConfig;
+  /**
+   * Set the forecast horizon.
+   */
+  horizon(horizon: number): JsBacktestConfig;
+  /**
+   * Set whether to use expanding (true) or rolling (false) window.
+   */
+  expanding(expanding: boolean): JsBacktestConfig;
+}
+
+export class JsBacktestResult {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Get average interval width across all folds.
+   */
+  intervalWidths(): number;
+  /**
+   * Get calibration error (absolute deviation from target coverage).
+   */
+  calibrationError(target_coverage: number): number;
+  /**
+   * Get the number of backtest folds.
+   */
+  numFolds(): number;
+  /**
+   * Get overall coverage across all folds.
+   */
+  readonly coverage: number;
+}
+
+export class JsConformalPredictor {
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Create a conformal predictor with the Jackknife+ method.
+   *
+   * @param coverage - Target coverage level in (0, 1)
+   */
+  static jackknifePlus(coverage: number): JsConformalPredictor;
+  /**
+   * Generate prediction intervals for new point forecasts.
+   *
+   * @param result - A fitted JsConformalResult from calibrate()
+   * @param pointForecasts - New point forecast values
+   */
+  predictIntervals(result: JsConformalResult, point_forecasts: Float64Array): JsPredictionIntervals;
+  /**
+   * Create a split conformal predictor.
+   *
+   * @param coverage - Target coverage level in (0, 1), e.g. 0.90
+   */
+  constructor(coverage: number);
+  /**
+   * Calibrate (fit) the predictor on historical forecasts and actuals.
+   *
+   * @param forecasts - Historical point forecast values
+   * @param actuals - Corresponding actual observed values
+   */
+  calibrate(forecasts: Float64Array, actuals: Float64Array): JsConformalResult;
+  /**
+   * Create a conformal predictor with the cross-validation method.
+   *
+   * @param coverage - Target coverage level in (0, 1)
+   * @param nFolds - Number of cross-validation folds
+   */
+  static crossVal(coverage: number, n_folds: number): JsConformalPredictor;
+}
+
+export class JsConformalResult {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Get the quantile value (interval half-width).
+   */
+  quantileValue(): number;
+  /**
+   * Get the nonconformity scores.
+   */
+  scores(): Float64Array;
+  /**
+   * Get the coverage level.
+   */
+  readonly coverage: number;
+}
+
+export class JsDataProfile {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Profile a time series.
+   *
+   * @param series - TimeSeries to profile
+   * @returns A comprehensive data profile
+   */
+  static fromSeries(series: TimeSeries): JsDataProfile;
+  /**
+   * Profile raw values (without timestamps).
+   *
+   * @param values - Array of numeric values
+   * @returns A data profile
+   */
+  static fromValues(values: Float64Array): JsDataProfile;
+  /**
+   * Full profile as a formatted string.
+   */
+  toString(): string;
+  /**
+   * Human-readable summary string.
+   */
+  summary(): string;
+  /**
+   * Profile as a JSON-serializable object.
+   */
+  toJSON(): any;
+  /**
+   * Whether every finite value is integer-valued.
+   */
+  readonly isInteger: boolean;
+  /**
+   * Lempel-Ziv complexity (normalized).
+   */
+  readonly lempelZiv: number;
+  /**
+   * ADF p-value.
+   */
+  readonly adfPValue: number;
+  /**
+   * Slope of the linear trend.
+   */
+  readonly trendSlope: number;
+  /**
+   * KPSS p-value.
+   */
+  readonly kpssPValue: number;
+  /**
+   * ADF test statistic.
+   */
+  readonly adfStatistic: number;
+  /**
+   * Whether any value is negative.
+   */
+  readonly hasNegatives: boolean;
+  /**
+   * Combined stationarity (ADF stationary AND KPSS stationary).
+   */
+  readonly isStationary: boolean;
+  /**
+   * Count of NaN or infinite values.
+   */
+  readonly missingCount: number;
+  /**
+   * Heuristic data-quality score in [0.0, 1.0].
+   */
+  readonly qualityScore: number;
+  /**
+   * Fraction of values that are exactly zero.
+   */
+  readonly zeroFraction: number;
+  /**
+   * KPSS test statistic.
+   */
+  readonly kpssStatistic: number;
+  /**
+   * Number of observations.
+   */
+  readonly nObservations: number;
+  /**
+   * Trend strength (R-squared, 0.0 to 1.0).
+   */
+  readonly trendStrength: number;
+  /**
+   * Whether the series is classified as intermittent.
+   */
+  readonly isIntermittent: boolean;
+  /**
+   * Trend direction: "Rising", "Falling", or "Flat".
+   */
+  readonly trendDirection: string;
+  /**
+   * Partial autocorrelation at lag 1.
+   */
+  readonly partialAcfLag1: number;
+  /**
+   * Whether ADF concludes stationarity at 5%.
+   */
+  readonly adfIsStationary: boolean;
+  /**
+   * Whether KPSS concludes stationarity at 5%.
+   */
+  readonly kpssIsStationary: boolean;
+  /**
+   * Approximate entropy (undefined if series is too short).
+   */
+  readonly approximateEntropy: number | undefined;
+  /**
+   * Maximum value.
+   */
+  readonly max: number;
+  /**
+   * Minimum value.
+   */
+  readonly min: number;
+  /**
+   * Arithmetic mean.
+   */
+  readonly mean: number;
+  /**
+   * Standard deviation.
+   */
+  readonly stdDev: number;
+  /**
+   * Autocorrelation at lag 1.
+   */
+  readonly acfLag1: number;
+  /**
+   * Autocorrelation at lag 2.
+   */
+  readonly acfLag2: number;
+  /**
+   * Excess kurtosis.
+   */
+  readonly kurtosis: number;
+  /**
+   * Skewness.
+   */
+  readonly skewness: number;
+}
+
+export class JsHistoricalSimResult {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Get the quantile values.
+   */
+  quantileValues(): Float64Array;
+  /**
+   * Get the sorted errors.
+   */
+  errors(): Float64Array;
+}
+
+export class JsHistoricalSimulator {
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Create a simulator with a rolling window.
+   *
+   * @param quantiles - Sorted quantile levels in (0,1)
+   * @param window - Number of recent observations to use
+   */
+  static withWindow(quantiles: Float64Array, window: number): JsHistoricalSimulator;
+  /**
+   * Generate prediction intervals for new point forecasts.
+   *
+   * @param result - A fitted JsHistoricalSimResult from simulate()
+   * @param pointForecasts - New point forecast values
+   */
+  predictIntervals(result: JsHistoricalSimResult, point_forecasts: Float64Array): JsPredictionIntervals;
+  /**
+   * Create a new historical simulator.
+   *
+   * @param quantiles - Sorted quantile levels in (0,1), e.g. [0.1, 0.5, 0.9]
+   */
+  constructor(quantiles: Float64Array);
+  /**
+   * Fit the simulator on historical forecasts and actuals.
+   *
+   * @param forecasts - Historical point forecast values
+   * @param actuals - Corresponding actual observed values
+   */
+  simulate(forecasts: Float64Array, actuals: Float64Array): JsHistoricalSimResult;
+}
+
+export class JsModelDiagnostics {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Create diagnostics from an array of residuals.
+   *
+   * @param residuals - Array of model residuals
+   * @param significance - Significance level for tests (e.g., 0.05)
+   */
+  static fromResiduals(residuals: Float64Array, significance: number): JsModelDiagnostics;
+  /**
+   * Get a human-readable summary of the diagnostics.
+   */
+  summary(): string;
+  /**
+   * Whether all diagnostic tests pass at the configured significance level.
+   */
+  readonly passesAll: boolean;
+  /**
+   * Autocorrelation function of the residuals.
+   */
+  readonly residualAcf: Float64Array;
+  /**
+   * Standard deviation of the residuals.
+   */
+  readonly residualStd: number;
+  /**
+   * Mean of the residuals.
+   */
+  readonly residualMean: number;
+  /**
+   * Partial autocorrelation function of the residuals.
+   */
+  readonly residualPacf: Float64Array;
+  /**
+   * Number of lags used in the Ljung-Box test.
+   */
+  readonly ljungBoxLags: number;
+  /**
+   * Ljung-Box test p-value for autocorrelation.
+   */
+  readonly ljungBoxPvalue: number;
+  /**
+   * Jarque-Bera test p-value.
+   */
+  readonly jarqueBeraPvalue: number;
+  /**
+   * Jarque-Bera test statistic for normality.
+   */
+  readonly jarqueBeraStatistic: number;
+  /**
+   * Breusch-Pagan heteroscedasticity test p-value.
+   */
+  readonly heteroscedasticityPvalue: number;
+}
+
+export class JsNormalPredictor {
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Generate prediction intervals for new point forecasts.
+   *
+   * Returns intervals using the first and last quantile as bounds.
+   *
+   * @param result - A fitted JsNormalResult from fit()
+   * @param pointForecasts - New point forecast values
+   */
+  predictIntervals(result: JsNormalResult, point_forecasts: Float64Array): JsPredictionIntervals;
+  /**
+   * Fit the predictor on historical forecasts and actuals.
+   *
+   * @param forecasts - Historical point forecast values
+   * @param actuals - Corresponding actual observed values
+   */
+  fit(forecasts: Float64Array, actuals: Float64Array): JsNormalResult;
+  /**
+   * Create a new normal predictor.
+   *
+   * @param quantiles - Sorted quantile levels in (0,1), e.g. [0.1, 0.5, 0.9]
+   */
+  constructor(quantiles: Float64Array);
+}
+
+export class JsNormalResult {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Get the standard deviation of errors.
+   */
+  stdDev(): number;
+  /**
+   * Get the mean error (bias).
+   */
+  readonly mean: number;
+}
+
+export class JsPipelineBuilder {
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Set preprocessing mode.
+   *
+   * @param mode - "auto", "none", or "manual"
+   */
+  preprocess(mode: string): JsPipelineBuilder;
+  /**
+   * Apply non-negative constraint to forecasts.
+   */
+  nonNegative(): JsPipelineBuilder;
+  /**
+   * Select top-K models for evaluation.
+   *
+   * @param k - Number of models to select
+   */
+  selectModels(k: number): JsPipelineBuilder;
+  /**
+   * Enable fallback chain (Naive → SMA).
+   */
+  withFallback(): JsPipelineBuilder;
+  /**
+   * Enable cross-validation.
+   *
+   * @param folds - Number of CV folds
+   * @param horizon - Forecast horizon for each fold
+   */
+  crossValidate(folds: number, horizon: number): JsPipelineBuilder;
+  /**
+   * Set the seasonal period hint.
+   *
+   * @param period - Seasonal period (e.g., 12 for monthly data)
+   */
+  seasonalPeriod(period: number): JsPipelineBuilder;
+  /**
+   * Add a seasonal model to the pipeline.
+   *
+   * @param name - Model name (e.g., "SeasonalNaive")
+   * @param period - Seasonal period
+   */
+  addSeasonalModel(name: string, period: number): JsPipelineBuilder;
+  /**
+   * Create a new pipeline builder.
+   */
+  constructor();
+  /**
+   * Set the metric strategy for model selection.
+   *
+   * @param strategy - "auto", "mae", "mse", "rmse", "smape", "wape", or "mda"
+   */
+  metric(strategy: string): JsPipelineBuilder;
+  /**
+   * Build and execute the pipeline.
+   *
+   * @param series - TimeSeries to forecast
+   * @param horizon - Number of steps to forecast
+   * @returns JsPipelineResult with forecast, profile, and diagnostics
+   */
+  execute(series: TimeSeries, horizon: number): JsPipelineResult;
+  /**
+   * Enable data profiling.
+   */
+  profile(): JsPipelineBuilder;
+  /**
+   * Set the ensemble mode.
+   *
+   * @param mode - "auto", "none", "mean", "median", or "weighted"
+   */
+  ensemble(mode: string): JsPipelineBuilder;
+  /**
+   * Add a built-in model to the pipeline.
+   *
+   * Supported models: "Naive", "SES", "SMA", "SMA5", "SMA10"
+   *
+   * @param name - Model name
+   */
+  addModel(name: string): JsPipelineBuilder;
+}
+
+export class JsPipelineReport {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Get the full report as formatted text.
+   */
+  toString(): string;
+  /**
+   * Get a section heading by index.
+   */
+  sectionHeading(index: number): string | undefined;
+  /**
+   * Get the report as a JSON object.
+   *
+   * Returns `{ title, sections: [{ heading, content }] }`.
+   */
+  toJSON(): any;
+  /**
+   * Get the number of sections.
+   */
+  readonly sectionCount: number;
+  /**
+   * Get the report title.
+   */
+  readonly title: string;
+}
+
+export class JsPipelineResult {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Get a human-readable summary of the result.
+   */
+  toString(): string;
+  /**
+   * Generate a full structured report.
+   */
+  report(): JsPipelineReport;
+  /**
+   * Get the name of the selected model.
+   */
+  readonly modelName: string;
+  /**
+   * Get the decision log as a formatted string.
+   */
+  readonly decisionLog: string;
+  /**
+   * Get metric scores as JSON (undefined if not computed).
+   */
+  readonly metricScores: any;
+  /**
+   * Get quality floor result (undefined if not computed).
+   */
+  readonly qualityFloor: string | undefined;
+  /**
+   * Get the number of decisions in the log.
+   */
+  readonly decisionCount: number;
+  /**
+   * Get preprocessing info (undefined if not applied).
+   */
+  readonly preprocessInfo: any;
+  /**
+   * Get ensemble weights as JSON (undefined if not an ensemble).
+   */
+  readonly ensembleWeights: any;
+  /**
+   * Get model confidence set (undefined if not computed).
+   */
+  readonly modelConfidenceSet: any;
+  /**
+   * Get selection confidence (undefined if not computed).
+   */
+  readonly selectionConfidence: string | undefined;
+  /**
+   * Get the data profile (undefined if profiling was not enabled).
+   */
+  readonly profile: JsDataProfile | undefined;
+  /**
+   * Get the forecast.
+   */
+  readonly forecast: Forecast;
+}
+
+export class JsPointForecasts {
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Create point forecasts from an array of values.
+   */
+  constructor(values: Float64Array);
+  /**
+   * Check if empty.
+   */
+  isEmpty(): boolean;
+  /**
+   * Get the number of forecast points.
+   */
+  readonly length: number;
+  /**
+   * Get the forecast values.
+   */
+  readonly values: Float64Array;
+}
+
+export class JsPostProcessor {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Create a historical simulation postprocessor.
+   *
+   * @param quantiles - Sorted quantile levels in (0,1)
    */
-  hasUpper(): boolean;
+  static historicalSim(quantiles: Float64Array): JsPostProcessor;
   /**
-   * Get lower prediction interval bounds.
+   * Generate prediction intervals from a trained model.
    *
-   * @returns Array of lower bounds, or undefined if not available
+   * @param trained - A JsTrainedModel from train()
+   * @param forecasts - New point forecasts
    */
-  readonly lower: Float64Array | undefined;
+  predictIntervals(trained: JsTrainedModel, forecasts: JsPointForecasts): JsPredictionIntervals;
   /**
-   * Get upper prediction interval bounds.
+   * Train the postprocessor on historical data.
    *
-   * @returns Array of upper bounds, or undefined if not available
+   * @param forecasts - JsPointForecasts with historical predictions
+   * @param actuals - Corresponding actual observed values
    */
-  readonly upper: Float64Array | undefined;
+  train(forecasts: JsPointForecasts, actuals: Float64Array): JsTrainedModel;
   /**
-   * Get point predictions.
+   * Create a normal prediction postprocessor.
+   *
+   * @param quantiles - Sorted quantile levels in (0,1)
    */
-  readonly values: Float64Array;
+  static normal(quantiles: Float64Array): JsPostProcessor;
   /**
-   * Get the forecast horizon (number of predictions).
+   * Create a conformal prediction postprocessor.
+   *
+   * @param coverage - Target coverage level in (0, 1), e.g. 0.90
    */
-  readonly horizon: number;
+  static conformal(coverage: number): JsPostProcessor;
 }
 
-export class GARCHForecaster {
+export class JsPredictionIntervals {
+  private constructor();
   free(): void;
   [Symbol.dispose](): void;
-  fit(series: TimeSeries): void;
   /**
-   * @param p - GARCH order (lagged variance terms)
-   * @param q - ARCH order (lagged squared residuals)
+   * Compute empirical coverage given actual values.
    */
-  constructor(p: number, q: number);
-  predict(horizon: number): Forecast;
-  readonly name: string;
+  empiricalCoverage(actuals: Float64Array): number | undefined;
+  /**
+   * Get the interval widths.
+   */
+  widths(): Float64Array;
+  /**
+   * Get the interval midpoints.
+   */
+  midpoints(): Float64Array;
+  /**
+   * Get the lower bounds.
+   */
+  readonly lower: Float64Array;
+  /**
+   * Get the upper bounds.
+   */
+  readonly upper: Float64Array;
+  /**
+   * Get the number of intervals.
+   */
+  readonly length: number;
+  /**
+   * Get the coverage level (e.g. 0.90).
+   */
+  readonly coverage: number;
 }
 
-export class HoltForecaster {
+export class JsTrainedModel {
+  private constructor();
   free(): void;
   [Symbol.dispose](): void;
-  fit(series: TimeSeries): void;
-  /**
-   * @param alpha - Level smoothing parameter (0 < alpha <= 1)
-   * @param beta - Trend smoothing parameter (0 < beta <= 1)
-   */
-  constructor(alpha: number, beta: number);
-  predict(horizon: number): Forecast;
-  readonly name: string;
 }
 
-export class HoltWintersForecaster {
+export class KalmanForecaster {
+  private constructor();
   free(): void;
   [Symbol.dispose](): void;
   /**
-   * Create with multiplicative seasonality.
+   * Create a local level (random walk plus noise) model.
+   *
+   * @param obs_noise - Observation noise variance
+   * @param state_noise - State (level) noise variance
    */
-  static multiplicative(alpha: number, beta: number, gamma: number, period: number): HoltWintersForecaster;
-  fit(series: TimeSeries): void;
+  static localLevel(obs_noise: number, state_noise: number): KalmanForecaster;
   /**
-   * Create with additive seasonality.
-   * @param alpha - Level smoothing parameter
-   * @param beta - Trend smoothing parameter
-   * @param gamma - Seasonal smoothing parameter
-   * @param period - Seasonal period
+   * Create a local linear trend model.
+   *
+   * @param obs_noise - Observation noise variance
+   * @param level_noise - Level noise variance
+   * @param trend_noise - Trend noise variance
    */
-  constructor(alpha: number, beta: number, gamma: number, period: number);
+  static localLinearTrend(obs_noise: number, level_noise: number, trend_noise: number): KalmanForecaster;
   /**
-   * Create with automatic parameter optimization.
-   * @param period - Seasonal period
-   * @param seasonal_type - "additive" or "multiplicative"
+   * Predict with prediction intervals.
+   *
+   * @param horizon - Number of steps to forecast
+   * @param level - Confidence level (e.g., 0.95 for 95% intervals)
+   * @returns Forecast with predictions and intervals
+   */
+  predictWithIntervals(horizon: number, level: number): Forecast;
+  /**
+   * Fit the Kalman filter to a time series.
+   *
+   * @param series - TimeSeries to fit
    */
-  static auto(period: number, seasonal_type: string): HoltWintersForecaster;
-  predict(horizon: number): Forecast;
-  readonly name: string;
-}
-
-export class IMAPAForecaster {
-  free(): void;
-  [Symbol.dispose](): void;
   fit(series: TimeSeries): void;
-  constructor();
+  /**
+   * Apply the Kalman smoother (RTS smoother) and return smoothed observations.
+   *
+   * @param series - TimeSeries to smooth
+   * @returns Array of smoothed observation values
+   */
+  smooth(series: TimeSeries): Float64Array;
+  /**
+   * Predict future values.
+   *
+   * @param horizon - Number of steps to forecast
+   * @returns Forecast with point predictions
+   */
   predict(horizon: number): Forecast;
+  /**
+   * Get the model name.
+   */
   readonly name: string;
 }
 
 export class MFLESForecaster {
   free(): void;
   [Symbol.dispose](): void;
+  predictWithIntervals(horizon: number, level: number): Forecast;
   fit(series: TimeSeries): void;
   /**
    * @param seasonal_periods - Array of seasonal periods
@@ -346,6 +1431,7 @@ export class SARIMAForecaster {
 export class SESForecaster {
   free(): void;
   [Symbol.dispose](): void;
+  predictWithIntervals(horizon: number, level: number): Forecast;
   fit(series: TimeSeries): void;
   /**
    * @param alpha - Smoothing parameter (0 < alpha <= 1)
@@ -408,18 +1494,58 @@ export class SeasonalWindowAverageForecaster {
 export class TBATSForecaster {
   free(): void;
   [Symbol.dispose](): void;
+  /**
+   * Enable Box-Cox transformation.
+   *
+   * @param lambda - Box-Cox parameter (0 = log, 1 = identity)
+   */
+  setBoxCox(lambda: number): void;
+  /**
+   * Set Fourier K (number of harmonics) for each seasonal period.
+   *
+   * @param k - Array of K values (one per seasonal period)
+   */
+  setFourierK(k: Uint32Array): void;
+  /**
+   * Enable damped trend.
+   *
+   * @param phi - Damping parameter (typically 0.8-0.99)
+   */
+  setDampedTrend(phi: number): void;
+  /**
+   * Create a TBATSForecaster with specified seasonal periods.
+   *
+   * @param periods - Array of seasonal periods
+   * @returns A new TBATSForecaster
+   */
+  static withSeasonalPeriods(periods: Uint32Array): TBATSForecaster;
+  /**
+   * Predict with prediction intervals.
+   *
+   * @param horizon - Number of steps to forecast
+   * @param level - Confidence level (e.g., 0.95 for 95% intervals)
+   */
+  predictWithIntervals(horizon: number, level: number): Forecast;
   fit(series: TimeSeries): void;
   /**
    * @param seasonal_periods - Array of seasonal periods (e.g., [7, 365] for daily data)
    */
   constructor(seasonal_periods: Uint32Array);
   predict(horizon: number): Forecast;
+  /**
+   * Set ARMA error orders.
+   *
+   * @param p - AR order
+   * @param q - MA order
+   */
+  setArma(p: number, q: number): void;
   readonly name: string;
 }
 
 export class TSBForecaster {
   free(): void;
   [Symbol.dispose](): void;
+  predictWithIntervals(horizon: number, level: number): Forecast;
   fit(series: TimeSeries): void;
   constructor();
   predict(horizon: number): Forecast;
@@ -439,6 +1565,23 @@ export class ThetaForecaster {
 export class TimeSeries {
   free(): void;
   [Symbol.dispose](): void;
+  /**
+   * Check if calendar annotations are attached.
+   */
+  hasCalendar(): boolean;
+  /**
+   * Attach calendar annotations (holidays, regressors) to this time series.
+   *
+   * Models that support exogenous variables will automatically use the
+   * calendar annotations during fitting.
+   *
+   * @param calendar - CalendarAnnotations instance
+   */
+  setCalendar(calendar: CalendarAnnotations): void;
+  /**
+   * Remove calendar annotations from this time series.
+   */
+  clearCalendar(): void;
   /**
    * Create a time series with timestamps.
    *
@@ -480,6 +1623,48 @@ export class TimeSeries {
   readonly values: Float64Array;
 }
 
+export class VARForecaster {
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Fit the VAR model to multivariate time series data.
+   *
+   * @param data - Array of Float64Arrays, one per variable. All must have the same length.
+   */
+  fitMultivariate(data: Array<any>): void;
+  /**
+   * Predict future values for all variables.
+   *
+   * @param horizon - Number of steps to forecast
+   * @returns Array of Float64Arrays, one per variable
+   */
+  predictMultivariate(horizon: number): Array<any>;
+  /**
+   * Perform a Granger causality test.
+   *
+   * Tests whether variable `cause` Granger-causes variable `effect`.
+   *
+   * @param cause - Index of the potentially causal variable (0-based)
+   * @param effect - Index of the effect variable (0-based)
+   * @returns F-statistic. Higher values indicate stronger evidence of causality.
+   */
+  grangerCausalityTest(cause: number, effect: number): number;
+  /**
+   * Create a new VAR forecaster with the given lag order.
+   *
+   * @param order - Number of lags (p). Must be at least 1.
+   */
+  constructor(order: number);
+  /**
+   * Get the model name.
+   */
+  readonly name: string;
+  /**
+   * Get the lag order.
+   */
+  readonly order: number;
+}
+
 export class WindowAverageForecaster {
   free(): void;
   [Symbol.dispose](): void;
@@ -492,6 +1677,142 @@ export class WindowAverageForecaster {
   readonly name: string;
 }
 
+/**
+ * Perform the Augmented Dickey-Fuller (ADF) test for unit root.
+ *
+ * Tests the null hypothesis that the series has a unit root (non-stationary).
+ * Rejection (low p-value, negative statistic below critical values) implies
+ * stationarity.
+ *
+ * @param values - Array of numeric values
+ * @param maxLags - Maximum lags to include (default: (n-1)^(1/3))
+ * @returns Object with `statistic`, `pValue`, `lags`, `isStationary`, and `criticalValues`
+ */
+export function adfTest(values: Float64Array, max_lags?: number | null): any;
+
+/**
+ * Compute the approximate entropy of a time series.
+ *
+ * Measures the complexity/regularity of a time series, including self-matches.
+ *
+ * @param values - Array of numeric values
+ * @param m - Embedding dimension (typically 2)
+ * @param r - Tolerance (typically 0.2 * standard deviation)
+ * @returns Approximate entropy, or NaN if insufficient data
+ */
+export function approximateEntropy(values: Float64Array, m: number, r: number): number;
+
+/**
+ * Compute the autocorrelation of a time series at a specific lag.
+ *
+ * @param values - Array of numeric values
+ * @param lag - Lag value
+ * @returns Autocorrelation coefficient at the given lag
+ */
+export function autocorrelation(values: Float64Array, lag: number): number;
+
+/**
+ * Run a backtest on a postprocessor.
+ *
+ * @param processor - The postprocessor to evaluate
+ * @param forecasts - All historical point forecasts
+ * @param actuals - All historical actual values
+ * @param config - Backtest configuration
+ */
+export function backtestPostProcessor(processor: JsPostProcessor, forecasts: JsPointForecasts, actuals: Float64Array, config: JsBacktestConfig): JsBacktestResult;
+
+/**
+ * Generate a bootstrap forecast with empirical prediction intervals.
+ *
+ * Uses residual bootstrap: resamples fitted residuals, generates synthetic
+ * series, re-fits the model, and collects forecast distributions to
+ * compute confidence intervals.
+ *
+ * @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", "sma5", etc.
+ * @param horizon - Number of steps to forecast
+ * @param level - Confidence level (e.g., 0.95 for 95% intervals)
+ * @param nSamples - Number of bootstrap samples (default: 200)
+ * @returns Object with `point`, `lower`, `upper`, `level`, `nSamples`
+ */
+export function bootstrapForecast(values: Float64Array, timestamps: Float64Array | null | undefined, model_type: string, horizon: number, level: number, n_samples?: number | null): any;
+
+/**
+ * Perform time series cross-validation with expanding window.
+ *
+ * Evaluates a forecasting model using multiple train/test splits where
+ * the training window grows with each fold.
+ *
+ * @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", "sma5", etc.
+ * @param horizon - Forecast horizon for each fold
+ * @param initialWindow - Initial training window size (default: max(10, length/3))
+ * @returns Object with `rmse`, `mae`, `mape`, `smape`, `folds`, `maeStd`, `rmseStd`
+ */
+export function crossValidate(values: Float64Array, timestamps: Float64Array | null | undefined, model_type: string, horizon: number, initial_window?: number | null): any;
+
+/**
+ * Detect changepoints in a time series using the PELT algorithm.
+ *
+ * Returns an object with `changepoints` (indices), `segments` (boundary pairs),
+ * `cost`, `nChangepoints`, and `segmentMeans`.
+ *
+ * @param values - Array of numeric values
+ * @param penalty - Penalty for each changepoint (controls number of changepoints; higher = fewer)
+ * @param costFunction - Cost function: "l1", "l2" (default), "normal", "poisson", "linearTrend", "meanVariance", or "cusum"
+ * @param minSegmentLength - Minimum segment length (default: 2)
+ * @returns Object with changepoint detection results
+ */
+export function detectChangepoints(values: Float64Array, penalty: number, cost_function?: string | null, min_segment_length?: number | null): any;
+
+/**
+ * Detect changepoints using BIC penalty (penalty = log(n)).
+ *
+ * BIC penalty automatically adapts to series length, providing a good
+ * default for most use cases.
+ *
+ * @param values - Array of numeric values
+ * @param costFunction - Cost function (default: "l2")
+ * @returns Object with changepoint detection results
+ */
+export function detectChangepointsBic(values: Float64Array, cost_function?: string | null): any;
+
+/**
+ * Run comprehensive residual diagnostics.
+ *
+ * Combines Ljung-Box (autocorrelation), Durbin-Watson (first-order autocorrelation),
+ * and Jarque-Bera (normality) tests into a single diagnostic report.
+ *
+ * @param residuals - Array of model residuals
+ * @param fittedParams - Number of fitted model parameters (default: 0)
+ * @returns Object with `ljungBox`, `durbinWatson`, `jarqueBera`, `mean`, `variance`, `n`, and `isAdequate`
+ */
+export function diagnoseResiduals(residuals: Float64Array, fitted_params?: number | null): any;
+
+/**
+ * Perform the Durbin-Watson test for first-order autocorrelation.
+ *
+ * The statistic ranges from 0 to 4:
+ * - Near 0: Strong positive autocorrelation
+ * - Near 2: No autocorrelation
+ * - Near 4: Strong negative autocorrelation
+ *
+ * @param residuals - Array of model residuals
+ * @returns Object with `statistic` and `interpretation`
+ */
+export function durbinWatson(residuals: Float64Array): any;
+
+/**
+ * Generate a human-readable explanation of a pipeline result.
+ *
+ * @param result - A JsPipelineResult to explain
+ * @param verbosity - "brief", "normal", or "detailed"
+ * @returns Object with `summary` and `sections`
+ */
+export function explainResult(result: JsPipelineResult, verbosity: string): any;
+
 /**
  * Initialize the WASM module.
  *
@@ -499,6 +1820,144 @@ export class WindowAverageForecaster {
  */
 export function init(): void;
 
+/**
+ * Perform the Jarque-Bera test for normality of residuals.
+ *
+ * Tests the null hypothesis that residuals are normally distributed by
+ * examining skewness and kurtosis. A high statistic (low p-value) suggests
+ * non-normality.
+ *
+ * @param residuals - Array of model residuals
+ * @returns Object with `statistic`, `pValue`, `isNormal`, `skewness`, and `excessKurtosis`
+ */
+export function jarqueBera(residuals: Float64Array): any;
+
+/**
+ * Perform the KPSS test for stationarity.
+ *
+ * Tests the null hypothesis that the series is (level) stationary.
+ * Rejection (high statistic above critical values) implies non-stationarity.
+ *
+ * Note: ADF and KPSS test opposite null hypotheses:
+ * - ADF: H0 = non-stationary, reject = stationary
+ * - KPSS: H0 = stationary, reject = non-stationary
+ *
+ * @param values - Array of numeric values
+ * @param lags - Number of lags for HAC variance (default: 4*(n/100)^0.25)
+ * @returns Object with `statistic`, `pValue`, `lags`, `isStationary`, and `criticalValues`
+ */
+export function kpssTest(values: Float64Array, lags?: number | null): any;
+
+/**
+ * Compute the excess kurtosis (fourth standardized moment) of a time series.
+ *
+ * Measures the "tailedness" of the distribution. A normal distribution has
+ * excess kurtosis of 0.
+ *
+ * @param values - Array of numeric values
+ * @returns Excess kurtosis, or NaN if fewer than 4 values
+ */
+export function kurtosis(values: Float64Array): number;
+
+/**
+ * Perform the Ljung-Box test for autocorrelation in residuals.
+ *
+ * Tests the null hypothesis that residuals are independently distributed
+ * (white noise). A low p-value suggests significant autocorrelation remains.
+ *
+ * @param residuals - Array of model residuals
+ * @param lags - Number of lags to include (default: min(10, n/5))
+ * @param fittedParams - Number of fitted model parameters (for df adjustment, default: 0)
+ * @returns Object with `statistic`, `pValue`, `lags`, `df`, and `isWhiteNoise`
+ */
+export function ljungBox(residuals: Float64Array, lags?: number | null, fitted_params?: number | null): any;
+
+/**
+ * Compute the arithmetic mean of a time series.
+ *
+ * @param values - Array of numeric values
+ * @returns Arithmetic mean, or NaN if empty
+ */
+export function mean(values: Float64Array): number;
+
+/**
+ * Perform MSTL (Multiple Seasonal-Trend decomposition using LOESS).
+ *
+ * Decomposes a time series with multiple seasonal periods into trend,
+ * multiple seasonal components, and remainder.
+ *
+ * @param values - Array of numeric values
+ * @param periods - Array of seasonal periods (e.g., [7, 365] for daily data)
+ * @returns Object with `trend`, `seasonals` (array of arrays), `seasonalPeriods`, `remainder`, and `trendStrength`
+ */
+export function mstlDecompose(values: Float64Array, periods: Uint32Array): any;
+
+/**
+ * Compute the partial autocorrelation of a time series at a specific lag.
+ *
+ * Uses the Durbin-Levinson algorithm.
+ *
+ * @param values - Array of numeric values
+ * @param lag - Lag value (must be >= 1)
+ * @returns Partial autocorrelation coefficient at the given lag
+ */
+export function partialAutocorrelation(values: Float64Array, lag: number): number;
+
+/**
+ * Compute the sample entropy of a time series.
+ *
+ * Measures the complexity/regularity of a time series. Lower values indicate
+ * more regularity. Unlike approximate entropy, excludes self-matches.
+ *
+ * @param values - Array of numeric values
+ * @param m - Embedding dimension (typically 2)
+ * @param r - Tolerance (typically 0.2 * standard deviation)
+ * @returns Sample entropy, or NaN if insufficient data
+ */
+export function sampleEntropy(values: Float64Array, m: number, r: number): number;
+
+/**
+ * Recommend models based on data profile characteristics.
+ *
+ * Returns an object with `recommended` (model names) and `reasoning` (explanations).
+ *
+ * @param profile - A JsDataProfile from profiling
+ * @param availableModels - Optional array of model names to filter by
+ */
+export function selectModels(profile: JsDataProfile, available_models?: string[] | null): any;
+
+/**
+ * Compute the skewness (third standardized moment) of a time series.
+ *
+ * Measures the asymmetry of the distribution.
+ *
+ * @param values - Array of numeric values
+ * @returns Skewness, or NaN if fewer than 3 values
+ */
+export function skewness(values: Float64Array): number;
+
+/**
+ * Perform STL (Seasonal-Trend decomposition using LOESS).
+ *
+ * Decomposes a time series into trend, seasonal, and remainder components.
+ *
+ * @param values - Array of numeric values
+ * @param period - Seasonal period (e.g., 12 for monthly data)
+ * @param robust - Enable robust fitting to reduce outlier influence (default: false)
+ * @returns Object with `trend`, `seasonal`, `remainder`, `seasonalStrength`, and `trendStrength`
+ */
+export function stlDecompose(values: Float64Array, period: number, robust?: boolean | null): any;
+
+/**
+ * Compute the population variance of a time series.
+ *
+ * Uses population formula (n denominator) matching tsfresh.
+ *
+ * @param values - Array of numeric values
+ * @returns Population variance, or NaN if empty
+ */
+export function variance(values: Float64Array): number;
+
 /**
  * Get the library version.
  */
@@ -511,17 +1970,40 @@ export interface InitOutput {
   readonly __wbg_adidaforecaster_free: (a: number, b: number) => void;
   readonly __wbg_arimaforecaster_free: (a: number, b: number) => void;
   readonly __wbg_autoarimaforecaster_free: (a: number, b: number) => void;
+  readonly __wbg_autoensembleforecaster_free: (a: number, b: number) => void;
   readonly __wbg_autoetsforecaster_free: (a: number, b: number) => void;
+  readonly __wbg_autoforecastbuilder_free: (a: number, b: number) => void;
+  readonly __wbg_autoforecaster_free: (a: number, b: number) => void;
   readonly __wbg_autotbatsforecaster_free: (a: number, b: number) => void;
   readonly __wbg_autothetaforecaster_free: (a: number, b: number) => void;
+  readonly __wbg_calendarannotations_free: (a: number, b: number) => void;
   readonly __wbg_crostonforecaster_free: (a: number, b: number) => void;
   readonly __wbg_dynamicthetaforecaster_free: (a: number, b: number) => void;
+  readonly __wbg_ensembleforecaster_free: (a: number, b: number) => void;
   readonly __wbg_etsforecaster_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_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_jsconformalpredictor_free: (a: number, b: number) => void;
+  readonly __wbg_jsconformalresult_free: (a: number, b: number) => void;
+  readonly __wbg_jsdataprofile_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_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_jspipelinebuilder_free: (a: number, b: number) => void;
+  readonly __wbg_jspipelinereport_free: (a: number, b: number) => void;
+  readonly __wbg_jspipelineresult_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_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;
   readonly __wbg_mflesforecaster_free: (a: number, b: number) => void;
   readonly __wbg_mstlforecasterwrapper_free: (a: number, b: number) => void;
@@ -537,10 +2019,14 @@ export interface InitOutput {
   readonly __wbg_tbatsforecaster_free: (a: number, b: number) => void;
   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 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 approximateEntropy: (a: number, b: number, c: number, d: 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;
@@ -551,6 +2037,16 @@ export interface InitOutput {
   readonly autoarimaforecaster_new: () => number;
   readonly autoarimaforecaster_predict: (a: number, b: number) => [number, number, number];
   readonly autoarimaforecaster_predictWithIntervals: (a: number, b: number, c: number) => [number, number, number];
+  readonly autocorrelation: (a: number, b: number, c: number) => number;
+  readonly autoensembleforecaster_allScores: (a: number) => [number, number, number];
+  readonly autoensembleforecaster_fit: (a: number, b: number) => [number, number];
+  readonly autoensembleforecaster_modelCount: (a: number) => number;
+  readonly autoensembleforecaster_name: (a: number) => [number, number];
+  readonly autoensembleforecaster_new: () => number;
+  readonly autoensembleforecaster_predict: (a: number, b: number) => [number, number, number];
+  readonly autoensembleforecaster_predictWithIntervals: (a: number, b: number, c: number) => [number, number, number];
+  readonly autoensembleforecaster_seasonal: (a: number) => number;
+  readonly autoensembleforecaster_withConfig: (a: number, b: number) => number;
   readonly autoetsforecaster_additiveOnly: () => number;
   readonly autoetsforecaster_fit: (a: number, b: number) => [number, number];
   readonly autoetsforecaster_name: (a: number) => [number, number];
@@ -558,6 +2054,22 @@ export interface InitOutput {
   readonly autoetsforecaster_predict: (a: number, b: number) => [number, number, number];
   readonly autoetsforecaster_withConfig: (a: number, b: number, c: number, d: number) => number;
   readonly autoetsforecaster_withPeriod: (a: number) => number;
+  readonly autoforecastbuilder_build: (a: number) => number;
+  readonly autoforecastbuilder_includeArima: (a: number, b: number) => number;
+  readonly autoforecastbuilder_includeEts: (a: number, b: number) => number;
+  readonly autoforecastbuilder_includeTheta: (a: number, b: number) => number;
+  readonly autoforecastbuilder_new: () => number;
+  readonly autoforecastbuilder_seasonalPeriod: (a: number, b: number) => number;
+  readonly autoforecastbuilder_useCrossValidation: (a: number, b: number) => number;
+  readonly autoforecaster_allScores: (a: number) => [number, number, number];
+  readonly autoforecaster_fit: (a: number, b: number) => [number, number];
+  readonly autoforecaster_name: (a: number) => [number, number];
+  readonly autoforecaster_new: () => number;
+  readonly autoforecaster_predict: (a: number, b: number) => [number, number, number];
+  readonly autoforecaster_predictWithIntervals: (a: number, b: number, c: number) => [number, number, number];
+  readonly autoforecaster_seasonal: (a: number) => number;
+  readonly autoforecaster_selectedModelName: (a: number) => [number, number];
+  readonly autoforecaster_withConfig: (a: number, b: number, c: number, d: number, e: number) => number;
   readonly autotbatsforecaster_fit: (a: number, b: number) => [number, number];
   readonly autotbatsforecaster_name: (a: number) => [number, number];
   readonly autotbatsforecaster_new: (a: number, b: number) => number;
@@ -567,10 +2079,32 @@ export interface InitOutput {
   readonly autothetaforecaster_new: () => number;
   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 bootstrapForecast: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number) => [number, 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];
+  readonly calendarannotations_getHolidays: (a: number) => [number, number];
+  readonly calendarannotations_getRegressor: (a: number, b: number, c: number) => [number, number];
+  readonly calendarannotations_hasRegressors: (a: number) => number;
+  readonly calendarannotations_holidayCount: (a: number) => number;
+  readonly calendarannotations_isBusinessDay: (a: number, b: number) => number;
+  readonly calendarannotations_isHoliday: (a: number, b: number) => number;
+  readonly calendarannotations_new: () => number;
+  readonly calendarannotations_regressorCount: (a: number) => number;
+  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 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];
   readonly crostonforecaster_new: () => number;
   readonly crostonforecaster_predict: (a: number, b: number) => [number, number, number];
+  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 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];
   readonly dynamicthetaforecaster_name: (a: number) => [number, number];
   readonly dynamicthetaforecaster_new: (a: number) => number;
@@ -578,37 +2112,181 @@ 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 ensembleforecaster_fit: (a: number, b: number) => [number, number];
+  readonly ensembleforecaster_modelCount: (a: number) => number;
+  readonly ensembleforecaster_name: (a: number) => [number, number];
+  readonly ensembleforecaster_new: (a: number, b: number) => [number, number, number];
+  readonly ensembleforecaster_predict: (a: number, b: number) => [number, number, number];
+  readonly ensembleforecaster_predictWithIntervals: (a: number, b: number, c: number) => [number, number, number];
+  readonly ensembleforecaster_setHorizonAdaptive: (a: number) => void;
+  readonly ensembleforecaster_setInverseAic: (a: number) => void;
+  readonly ensembleforecaster_setMedian: (a: number) => void;
+  readonly ensembleforecaster_setMethod: (a: number, b: number, c: number) => [number, number];
+  readonly ensembleforecaster_setStacking: (a: number, b: number) => void;
+  readonly ensembleforecaster_setWeightedMse: (a: number) => void;
+  readonly ensembleforecaster_setWeights: (a: number, b: number, c: number) => void;
   readonly etsforecaster_fit: (a: number, b: number) => [number, number];
   readonly etsforecaster_fromNotation: (a: number, b: number, c: number) => [number, number, number];
   readonly etsforecaster_isValidSpec: (a: number, b: number, c: number, d: number, e: number, f: number) => number;
   readonly etsforecaster_name: (a: number) => [number, number];
   readonly etsforecaster_new: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => [number, number, number];
   readonly etsforecaster_predict: (a: number, b: number) => [number, number, number];
+  readonly explainResult: (a: number, b: number, c: number) => [number, number, number];
+  readonly forecast_clamp: (a: number, b: number, c: number) => number;
   readonly forecast_hasLower: (a: number) => number;
   readonly forecast_hasUpper: (a: number) => number;
   readonly forecast_horizon: (a: number) => number;
   readonly forecast_lower: (a: number) => [number, number];
+  readonly forecast_nonNegative: (a: number) => number;
+  readonly forecast_roundToInteger: (a: number) => number;
   readonly forecast_upper: (a: number) => [number, number];
   readonly forecast_values: (a: 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 holtforecaster_fit: (a: number, b: number) => [number, number];
   readonly holtforecaster_name: (a: number) => [number, number];
   readonly holtforecaster_new: (a: number, b: number) => number;
   readonly holtforecaster_predict: (a: number, b: number) => [number, number, number];
+  readonly holtforecaster_predictWithIntervals: (a: number, b: number, c: number) => [number, number, number];
   readonly holtwintersforecaster_auto: (a: number, b: number, c: number) => [number, number, number];
   readonly holtwintersforecaster_fit: (a: number, b: number) => [number, number];
   readonly holtwintersforecaster_multiplicative: (a: number, b: number, c: number, d: number) => number;
   readonly holtwintersforecaster_name: (a: number) => [number, number];
   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 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 init: () => void;
+  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;
+  readonly jsbacktestconfig_initialWindow: (a: number, b: number) => number;
+  readonly jsbacktestconfig_new: () => number;
+  readonly jsbacktestconfig_step: (a: number, b: number) => number;
+  readonly jsbacktestresult_calibrationError: (a: number, b: number) => number;
+  readonly jsbacktestresult_coverage: (a: number) => number;
+  readonly jsbacktestresult_intervalWidths: (a: number) => number;
+  readonly jsbacktestresult_numFolds: (a: number) => number;
+  readonly jsconformalpredictor_calibrate: (a: number, b: number, c: number, d: number, e: number) => [number, number, number];
+  readonly jsconformalpredictor_crossVal: (a: number, b: number) => number;
+  readonly jsconformalpredictor_jackknifePlus: (a: number) => number;
+  readonly jsconformalpredictor_new: (a: number) => number;
+  readonly jsconformalpredictor_predictIntervals: (a: number, b: number, c: number, d: number) => number;
+  readonly jsconformalresult_coverage: (a: number) => number;
+  readonly jsconformalresult_quantileValue: (a: number) => number;
+  readonly jsconformalresult_scores: (a: number) => [number, number];
+  readonly jsdataprofile_acfLag1: (a: number) => number;
+  readonly jsdataprofile_acfLag2: (a: number) => number;
+  readonly jsdataprofile_adfIsStationary: (a: number) => number;
+  readonly jsdataprofile_adfPValue: (a: number) => number;
+  readonly jsdataprofile_adfStatistic: (a: number) => number;
+  readonly jsdataprofile_approximateEntropy: (a: number) => [number, number];
+  readonly jsdataprofile_fromSeries: (a: number) => number;
+  readonly jsdataprofile_fromValues: (a: number, b: number) => number;
+  readonly jsdataprofile_hasNegatives: (a: number) => number;
+  readonly jsdataprofile_isInteger: (a: number) => number;
+  readonly jsdataprofile_isIntermittent: (a: number) => number;
+  readonly jsdataprofile_isStationary: (a: number) => number;
+  readonly jsdataprofile_kpssIsStationary: (a: number) => number;
+  readonly jsdataprofile_kpssPValue: (a: number) => number;
+  readonly jsdataprofile_kpssStatistic: (a: number) => number;
+  readonly jsdataprofile_kurtosis: (a: number) => number;
+  readonly jsdataprofile_lempelZiv: (a: number) => number;
+  readonly jsdataprofile_max: (a: number) => number;
+  readonly jsdataprofile_min: (a: number) => number;
+  readonly jsdataprofile_missingCount: (a: number) => number;
+  readonly jsdataprofile_nObservations: (a: number) => number;
+  readonly jsdataprofile_partialAcfLag1: (a: number) => number;
+  readonly jsdataprofile_qualityScore: (a: number) => number;
+  readonly jsdataprofile_skewness: (a: number) => number;
+  readonly jsdataprofile_summary: (a: number) => [number, number];
+  readonly jsdataprofile_toJSON: (a: number) => [number, number, number];
+  readonly jsdataprofile_toString: (a: number) => [number, number];
+  readonly jsdataprofile_trendDirection: (a: number) => [number, number];
+  readonly jsdataprofile_trendSlope: (a: number) => number;
+  readonly jsdataprofile_trendStrength: (a: number) => number;
+  readonly jsdataprofile_zeroFraction: (a: number) => number;
+  readonly jshistoricalsimresult_errors: (a: number) => [number, number];
+  readonly jshistoricalsimresult_quantileValues: (a: number) => [number, number];
+  readonly jshistoricalsimulator_new: (a: number, b: number) => number;
+  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 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_residualPacf: (a: number) => [number, number];
+  readonly jsmodeldiagnostics_summary: (a: number) => [number, number];
+  readonly jsnormalpredictor_fit: (a: number, b: number, c: number, d: number, e: number) => [number, number, number];
+  readonly jsnormalpredictor_new: (a: number, b: number) => number;
+  readonly jsnormalpredictor_predictIntervals: (a: number, b: number, c: number, d: number) => [number, number, number];
+  readonly jspipelinebuilder_addModel: (a: number, b: number, c: number) => number;
+  readonly jspipelinebuilder_addSeasonalModel: (a: number, b: number, c: number, d: number) => number;
+  readonly jspipelinebuilder_crossValidate: (a: number, b: number, c: number) => number;
+  readonly jspipelinebuilder_ensemble: (a: number, b: number, c: number) => number;
+  readonly jspipelinebuilder_execute: (a: number, b: number, c: number) => [number, number, number];
+  readonly jspipelinebuilder_metric: (a: number, b: number, c: number) => number;
+  readonly jspipelinebuilder_new: () => number;
+  readonly jspipelinebuilder_nonNegative: (a: number) => number;
+  readonly jspipelinebuilder_preprocess: (a: number, b: number, c: number) => number;
+  readonly jspipelinebuilder_profile: (a: number) => number;
+  readonly jspipelinebuilder_seasonalPeriod: (a: number, b: number) => number;
+  readonly jspipelinebuilder_selectModels: (a: number, b: number) => number;
+  readonly jspipelinebuilder_withFallback: (a: number) => number;
+  readonly jspipelinereport_sectionCount: (a: number) => number;
+  readonly jspipelinereport_sectionHeading: (a: number, b: number) => [number, number];
+  readonly jspipelinereport_title: (a: number) => [number, number];
+  readonly jspipelinereport_toJSON: (a: number) => [number, number, number];
+  readonly jspipelinereport_toString: (a: number) => [number, number];
+  readonly jspipelineresult_decisionCount: (a: number) => number;
+  readonly jspipelineresult_decisionLog: (a: number) => [number, number];
+  readonly jspipelineresult_ensembleWeights: (a: number) => [number, number, number];
+  readonly jspipelineresult_forecast: (a: number) => number;
+  readonly jspipelineresult_metricScores: (a: number) => [number, number, number];
+  readonly jspipelineresult_modelConfidenceSet: (a: number) => [number, number, number];
+  readonly jspipelineresult_modelName: (a: number) => [number, number];
+  readonly jspipelineresult_preprocessInfo: (a: number) => [number, number, number];
+  readonly jspipelineresult_profile: (a: number) => number;
+  readonly jspipelineresult_qualityFloor: (a: number) => [number, number];
+  readonly jspipelineresult_report: (a: number) => number;
+  readonly jspipelineresult_selectionConfidence: (a: number) => [number, number];
+  readonly jspipelineresult_toString: (a: number) => [number, number];
+  readonly jspointforecasts_isEmpty: (a: number) => number;
+  readonly jspointforecasts_length: (a: number) => number;
+  readonly jspointforecasts_new: (a: number, b: number) => number;
+  readonly jspointforecasts_values: (a: number) => [number, number];
+  readonly jspostprocessor_conformal: (a: number) => number;
+  readonly jspostprocessor_historicalSim: (a: number, b: number) => number;
+  readonly jspostprocessor_normal: (a: number, b: number) => number;
+  readonly jspostprocessor_predictIntervals: (a: number, b: number, c: number) => [number, number, number];
+  readonly jspostprocessor_train: (a: number, b: number, c: number, d: number) => [number, number, number];
+  readonly jspredictionintervals_empiricalCoverage: (a: number, b: number, c: number) => [number, number];
+  readonly jspredictionintervals_length: (a: number) => number;
+  readonly jspredictionintervals_lower: (a: number) => [number, number];
+  readonly jspredictionintervals_midpoints: (a: number) => [number, number];
+  readonly jspredictionintervals_upper: (a: number) => [number, number];
+  readonly jspredictionintervals_widths: (a: number) => [number, number];
+  readonly kalmanforecaster_fit: (a: number, b: number) => [number, number];
+  readonly kalmanforecaster_localLevel: (a: number, b: number) => number;
+  readonly kalmanforecaster_localLinearTrend: (a: number, b: number, c: number) => number;
+  readonly kalmanforecaster_name: (a: number) => [number, number];
+  readonly kalmanforecaster_predict: (a: number, b: number) => [number, number, number];
+  readonly kalmanforecaster_predictWithIntervals: (a: number, b: number, c: number) => [number, number, number];
+  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 ljungBox: (a: number, b: number, c: number, d: number) => [number, number, number];
+  readonly mean: (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;
@@ -618,6 +2296,8 @@ export interface InitOutput {
   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 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];
   readonly mstlforecasterwrapper_new: (a: number, b: number) => number;
@@ -632,11 +2312,13 @@ export interface InitOutput {
   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 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 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];
   readonly sarimaforecaster_new: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => number;
@@ -655,27 +2337,39 @@ export interface InitOutput {
   readonly seasonalwindowaverageforecaster_name: (a: number) => [number, number];
   readonly seasonalwindowaverageforecaster_new: (a: number, b: number) => number;
   readonly seasonalwindowaverageforecaster_predict: (a: number, b: number) => [number, number, number];
+  readonly selectModels: (a: number, b: number, c: number) => [number, number, number];
   readonly sesforecaster_fit: (a: number, b: number) => [number, number];
   readonly sesforecaster_name: (a: number) => [number, number];
   readonly sesforecaster_new: (a: number) => number;
   readonly sesforecaster_predict: (a: number, b: number) => [number, number, number];
+  readonly sesforecaster_predictWithIntervals: (a: number, b: number, c: number) => [number, number, number];
+  readonly skewness: (a: number, b: number) => number;
   readonly smaforecaster_fit: (a: number, b: number) => [number, number];
   readonly smaforecaster_name: (a: number) => [number, number];
   readonly smaforecaster_new: (a: number) => number;
   readonly smaforecaster_predict: (a: number, b: number) => [number, number, number];
+  readonly stlDecompose: (a: number, b: number, c: number, d: number) => [number, 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;
   readonly tbatsforecaster_predict: (a: number, b: number) => [number, number, number];
+  readonly tbatsforecaster_predictWithIntervals: (a: number, b: number, c: number) => [number, number, number];
+  readonly tbatsforecaster_setArma: (a: number, b: number, c: number) => void;
+  readonly tbatsforecaster_setBoxCox: (a: number, b: number) => void;
+  readonly tbatsforecaster_setDampedTrend: (a: number, b: number) => void;
+  readonly tbatsforecaster_setFourierK: (a: number, b: number, c: number) => void;
   readonly thetaforecaster_fit: (a: number, b: number) => [number, number];
   readonly thetaforecaster_name: (a: number) => [number, number];
   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 timeseries_clearCalendar: (a: number) => void;
+  readonly timeseries_hasCalendar: (a: number) => number;
   readonly timeseries_hasMissingValues: (a: number) => number;
   readonly timeseries_isEmpty: (a: number) => number;
   readonly timeseries_length: (a: number) => number;
   readonly timeseries_new: (a: number, b: number) => [number, number, number];
+  readonly timeseries_setCalendar: (a: number, b: number) => void;
   readonly timeseries_slice: (a: number, b: number, c: number) => [number, number, number];
   readonly timeseries_values: (a: number) => [number, number];
   readonly timeseries_withTimestamps: (a: number, b: number, c: number, d: number) => [number, number, number];
@@ -683,16 +2377,36 @@ export interface InitOutput {
   readonly tsbforecaster_name: (a: number) => [number, number];
   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 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];
+  readonly varforecaster_new: (a: number) => number;
+  readonly varforecaster_order: (a: number) => number;
+  readonly varforecaster_predictMultivariate: (a: number, b: number) => [number, number, number];
+  readonly variance: (a: number, b: number) => number;
   readonly version: () => [number, number];
   readonly windowaverageforecaster_fit: (a: number, b: number) => [number, number];
   readonly windowaverageforecaster_name: (a: number) => [number, number];
   readonly windowaverageforecaster_new: (a: number) => number;
   readonly windowaverageforecaster_predict: (a: number, b: number) => [number, number, number];
+  readonly tbatsforecaster_withSeasonalPeriods: (a: number, b: number) => number;
   readonly __wbg_tsbforecaster_free: (a: number, b: number) => void;
   readonly __wbg_windowaverageforecaster_free: (a: number, b: number) => void;
-  readonly __wbindgen_externrefs: WebAssembly.Table;
+  readonly jsdataprofile_mean: (a: number) => number;
+  readonly jsdataprofile_stdDev: (a: number) => number;
+  readonly jsmodeldiagnostics_heteroscedasticityPvalue: (a: number) => number;
+  readonly jsmodeldiagnostics_jarqueBeraPvalue: (a: number) => number;
+  readonly jsmodeldiagnostics_residualMean: (a: number) => number;
+  readonly jsmodeldiagnostics_residualStd: (a: number) => number;
+  readonly jsnormalresult_mean: (a: number) => number;
+  readonly jsnormalresult_stdDev: (a: number) => number;
+  readonly jspredictionintervals_coverage: (a: 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;
+  readonly __externref_table_alloc: () => number;
+  readonly __wbindgen_externrefs: WebAssembly.Table;
   readonly __externref_table_dealloc: (a: number) => void;
   readonly __wbindgen_free: (a: number, b: number, c: number) => void;
   readonly __wbindgen_start: () => void;