@sipemu/anofox-forecast 0.4.3 → 0.4.5

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,134 @@ 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 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 +212,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,6 +383,65 @@ export class ETSForecaster {
   readonly name: string;
 }
 
+export class EnsembleForecaster {
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Set the combination method to median.
+   */
+  setMedian(): 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 weighted MSE.
+   */
+  setWeightedMse(): 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;
@@ -202,6 +479,7 @@ export class Forecast {
 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)
@@ -215,6 +493,7 @@ export class GARCHForecaster {
 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)
@@ -232,6 +511,7 @@ export class HoltWintersForecaster {
    * 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.
@@ -254,15 +534,308 @@ export class HoltWintersForecaster {
 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 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 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 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)
+   */
+  static historicalSim(quantiles: Float64Array): JsPostProcessor;
+  /**
+   * Generate prediction intervals from a trained model.
+   *
+   * @param trained - A JsTrainedModel from train()
+   * @param forecasts - New point forecasts
+   */
+  predictIntervals(trained: JsTrainedModel, forecasts: JsPointForecasts): JsPredictionIntervals;
+  /**
+   * Train the postprocessor on historical data.
+   *
+   * @param forecasts - JsPointForecasts with historical predictions
+   * @param actuals - Corresponding actual observed values
+   */
+  train(forecasts: JsPointForecasts, actuals: Float64Array): JsTrainedModel;
+  /**
+   * Create a normal prediction postprocessor.
+   *
+   * @param quantiles - Sorted quantile levels in (0,1)
+   */
+  static normal(quantiles: Float64Array): JsPostProcessor;
+  /**
+   * Create a conformal prediction postprocessor.
+   *
+   * @param coverage - Target coverage level in (0, 1), e.g. 0.90
+   */
+  static conformal(coverage: number): JsPostProcessor;
+}
+
+export class JsPredictionIntervals {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Compute empirical coverage given actual values.
+   */
+  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 JsTrainedModel {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+}
+
 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 +919,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 +982,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 +1053,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.
    *
@@ -492,6 +1123,133 @@ 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;
+
 /**
  * Initialize the WASM module.
  *
@@ -499,6 +1257,134 @@ 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;
+
+/**
+ * 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 +1397,33 @@ 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_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_jshistoricalsimresult_free: (a: number, b: number) => void;
+  readonly __wbg_jshistoricalsimulator_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_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_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 +1439,13 @@ 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 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 +1456,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 +1473,15 @@ 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 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 +1491,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,6 +1524,15 @@ 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_setMedian: (a: 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;
@@ -594,21 +1549,73 @@ export interface InitOutput {
   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 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 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 jsnormalresult_mean: (a: number) => number;
+  readonly jsnormalresult_stdDev: (a: 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 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 +1625,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 +1641,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;
@@ -659,23 +1670,34 @@ export interface InitOutput {
   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 +1705,22 @@ 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 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 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;