@sipemu/anofox-forecast 0.4.5 → 0.4.7

package/README.md

@@ -1,6 +1,6 @@
 # @sipemu/anofox-forecast
 
-WebAssembly bindings for [anofox-forecast](https://crates.io/crates/anofox-forecast), a comprehensive time series forecasting library with 40+ models, automatic model selection, probabilistic postprocessing, and more.
+WebAssembly bindings for [anofox-forecast](https://crates.io/crates/anofox-forecast), a comprehensive time series forecasting library with 50+ models, automatic model selection, probabilistic postprocessing, and more.
 
 ## Installation
 
@@ -281,8 +281,7 @@ const forecast = model.predict(10);
 ## Limitations
 
 - The `parallel` feature from the Rust crate is not available in WASM
-- Postprocessing features (conformal prediction, IDR) are not yet exposed
-- Cross-validation utilities are not yet exposed
+- IDR (Isotonic Distributional Regression) and QRA are not yet exposed in WASM
 
 ## License
 

package/anofox_forecast_js.d.ts

@@ -123,6 +123,51 @@ export class AutoEnsembleForecaster {
   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;
@@ -390,6 +435,15 @@ export class EnsembleForecaster {
    * 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.
    */
@@ -402,10 +456,31 @@ export class EnsembleForecaster {
    * @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.
    *
@@ -446,6 +521,22 @@ export class Forecast {
   private constructor();
   free(): void;
   [Symbol.dispose](): void;
+  /**
+   * 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.
    */
@@ -692,6 +783,63 @@ export class JsHistoricalSimulator {
   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;
@@ -832,6 +980,59 @@ export class JsTrainedModel {
   [Symbol.dispose](): void;
 }
 
+export class KalmanForecaster {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Create a local level (random walk plus noise) model.
+   *
+   * @param obs_noise - Observation noise variance
+   * @param state_noise - State (level) noise variance
+   */
+  static localLevel(obs_noise: number, state_noise: number): KalmanForecaster;
+  /**
+   * Create a local linear trend model.
+   *
+   * @param obs_noise - Observation noise variance
+   * @param level_noise - Level noise variance
+   * @param trend_noise - Trend noise variance
+   */
+  static localLinearTrend(obs_noise: number, level_noise: number, trend_noise: number): KalmanForecaster;
+  /**
+   * 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
+   */
+  fit(series: TimeSeries): void;
+  /**
+   * 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;
@@ -1111,6 +1312,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;
@@ -1399,6 +1642,7 @@ export interface InitOutput {
   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;
@@ -1418,12 +1662,14 @@ export interface InitOutput {
   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_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_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;
@@ -1435,10 +1681,10 @@ export interface InitOutput {
   readonly __wbg_seasonalnaiveforecaster_free: (a: number, b: number) => void;
   readonly __wbg_seasonalwindowaverageforecaster_free: (a: number, b: number) => void;
   readonly __wbg_sesforecaster_free: (a: number, b: number) => void;
-  readonly __wbg_smaforecaster_free: (a: number, b: number) => void;
   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];
@@ -1473,6 +1719,13 @@ 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];
@@ -1530,7 +1783,11 @@ export interface InitOutput {
   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];
@@ -1539,10 +1796,13 @@ export interface InitOutput {
   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 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];
@@ -1592,11 +1852,19 @@ export interface InitOutput {
   readonly jshistoricalsimulator_predictIntervals: (a: number, b: number, c: number, d: number) => [number, number, number];
   readonly jshistoricalsimulator_simulate: (a: number, b: number, c: number, d: number, e: number) => [number, number, number];
   readonly jshistoricalsimulator_withWindow: (a: number, b: number, c: number) => number;
+  readonly jsmodeldiagnostics_fromResiduals: (a: number, b: number, c: number) => number;
+  readonly jsmodeldiagnostics_jarqueBeraStatistic: (a: number) => number;
+  readonly jsmodeldiagnostics_ljungBoxLags: (a: number) => number;
+  readonly jsmodeldiagnostics_ljungBoxPvalue: (a: number) => number;
+  readonly jsmodeldiagnostics_passesAll: (a: number) => number;
+  readonly jsmodeldiagnostics_residualAcf: (a: number) => [number, number];
+  readonly jsmodeldiagnostics_residualMean: (a: number) => number;
+  readonly jsmodeldiagnostics_residualPacf: (a: number) => [number, number];
+  readonly jsmodeldiagnostics_residualStd: (a: 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 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;
@@ -1612,6 +1880,13 @@ export interface InitOutput {
   readonly jspredictionintervals_midpoints: (a: number) => [number, number];
   readonly jspredictionintervals_upper: (a: number) => [number, number];
   readonly jspredictionintervals_widths: (a: number) => [number, number];
+  readonly 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];
@@ -1706,6 +1981,12 @@ export interface InitOutput {
   readonly tsbforecaster_new: () => number;
   readonly tsbforecaster_predict: (a: number, b: number) => [number, number, number];
   readonly tsbforecaster_predictWithIntervals: (a: number, b: number, c: number) => [number, number, number];
+  readonly 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];
@@ -1713,8 +1994,13 @@ export interface InitOutput {
   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_smaforecaster_free: (a: number, b: number) => void;
   readonly __wbg_tsbforecaster_free: (a: number, b: number) => void;
   readonly __wbg_windowaverageforecaster_free: (a: number, b: number) => void;
+  readonly jsmodeldiagnostics_heteroscedasticityPvalue: (a: number) => number;
+  readonly jsmodeldiagnostics_jarqueBeraPvalue: (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;

package/anofox_forecast_js.js

@@ -188,6 +188,10 @@ const AutoEnsembleForecasterFinalization = (typeof FinalizationRegistry === 'und
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_autoensembleforecaster_free(ptr >>> 0, 1));
 
+const AutoForecastBuilderFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_autoforecastbuilder_free(ptr >>> 0, 1));
+
 const AutoForecasterFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_autoforecaster_free(ptr >>> 0, 1));
@@ -264,6 +268,10 @@ const JsHistoricalSimulatorFinalization = (typeof FinalizationRegistry === 'unde
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_jshistoricalsimulator_free(ptr >>> 0, 1));
 
+const JsModelDiagnosticsFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_jsmodeldiagnostics_free(ptr >>> 0, 1));
+
 const JsNormalPredictorFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_jsnormalpredictor_free(ptr >>> 0, 1));
@@ -288,6 +296,10 @@ const JsTrainedModelFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_jstrainedmodel_free(ptr >>> 0, 1));
 
+const KalmanForecasterFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_kalmanforecaster_free(ptr >>> 0, 1));
+
 const MFLESForecasterFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_mflesforecaster_free(ptr >>> 0, 1));
@@ -352,6 +364,10 @@ const TimeSeriesFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_timeseries_free(ptr >>> 0, 1));
 
+const VARForecasterFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_varforecaster_free(ptr >>> 0, 1));
+
 const WindowAverageForecasterFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_windowaverageforecaster_free(ptr >>> 0, 1));
@@ -825,6 +841,113 @@ export class AutoEnsembleForecaster {
 }
 if (Symbol.dispose) AutoEnsembleForecaster.prototype[Symbol.dispose] = AutoEnsembleForecaster.prototype.free;
 
+/**
+ * Builder for constructing an AutoForecaster with custom parameters.
+ *
+ * Uses a fluent API: chain setter methods and call `build()` to produce
+ * an `AutoForecaster`.
+ */
+export class AutoForecastBuilder {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(AutoForecastBuilder.prototype);
+        obj.__wbg_ptr = ptr;
+        AutoForecastBuilderFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        AutoForecastBuilderFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_autoforecastbuilder_free(ptr, 0);
+    }
+    /**
+     * Include or exclude AutoETS from the candidate set.
+     *
+     * @param include - Whether to include AutoETS (default: true)
+     * @param {boolean} include
+     * @returns {AutoForecastBuilder}
+     */
+    includeEts(include) {
+        const ptr = this.__destroy_into_raw();
+        const ret = wasm.autoforecastbuilder_includeEts(ptr, include);
+        return AutoForecastBuilder.__wrap(ret);
+    }
+    /**
+     * Include or exclude AutoARIMA from the candidate set.
+     *
+     * @param include - Whether to include AutoARIMA (default: true)
+     * @param {boolean} include
+     * @returns {AutoForecastBuilder}
+     */
+    includeArima(include) {
+        const ptr = this.__destroy_into_raw();
+        const ret = wasm.autoforecastbuilder_includeArima(ptr, include);
+        return AutoForecastBuilder.__wrap(ret);
+    }
+    /**
+     * Include or exclude AutoTheta from the candidate set.
+     *
+     * @param include - Whether to include AutoTheta (default: true)
+     * @param {boolean} include
+     * @returns {AutoForecastBuilder}
+     */
+    includeTheta(include) {
+        const ptr = this.__destroy_into_raw();
+        const ret = wasm.autoforecastbuilder_includeTheta(ptr, include);
+        return AutoForecastBuilder.__wrap(ret);
+    }
+    /**
+     * Set the seasonal period.
+     *
+     * @param period - Seasonal period (e.g., 12 for monthly data)
+     * @param {number} period
+     * @returns {AutoForecastBuilder}
+     */
+    seasonalPeriod(period) {
+        const ptr = this.__destroy_into_raw();
+        const ret = wasm.autoforecastbuilder_seasonalPeriod(ptr, period);
+        return AutoForecastBuilder.__wrap(ret);
+    }
+    /**
+     * Use cross-validation instead of in-sample MSE for model selection.
+     *
+     * @param useCv - Whether to use cross-validation (default: false)
+     * @param {boolean} use_cv
+     * @returns {AutoForecastBuilder}
+     */
+    useCrossValidation(use_cv) {
+        const ptr = this.__destroy_into_raw();
+        const ret = wasm.autoforecastbuilder_useCrossValidation(ptr, use_cv);
+        return AutoForecastBuilder.__wrap(ret);
+    }
+    /**
+     * Create a new builder with all defaults enabled.
+     */
+    constructor() {
+        const ret = wasm.autoforecastbuilder_new();
+        this.__wbg_ptr = ret >>> 0;
+        AutoForecastBuilderFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * Build the AutoForecaster with the configured parameters.
+     *
+     * @returns A new AutoForecaster ready to fit
+     * @returns {AutoForecaster}
+     */
+    build() {
+        const ptr = this.__destroy_into_raw();
+        const ret = wasm.autoforecastbuilder_build(ptr);
+        return AutoForecaster.__wrap(ret);
+    }
+}
+if (Symbol.dispose) AutoForecastBuilder.prototype[Symbol.dispose] = AutoForecastBuilder.prototype.free;
+
 /**
  * Automatic model selection across ARIMA, ETS, and Theta families.
  *
@@ -1688,6 +1811,23 @@ export class EnsembleForecaster {
     setMedian() {
         wasm.ensembleforecaster_setMedian(this.__wbg_ptr);
     }
+    /**
+     * Set the combination method by name string.
+     *
+     * Supported values: "mean", "median", "weighted_mse", "inverse_aic",
+     * "stacking", "horizon_adaptive".
+     *
+     * @param method - Combination method name
+     * @param {string} method
+     */
+    setMethod(method) {
+        const ptr0 = passStringToWasm0(method, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.ensembleforecaster_setMethod(this.__wbg_ptr, ptr0, len0);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
     /**
      * Get the number of models in the ensemble.
      * @returns {number}
@@ -1709,12 +1849,40 @@ export class EnsembleForecaster {
         const len0 = WASM_VECTOR_LEN;
         wasm.ensembleforecaster_setWeights(this.__wbg_ptr, ptr0, len0);
     }
+    /**
+     * 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)
+     * @param {number | null} [folds]
+     */
+    setStacking(folds) {
+        wasm.ensembleforecaster_setStacking(this.__wbg_ptr, isLikeNone(folds) ? 0x100000001 : (folds) >>> 0);
+    }
+    /**
+     * Set the combination method to inverse AIC weighting.
+     *
+     * Computes Akaike weights from in-sample residuals.
+     */
+    setInverseAic() {
+        wasm.ensembleforecaster_setInverseAic(this.__wbg_ptr);
+    }
     /**
      * Set the combination method to weighted MSE.
      */
     setWeightedMse() {
         wasm.ensembleforecaster_setWeightedMse(this.__wbg_ptr);
     }
+    /**
+     * Set the combination method to per-horizon adaptive weighting.
+     *
+     * Computes separate weight vectors for each forecast horizon step
+     * based on rolling-origin evaluation.
+     */
+    setHorizonAdaptive() {
+        wasm.ensembleforecaster_setHorizonAdaptive(this.__wbg_ptr);
+    }
     /**
      * Predict with prediction intervals.
      *
@@ -1822,6 +1990,36 @@ export class Forecast {
         const ptr = this.__destroy_into_raw();
         wasm.__wbg_forecast_free(ptr, 0);
     }
+    /**
+     * Return a new forecast with all values clamped to be non-negative.
+     * @returns {Forecast}
+     */
+    nonNegative() {
+        const ret = wasm.forecast_nonNegative(this.__wbg_ptr);
+        return Forecast.__wrap(ret);
+    }
+    /**
+     * Return a new forecast with point values rounded to the nearest integer,
+     * lower intervals floored, and upper intervals ceiled.
+     * @returns {Forecast}
+     */
+    roundToInteger() {
+        const ret = wasm.forecast_roundToInteger(this.__wbg_ptr);
+        return Forecast.__wrap(ret);
+    }
+    /**
+     * Return a new forecast with all values clamped to `[lower, upper]`.
+     *
+     * @param lower - Lower bound
+     * @param upper - Upper bound
+     * @param {number} lower
+     * @param {number} upper
+     * @returns {Forecast}
+     */
+    clamp(lower, upper) {
+        const ret = wasm.forecast_clamp(this.__wbg_ptr, lower, upper);
+        return Forecast.__wrap(ret);
+    }
     /**
      * Get lower prediction interval bounds.
      *
@@ -2649,6 +2847,148 @@ export class JsHistoricalSimulator {
 }
 if (Symbol.dispose) JsHistoricalSimulator.prototype[Symbol.dispose] = JsHistoricalSimulator.prototype.free;
 
+/**
+ * Complete model diagnostics report.
+ *
+ * Includes Ljung-Box, Jarque-Bera, and Breusch-Pagan tests, plus
+ * residual ACF/PACF and summary statistics.
+ */
+export class JsModelDiagnostics {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(JsModelDiagnostics.prototype);
+        obj.__wbg_ptr = ptr;
+        JsModelDiagnosticsFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        JsModelDiagnosticsFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_jsmodeldiagnostics_free(ptr, 0);
+    }
+    /**
+     * Whether all diagnostic tests pass at the configured significance level.
+     * @returns {boolean}
+     */
+    get passesAll() {
+        const ret = wasm.jsmodeldiagnostics_passesAll(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * Autocorrelation function of the residuals.
+     * @returns {Float64Array}
+     */
+    get residualAcf() {
+        const ret = wasm.jsmodeldiagnostics_residualAcf(this.__wbg_ptr);
+        var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+        return v1;
+    }
+    /**
+     * Standard deviation of the residuals.
+     * @returns {number}
+     */
+    get residualStd() {
+        const ret = wasm.jsmodeldiagnostics_residualStd(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Mean of the residuals.
+     * @returns {number}
+     */
+    get residualMean() {
+        const ret = wasm.jsmodeldiagnostics_residualMean(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Partial autocorrelation function of the residuals.
+     * @returns {Float64Array}
+     */
+    get residualPacf() {
+        const ret = wasm.jsmodeldiagnostics_residualPacf(this.__wbg_ptr);
+        var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+        return v1;
+    }
+    /**
+     * Create diagnostics from an array of residuals.
+     *
+     * @param residuals - Array of model residuals
+     * @param significance - Significance level for tests (e.g., 0.05)
+     * @param {Float64Array} residuals
+     * @param {number} significance
+     * @returns {JsModelDiagnostics}
+     */
+    static fromResiduals(residuals, significance) {
+        const ptr0 = passArrayF64ToWasm0(residuals, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.jsmodeldiagnostics_fromResiduals(ptr0, len0, significance);
+        return JsModelDiagnostics.__wrap(ret);
+    }
+    /**
+     * Number of lags used in the Ljung-Box test.
+     * @returns {number}
+     */
+    get ljungBoxLags() {
+        const ret = wasm.jsmodeldiagnostics_ljungBoxLags(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Ljung-Box test p-value for autocorrelation.
+     * @returns {number}
+     */
+    get ljungBoxPvalue() {
+        const ret = wasm.jsmodeldiagnostics_ljungBoxPvalue(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Jarque-Bera test p-value.
+     * @returns {number}
+     */
+    get jarqueBeraPvalue() {
+        const ret = wasm.jsconformalresult_quantileValue(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Jarque-Bera test statistic for normality.
+     * @returns {number}
+     */
+    get jarqueBeraStatistic() {
+        const ret = wasm.jsmodeldiagnostics_jarqueBeraStatistic(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Breusch-Pagan heteroscedasticity test p-value.
+     * @returns {number}
+     */
+    get heteroscedasticityPvalue() {
+        const ret = wasm.jsconformalresult_coverage(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Get a human-readable summary of the diagnostics.
+     * @returns {string}
+     */
+    summary() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.jsmodeldiagnostics_summary(this.__wbg_ptr);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
+}
+if (Symbol.dispose) JsModelDiagnostics.prototype[Symbol.dispose] = JsModelDiagnostics.prototype.free;
+
 /**
  * Normal predictor — assumes Gaussian forecast errors.
  *
@@ -2750,7 +3090,7 @@ export class JsNormalResult {
      * @returns {number}
      */
     get mean() {
-        const ret = wasm.jsnormalresult_mean(this.__wbg_ptr);
+        const ret = wasm.jsmodeldiagnostics_ljungBoxPvalue(this.__wbg_ptr);
         return ret;
     }
     /**
@@ -2758,7 +3098,7 @@ export class JsNormalResult {
      * @returns {number}
      */
     stdDev() {
-        const ret = wasm.jsnormalresult_stdDev(this.__wbg_ptr);
+        const ret = wasm.jsmodeldiagnostics_jarqueBeraStatistic(this.__wbg_ptr);
         return ret;
     }
 }
@@ -2995,7 +3335,7 @@ export class JsPredictionIntervals {
      * @returns {number}
      */
     get coverage() {
-        const ret = wasm.jsnormalresult_mean(this.__wbg_ptr);
+        const ret = wasm.jsmodeldiagnostics_ljungBoxPvalue(this.__wbg_ptr);
         return ret;
     }
     /**
@@ -3037,6 +3377,139 @@ export class JsTrainedModel {
 }
 if (Symbol.dispose) JsTrainedModel.prototype[Symbol.dispose] = JsTrainedModel.prototype.free;
 
+/**
+ * Kalman filter forecaster for state-space models.
+ *
+ * Supports local level and local linear trend models out of the box.
+ */
+export class KalmanForecaster {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(KalmanForecaster.prototype);
+        obj.__wbg_ptr = ptr;
+        KalmanForecasterFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        KalmanForecasterFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_kalmanforecaster_free(ptr, 0);
+    }
+    /**
+     * Create a local level (random walk plus noise) model.
+     *
+     * @param obs_noise - Observation noise variance
+     * @param state_noise - State (level) noise variance
+     * @param {number} obs_noise
+     * @param {number} state_noise
+     * @returns {KalmanForecaster}
+     */
+    static localLevel(obs_noise, state_noise) {
+        const ret = wasm.kalmanforecaster_localLevel(obs_noise, state_noise);
+        return KalmanForecaster.__wrap(ret);
+    }
+    /**
+     * Create a local linear trend model.
+     *
+     * @param obs_noise - Observation noise variance
+     * @param level_noise - Level noise variance
+     * @param trend_noise - Trend noise variance
+     * @param {number} obs_noise
+     * @param {number} level_noise
+     * @param {number} trend_noise
+     * @returns {KalmanForecaster}
+     */
+    static localLinearTrend(obs_noise, level_noise, trend_noise) {
+        const ret = wasm.kalmanforecaster_localLinearTrend(obs_noise, level_noise, trend_noise);
+        return KalmanForecaster.__wrap(ret);
+    }
+    /**
+     * 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
+     * @param {number} horizon
+     * @param {number} level
+     * @returns {Forecast}
+     */
+    predictWithIntervals(horizon, level) {
+        const ret = wasm.kalmanforecaster_predictWithIntervals(this.__wbg_ptr, horizon, level);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return Forecast.__wrap(ret[0]);
+    }
+    /**
+     * Fit the Kalman filter to a time series.
+     *
+     * @param series - TimeSeries to fit
+     * @param {TimeSeries} series
+     */
+    fit(series) {
+        _assertClass(series, TimeSeries);
+        const ret = wasm.kalmanforecaster_fit(this.__wbg_ptr, series.__wbg_ptr);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * Get the model name.
+     * @returns {string}
+     */
+    get name() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.kalmanforecaster_name(this.__wbg_ptr);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * Apply the Kalman smoother (RTS smoother) and return smoothed observations.
+     *
+     * @param series - TimeSeries to smooth
+     * @returns Array of smoothed observation values
+     * @param {TimeSeries} series
+     * @returns {Float64Array}
+     */
+    smooth(series) {
+        _assertClass(series, TimeSeries);
+        const ret = wasm.kalmanforecaster_smooth(this.__wbg_ptr, series.__wbg_ptr);
+        if (ret[3]) {
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+        return v1;
+    }
+    /**
+     * Predict future values.
+     *
+     * @param horizon - Number of steps to forecast
+     * @returns Forecast with point predictions
+     * @param {number} horizon
+     * @returns {Forecast}
+     */
+    predict(horizon) {
+        const ret = wasm.kalmanforecaster_predict(this.__wbg_ptr, horizon);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return Forecast.__wrap(ret[0]);
+    }
+}
+if (Symbol.dispose) KalmanForecaster.prototype[Symbol.dispose] = KalmanForecaster.prototype.free;
+
 /**
  * MFLES - Multiple Frequency Locally Estimated Scatterplot Smoothing.
  */
@@ -4319,6 +4792,108 @@ export class TimeSeries {
 }
 if (Symbol.dispose) TimeSeries.prototype[Symbol.dispose] = TimeSeries.prototype.free;
 
+/**
+ * Vector Autoregression forecaster for multivariate time series.
+ *
+ * Models multiple time series jointly where each variable at time t is a
+ * linear function of the p most recent lags of all variables.
+ */
+export class VARForecaster {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        VARForecasterFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_varforecaster_free(ptr, 0);
+    }
+    /**
+     * Fit the VAR model to multivariate time series data.
+     *
+     * @param data - Array of Float64Arrays, one per variable. All must have the same length.
+     * @param {Array<any>} data
+     */
+    fitMultivariate(data) {
+        const ret = wasm.varforecaster_fitMultivariate(this.__wbg_ptr, data);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * Predict future values for all variables.
+     *
+     * @param horizon - Number of steps to forecast
+     * @returns Array of Float64Arrays, one per variable
+     * @param {number} horizon
+     * @returns {Array<any>}
+     */
+    predictMultivariate(horizon) {
+        const ret = wasm.varforecaster_predictMultivariate(this.__wbg_ptr, horizon);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * 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.
+     * @param {number} cause
+     * @param {number} effect
+     * @returns {number}
+     */
+    grangerCausalityTest(cause, effect) {
+        const ret = wasm.varforecaster_grangerCausalityTest(this.__wbg_ptr, cause, effect);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0];
+    }
+    /**
+     * Create a new VAR forecaster with the given lag order.
+     *
+     * @param order - Number of lags (p). Must be at least 1.
+     * @param {number} order
+     */
+    constructor(order) {
+        const ret = wasm.varforecaster_new(order);
+        this.__wbg_ptr = ret >>> 0;
+        VARForecasterFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * Get the model name.
+     * @returns {string}
+     */
+    get name() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.varforecaster_name(this.__wbg_ptr);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * Get the lag order.
+     * @returns {number}
+     */
+    get order() {
+        const ret = wasm.varforecaster_order(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+}
+if (Symbol.dispose) VARForecaster.prototype[Symbol.dispose] = VARForecaster.prototype.free;
+
 /**
  * Window Average forecaster - uses the last N observations.
  */
@@ -4990,10 +5565,32 @@ function __wbg_get_imports() {
         const ret = arg0.getTime();
         return ret;
     };
+    imports.wbg.__wbg_get_6b7bd52aca3f9671 = function(arg0, arg1) {
+        const ret = arg0[arg1 >>> 0];
+        return ret;
+    };
+    imports.wbg.__wbg_instanceof_Float64Array_9fefccd7bfa2fefe = function(arg0) {
+        let result;
+        try {
+            result = arg0 instanceof Float64Array;
+        } catch (_) {
+            result = false;
+        }
+        const ret = result;
+        return ret;
+    };
     imports.wbg.__wbg_length_22ac23eaec9d8053 = function(arg0) {
         const ret = arg0.length;
         return ret;
     };
+    imports.wbg.__wbg_length_406f6daaaa453057 = function(arg0) {
+        const ret = arg0.length;
+        return ret;
+    };
+    imports.wbg.__wbg_length_d45040a40c570362 = function(arg0) {
+        const ret = arg0.length;
+        return ret;
+    };
     imports.wbg.__wbg_msCrypto_a61aeb35a24c1329 = function(arg0) {
         const ret = arg0.msCrypto;
         return ret;
@@ -5014,6 +5611,14 @@ function __wbg_get_imports() {
         const ret = new Function(getStringFromWasm0(arg0, arg1));
         return ret;
     };
+    imports.wbg.__wbg_new_with_length_12c6de4fac33117a = function(arg0) {
+        const ret = new Array(arg0 >>> 0);
+        return ret;
+    };
+    imports.wbg.__wbg_new_with_length_806b9e5b8290af7c = function(arg0) {
+        const ret = new Float64Array(arg0 >>> 0);
+        return ret;
+    };
     imports.wbg.__wbg_new_with_length_aa5eaf41d35235e5 = function(arg0) {
         const ret = new Uint8Array(arg0 >>> 0);
         return ret;
@@ -5026,6 +5631,9 @@ function __wbg_get_imports() {
         const ret = arg0.process;
         return ret;
     };
+    imports.wbg.__wbg_prototypesetcall_d3c4edbb4ef96ca1 = function(arg0, arg1, arg2) {
+        Float64Array.prototype.set.call(getArrayF64FromWasm0(arg0, arg1), arg2);
+    };
     imports.wbg.__wbg_prototypesetcall_dfe9b766cdc1f1fd = function(arg0, arg1, arg2) {
         Uint8Array.prototype.set.call(getArrayU8FromWasm0(arg0, arg1), arg2);
     };
@@ -5036,6 +5644,9 @@ function __wbg_get_imports() {
         const ret = module.require;
         return ret;
     }, arguments) };
+    imports.wbg.__wbg_set_22933af9286a43df = function(arg0, arg1, arg2) {
+        arg0.set(getArrayF64FromWasm0(arg1, arg2));
+    };
     imports.wbg.__wbg_set_3f1d0b984ed272ed = function(arg0, arg1, arg2) {
         arg0[arg1] = arg2;
     };

package/anofox_forecast_js_bg.wasm.d.ts

@@ -6,6 +6,7 @@ export const __wbg_arimaforecaster_free: (a: number, b: number) => void;
 export const __wbg_autoarimaforecaster_free: (a: number, b: number) => void;
 export const __wbg_autoensembleforecaster_free: (a: number, b: number) => void;
 export const __wbg_autoetsforecaster_free: (a: number, b: number) => void;
+export const __wbg_autoforecastbuilder_free: (a: number, b: number) => void;
 export const __wbg_autoforecaster_free: (a: number, b: number) => void;
 export const __wbg_autotbatsforecaster_free: (a: number, b: number) => void;
 export const __wbg_autothetaforecaster_free: (a: number, b: number) => void;
@@ -25,12 +26,14 @@ export const __wbg_jsconformalpredictor_free: (a: number, b: number) => void;
 export const __wbg_jsconformalresult_free: (a: number, b: number) => void;
 export const __wbg_jshistoricalsimresult_free: (a: number, b: number) => void;
 export const __wbg_jshistoricalsimulator_free: (a: number, b: number) => void;
+export const __wbg_jsmodeldiagnostics_free: (a: number, b: number) => void;
 export const __wbg_jsnormalpredictor_free: (a: number, b: number) => void;
 export const __wbg_jsnormalresult_free: (a: number, b: number) => void;
 export const __wbg_jspointforecasts_free: (a: number, b: number) => void;
 export const __wbg_jspostprocessor_free: (a: number, b: number) => void;
 export const __wbg_jspredictionintervals_free: (a: number, b: number) => void;
 export const __wbg_jstrainedmodel_free: (a: number, b: number) => void;
+export const __wbg_kalmanforecaster_free: (a: number, b: number) => void;
 export const __wbg_meanforecaster_free: (a: number, b: number) => void;
 export const __wbg_mflesforecaster_free: (a: number, b: number) => void;
 export const __wbg_mstlforecasterwrapper_free: (a: number, b: number) => void;
@@ -42,10 +45,10 @@ export const __wbg_seasonalesforecaster_free: (a: number, b: number) => void;
 export const __wbg_seasonalnaiveforecaster_free: (a: number, b: number) => void;
 export const __wbg_seasonalwindowaverageforecaster_free: (a: number, b: number) => void;
 export const __wbg_sesforecaster_free: (a: number, b: number) => void;
-export const __wbg_smaforecaster_free: (a: number, b: number) => void;
 export const __wbg_tbatsforecaster_free: (a: number, b: number) => void;
 export const __wbg_thetaforecaster_free: (a: number, b: number) => void;
 export const __wbg_timeseries_free: (a: number, b: number) => void;
+export const __wbg_varforecaster_free: (a: number, b: number) => void;
 export const adfTest: (a: number, b: number, c: number) => [number, number, number];
 export const adidaforecaster_fit: (a: number, b: number) => [number, number];
 export const adidaforecaster_name: (a: number) => [number, number];
@@ -80,6 +83,13 @@ export const autoetsforecaster_new: () => number;
 export const autoetsforecaster_predict: (a: number, b: number) => [number, number, number];
 export const autoetsforecaster_withConfig: (a: number, b: number, c: number, d: number) => number;
 export const autoetsforecaster_withPeriod: (a: number) => number;
+export const autoforecastbuilder_build: (a: number) => number;
+export const autoforecastbuilder_includeArima: (a: number, b: number) => number;
+export const autoforecastbuilder_includeEts: (a: number, b: number) => number;
+export const autoforecastbuilder_includeTheta: (a: number, b: number) => number;
+export const autoforecastbuilder_new: () => number;
+export const autoforecastbuilder_seasonalPeriod: (a: number, b: number) => number;
+export const autoforecastbuilder_useCrossValidation: (a: number, b: number) => number;
 export const autoforecaster_allScores: (a: number) => [number, number, number];
 export const autoforecaster_fit: (a: number, b: number) => [number, number];
 export const autoforecaster_name: (a: number) => [number, number];
@@ -137,7 +147,11 @@ export const ensembleforecaster_name: (a: number) => [number, number];
 export const ensembleforecaster_new: (a: number, b: number) => [number, number, number];
 export const ensembleforecaster_predict: (a: number, b: number) => [number, number, number];
 export const ensembleforecaster_predictWithIntervals: (a: number, b: number, c: number) => [number, number, number];
+export const ensembleforecaster_setHorizonAdaptive: (a: number) => void;
+export const ensembleforecaster_setInverseAic: (a: number) => void;
 export const ensembleforecaster_setMedian: (a: number) => void;
+export const ensembleforecaster_setMethod: (a: number, b: number, c: number) => [number, number];
+export const ensembleforecaster_setStacking: (a: number, b: number) => void;
 export const ensembleforecaster_setWeightedMse: (a: number) => void;
 export const ensembleforecaster_setWeights: (a: number, b: number, c: number) => void;
 export const etsforecaster_fit: (a: number, b: number) => [number, number];
@@ -146,10 +160,13 @@ export const etsforecaster_isValidSpec: (a: number, b: number, c: number, d: num
 export const etsforecaster_name: (a: number) => [number, number];
 export const etsforecaster_new: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => [number, number, number];
 export const etsforecaster_predict: (a: number, b: number) => [number, number, number];
+export const forecast_clamp: (a: number, b: number, c: number) => number;
 export const forecast_hasLower: (a: number) => number;
 export const forecast_hasUpper: (a: number) => number;
 export const forecast_horizon: (a: number) => number;
 export const forecast_lower: (a: number) => [number, number];
+export const forecast_nonNegative: (a: number) => number;
+export const forecast_roundToInteger: (a: number) => number;
 export const forecast_upper: (a: number) => [number, number];
 export const forecast_values: (a: number) => [number, number];
 export const garchforecaster_fit: (a: number, b: number) => [number, number];
@@ -199,11 +216,19 @@ export const jshistoricalsimulator_new: (a: number, b: number) => number;
 export const jshistoricalsimulator_predictIntervals: (a: number, b: number, c: number, d: number) => [number, number, number];
 export const jshistoricalsimulator_simulate: (a: number, b: number, c: number, d: number, e: number) => [number, number, number];
 export const jshistoricalsimulator_withWindow: (a: number, b: number, c: number) => number;
+export const jsmodeldiagnostics_fromResiduals: (a: number, b: number, c: number) => number;
+export const jsmodeldiagnostics_jarqueBeraStatistic: (a: number) => number;
+export const jsmodeldiagnostics_ljungBoxLags: (a: number) => number;
+export const jsmodeldiagnostics_ljungBoxPvalue: (a: number) => number;
+export const jsmodeldiagnostics_passesAll: (a: number) => number;
+export const jsmodeldiagnostics_residualAcf: (a: number) => [number, number];
+export const jsmodeldiagnostics_residualMean: (a: number) => number;
+export const jsmodeldiagnostics_residualPacf: (a: number) => [number, number];
+export const jsmodeldiagnostics_residualStd: (a: number) => number;
+export const jsmodeldiagnostics_summary: (a: number) => [number, number];
 export const jsnormalpredictor_fit: (a: number, b: number, c: number, d: number, e: number) => [number, number, number];
 export const jsnormalpredictor_new: (a: number, b: number) => number;
 export const jsnormalpredictor_predictIntervals: (a: number, b: number, c: number, d: number) => [number, number, number];
-export const jsnormalresult_mean: (a: number) => number;
-export const jsnormalresult_stdDev: (a: number) => number;
 export const jspointforecasts_isEmpty: (a: number) => number;
 export const jspointforecasts_length: (a: number) => number;
 export const jspointforecasts_new: (a: number, b: number) => number;
@@ -219,6 +244,13 @@ export const jspredictionintervals_lower: (a: number) => [number, number];
 export const jspredictionintervals_midpoints: (a: number) => [number, number];
 export const jspredictionintervals_upper: (a: number) => [number, number];
 export const jspredictionintervals_widths: (a: number) => [number, number];
+export const kalmanforecaster_fit: (a: number, b: number) => [number, number];
+export const kalmanforecaster_localLevel: (a: number, b: number) => number;
+export const kalmanforecaster_localLinearTrend: (a: number, b: number, c: number) => number;
+export const kalmanforecaster_name: (a: number) => [number, number];
+export const kalmanforecaster_predict: (a: number, b: number) => [number, number, number];
+export const kalmanforecaster_predictWithIntervals: (a: number, b: number, c: number) => [number, number, number];
+export const kalmanforecaster_smooth: (a: number, b: number) => [number, number, number, number];
 export const kpssTest: (a: number, b: number, c: number) => [number, number, number];
 export const kurtosis: (a: number, b: number) => number;
 export const ljungBox: (a: number, b: number, c: number, d: number) => [number, number, number];
@@ -313,6 +345,12 @@ export const tsbforecaster_name: (a: number) => [number, number];
 export const tsbforecaster_new: () => number;
 export const tsbforecaster_predict: (a: number, b: number) => [number, number, number];
 export const tsbforecaster_predictWithIntervals: (a: number, b: number, c: number) => [number, number, number];
+export const varforecaster_fitMultivariate: (a: number, b: any) => [number, number];
+export const varforecaster_grangerCausalityTest: (a: number, b: number, c: number) => [number, number, number];
+export const varforecaster_name: (a: number) => [number, number];
+export const varforecaster_new: (a: number) => number;
+export const varforecaster_order: (a: number) => number;
+export const varforecaster_predictMultivariate: (a: number, b: number) => [number, number, number];
 export const variance: (a: number, b: number) => number;
 export const version: () => [number, number];
 export const windowaverageforecaster_fit: (a: number, b: number) => [number, number];
@@ -320,8 +358,13 @@ export const windowaverageforecaster_name: (a: number) => [number, number];
 export const windowaverageforecaster_new: (a: number) => number;
 export const windowaverageforecaster_predict: (a: number, b: number) => [number, number, number];
 export const tbatsforecaster_withSeasonalPeriods: (a: number, b: number) => number;
+export const __wbg_smaforecaster_free: (a: number, b: number) => void;
 export const __wbg_tsbforecaster_free: (a: number, b: number) => void;
 export const __wbg_windowaverageforecaster_free: (a: number, b: number) => void;
+export const jsmodeldiagnostics_heteroscedasticityPvalue: (a: number) => number;
+export const jsmodeldiagnostics_jarqueBeraPvalue: (a: number) => number;
+export const jsnormalresult_mean: (a: number) => number;
+export const jsnormalresult_stdDev: (a: number) => number;
 export const jspredictionintervals_coverage: (a: number) => number;
 export const __wbindgen_malloc: (a: number, b: number) => number;
 export const __wbindgen_realloc: (a: number, b: number, c: number, d: number) => number;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sipemu/anofox-forecast",
-  "version": "0.4.5",
+  "version": "0.4.7",
   "description": "Time series forecasting library - WebAssembly bindings for anofox-forecast",
   "type": "module",
   "main": "anofox_forecast_js.js",