@sipemu/anofox-forecast 0.4.0

package/anofox_forecast_js.js

@@ -0,0 +1,2617 @@
+let wasm;
+
+function _assertClass(instance, klass) {
+    if (!(instance instanceof klass)) {
+        throw new Error(`expected instance of ${klass.name}`);
+    }
+}
+
+function getArrayF64FromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return getFloat64ArrayMemory0().subarray(ptr / 8, ptr / 8 + len);
+}
+
+let cachedFloat64ArrayMemory0 = null;
+function getFloat64ArrayMemory0() {
+    if (cachedFloat64ArrayMemory0 === null || cachedFloat64ArrayMemory0.byteLength === 0) {
+        cachedFloat64ArrayMemory0 = new Float64Array(wasm.memory.buffer);
+    }
+    return cachedFloat64ArrayMemory0;
+}
+
+function getStringFromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return decodeText(ptr, len);
+}
+
+let cachedUint32ArrayMemory0 = null;
+function getUint32ArrayMemory0() {
+    if (cachedUint32ArrayMemory0 === null || cachedUint32ArrayMemory0.byteLength === 0) {
+        cachedUint32ArrayMemory0 = new Uint32Array(wasm.memory.buffer);
+    }
+    return cachedUint32ArrayMemory0;
+}
+
+let cachedUint8ArrayMemory0 = null;
+function getUint8ArrayMemory0() {
+    if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) {
+        cachedUint8ArrayMemory0 = new Uint8Array(wasm.memory.buffer);
+    }
+    return cachedUint8ArrayMemory0;
+}
+
+function passArray32ToWasm0(arg, malloc) {
+    const ptr = malloc(arg.length * 4, 4) >>> 0;
+    getUint32ArrayMemory0().set(arg, ptr / 4);
+    WASM_VECTOR_LEN = arg.length;
+    return ptr;
+}
+
+function passArrayF64ToWasm0(arg, malloc) {
+    const ptr = malloc(arg.length * 8, 8) >>> 0;
+    getFloat64ArrayMemory0().set(arg, ptr / 8);
+    WASM_VECTOR_LEN = arg.length;
+    return ptr;
+}
+
+function passStringToWasm0(arg, malloc, realloc) {
+    if (realloc === undefined) {
+        const buf = cachedTextEncoder.encode(arg);
+        const ptr = malloc(buf.length, 1) >>> 0;
+        getUint8ArrayMemory0().subarray(ptr, ptr + buf.length).set(buf);
+        WASM_VECTOR_LEN = buf.length;
+        return ptr;
+    }
+
+    let len = arg.length;
+    let ptr = malloc(len, 1) >>> 0;
+
+    const mem = getUint8ArrayMemory0();
+
+    let offset = 0;
+
+    for (; offset < len; offset++) {
+        const code = arg.charCodeAt(offset);
+        if (code > 0x7F) break;
+        mem[ptr + offset] = code;
+    }
+    if (offset !== len) {
+        if (offset !== 0) {
+            arg = arg.slice(offset);
+        }
+        ptr = realloc(ptr, len, len = offset + arg.length * 3, 1) >>> 0;
+        const view = getUint8ArrayMemory0().subarray(ptr + offset, ptr + len);
+        const ret = cachedTextEncoder.encodeInto(arg, view);
+
+        offset += ret.written;
+        ptr = realloc(ptr, len, offset, 1) >>> 0;
+    }
+
+    WASM_VECTOR_LEN = offset;
+    return ptr;
+}
+
+function takeFromExternrefTable0(idx) {
+    const value = wasm.__wbindgen_externrefs.get(idx);
+    wasm.__externref_table_dealloc(idx);
+    return value;
+}
+
+let cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
+cachedTextDecoder.decode();
+const MAX_SAFARI_DECODE_BYTES = 2146435072;
+let numBytesDecoded = 0;
+function decodeText(ptr, len) {
+    numBytesDecoded += len;
+    if (numBytesDecoded >= MAX_SAFARI_DECODE_BYTES) {
+        cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
+        cachedTextDecoder.decode();
+        numBytesDecoded = len;
+    }
+    return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));
+}
+
+const cachedTextEncoder = new TextEncoder();
+
+if (!('encodeInto' in cachedTextEncoder)) {
+    cachedTextEncoder.encodeInto = function (arg, view) {
+        const buf = cachedTextEncoder.encode(arg);
+        view.set(buf);
+        return {
+            read: arg.length,
+            written: buf.length
+        };
+    }
+}
+
+let WASM_VECTOR_LEN = 0;
+
+const ADIDAForecasterFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_adidaforecaster_free(ptr >>> 0, 1));
+
+const ARIMAForecasterFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_arimaforecaster_free(ptr >>> 0, 1));
+
+const AutoARIMAForecasterFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_autoarimaforecaster_free(ptr >>> 0, 1));
+
+const AutoETSForecasterFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_autoetsforecaster_free(ptr >>> 0, 1));
+
+const AutoTBATSForecasterFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_autotbatsforecaster_free(ptr >>> 0, 1));
+
+const AutoThetaForecasterFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_autothetaforecaster_free(ptr >>> 0, 1));
+
+const CrostonForecasterFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_crostonforecaster_free(ptr >>> 0, 1));
+
+const DynamicThetaForecasterFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_dynamicthetaforecaster_free(ptr >>> 0, 1));
+
+const ETSForecasterFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_etsforecaster_free(ptr >>> 0, 1));
+
+const ForecastFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_forecast_free(ptr >>> 0, 1));
+
+const GARCHForecasterFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_garchforecaster_free(ptr >>> 0, 1));
+
+const HoltForecasterFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_holtforecaster_free(ptr >>> 0, 1));
+
+const HoltWintersForecasterFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_holtwintersforecaster_free(ptr >>> 0, 1));
+
+const IMAPAForecasterFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_imapaforecaster_free(ptr >>> 0, 1));
+
+const MFLESForecasterFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_mflesforecaster_free(ptr >>> 0, 1));
+
+const MSTLForecasterWrapperFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_mstlforecasterwrapper_free(ptr >>> 0, 1));
+
+const MeanForecasterFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_meanforecaster_free(ptr >>> 0, 1));
+
+const NaiveForecasterFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_naiveforecaster_free(ptr >>> 0, 1));
+
+const OptimizedThetaForecasterFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_optimizedthetaforecaster_free(ptr >>> 0, 1));
+
+const RandomWalkDriftForecasterFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_randomwalkdriftforecaster_free(ptr >>> 0, 1));
+
+const SARIMAForecasterFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_sarimaforecaster_free(ptr >>> 0, 1));
+
+const SESForecasterFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_sesforecaster_free(ptr >>> 0, 1));
+
+const SMAForecasterFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_smaforecaster_free(ptr >>> 0, 1));
+
+const SeasonalESForecasterFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_seasonalesforecaster_free(ptr >>> 0, 1));
+
+const SeasonalNaiveForecasterFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_seasonalnaiveforecaster_free(ptr >>> 0, 1));
+
+const SeasonalWindowAverageForecasterFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_seasonalwindowaverageforecaster_free(ptr >>> 0, 1));
+
+const TBATSForecasterFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_tbatsforecaster_free(ptr >>> 0, 1));
+
+const TSBForecasterFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_tsbforecaster_free(ptr >>> 0, 1));
+
+const ThetaForecasterFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_thetaforecaster_free(ptr >>> 0, 1));
+
+const TimeSeriesFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_timeseries_free(ptr >>> 0, 1));
+
+const WindowAverageForecasterFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_windowaverageforecaster_free(ptr >>> 0, 1));
+
+/**
+ * ADIDA (Aggregate-Disaggregate Intermittent Demand Approach).
+ */
+export class ADIDAForecaster {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        ADIDAForecasterFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_adidaforecaster_free(ptr, 0);
+    }
+    /**
+     * @param {TimeSeries} series
+     */
+    fit(series) {
+        _assertClass(series, TimeSeries);
+        const ret = wasm.adidaforecaster_fit(this.__wbg_ptr, series.__wbg_ptr);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    constructor() {
+        const ret = wasm.adidaforecaster_new();
+        this.__wbg_ptr = ret >>> 0;
+        ADIDAForecasterFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * @returns {string}
+     */
+    get name() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.adidaforecaster_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);
+        }
+    }
+    /**
+     * @param {number} horizon
+     * @returns {Forecast}
+     */
+    predict(horizon) {
+        const ret = wasm.adidaforecaster_predict(this.__wbg_ptr, horizon);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return Forecast.__wrap(ret[0]);
+    }
+}
+if (Symbol.dispose) ADIDAForecaster.prototype[Symbol.dispose] = ADIDAForecaster.prototype.free;
+
+/**
+ * ARIMA forecaster - Autoregressive Integrated Moving Average.
+ */
+export class ARIMAForecaster {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        ARIMAForecasterFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_arimaforecaster_free(ptr, 0);
+    }
+    /**
+     * @param {number} horizon
+     * @param {number} level
+     * @returns {Forecast}
+     */
+    predictWithIntervals(horizon, level) {
+        const ret = wasm.arimaforecaster_predictWithIntervals(this.__wbg_ptr, horizon, level);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return Forecast.__wrap(ret[0]);
+    }
+    /**
+     * @param {TimeSeries} series
+     */
+    fit(series) {
+        _assertClass(series, TimeSeries);
+        const ret = wasm.arimaforecaster_fit(this.__wbg_ptr, series.__wbg_ptr);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * @param p - AR order (autoregressive)
+     * @param d - Differencing order
+     * @param q - MA order (moving average)
+     * @param {number} p
+     * @param {number} d
+     * @param {number} q
+     */
+    constructor(p, d, q) {
+        const ret = wasm.arimaforecaster_new(p, d, q);
+        this.__wbg_ptr = ret >>> 0;
+        ARIMAForecasterFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * @returns {string}
+     */
+    get name() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.arimaforecaster_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);
+        }
+    }
+    /**
+     * @param {number} horizon
+     * @returns {Forecast}
+     */
+    predict(horizon) {
+        const ret = wasm.arimaforecaster_predict(this.__wbg_ptr, horizon);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return Forecast.__wrap(ret[0]);
+    }
+}
+if (Symbol.dispose) ARIMAForecaster.prototype[Symbol.dispose] = ARIMAForecaster.prototype.free;
+
+/**
+ * AutoARIMA - Automatic ARIMA order selection.
+ */
+export class AutoARIMAForecaster {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        AutoARIMAForecasterFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_autoarimaforecaster_free(ptr, 0);
+    }
+    /**
+     * @param {number} horizon
+     * @param {number} level
+     * @returns {Forecast}
+     */
+    predictWithIntervals(horizon, level) {
+        const ret = wasm.autoarimaforecaster_predictWithIntervals(this.__wbg_ptr, horizon, level);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return Forecast.__wrap(ret[0]);
+    }
+    /**
+     * @param {TimeSeries} series
+     */
+    fit(series) {
+        _assertClass(series, TimeSeries);
+        const ret = wasm.autoarimaforecaster_fit(this.__wbg_ptr, series.__wbg_ptr);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    constructor() {
+        const ret = wasm.autoarimaforecaster_new();
+        this.__wbg_ptr = ret >>> 0;
+        AutoARIMAForecasterFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * @returns {string}
+     */
+    get name() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.autoarimaforecaster_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);
+        }
+    }
+    /**
+     * @param {number} horizon
+     * @returns {Forecast}
+     */
+    predict(horizon) {
+        const ret = wasm.autoarimaforecaster_predict(this.__wbg_ptr, horizon);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return Forecast.__wrap(ret[0]);
+    }
+}
+if (Symbol.dispose) AutoARIMAForecaster.prototype[Symbol.dispose] = AutoARIMAForecaster.prototype.free;
+
+/**
+ * AutoETS - Automatic ETS model selection.
+ */
+export class AutoETSForecaster {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        AutoETSForecasterFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_autoetsforecaster_free(ptr, 0);
+    }
+    /**
+     * @param {TimeSeries} series
+     */
+    fit(series) {
+        _assertClass(series, TimeSeries);
+        const ret = wasm.autoetsforecaster_fit(this.__wbg_ptr, series.__wbg_ptr);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    constructor() {
+        const ret = wasm.autoetsforecaster_new();
+        this.__wbg_ptr = ret >>> 0;
+        AutoETSForecasterFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * @returns {string}
+     */
+    get name() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.autoetsforecaster_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);
+        }
+    }
+    /**
+     * @param {number} horizon
+     * @returns {Forecast}
+     */
+    predict(horizon) {
+        const ret = wasm.autoetsforecaster_predict(this.__wbg_ptr, horizon);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return Forecast.__wrap(ret[0]);
+    }
+}
+if (Symbol.dispose) AutoETSForecaster.prototype[Symbol.dispose] = AutoETSForecaster.prototype.free;
+
+/**
+ * AutoTBATS - Automatic TBATS model selection.
+ */
+export class AutoTBATSForecaster {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        AutoTBATSForecasterFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_autotbatsforecaster_free(ptr, 0);
+    }
+    /**
+     * @param {TimeSeries} series
+     */
+    fit(series) {
+        _assertClass(series, TimeSeries);
+        const ret = wasm.autotbatsforecaster_fit(this.__wbg_ptr, series.__wbg_ptr);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * @param seasonal_periods - Array of seasonal periods
+     * @param {Uint32Array} seasonal_periods
+     */
+    constructor(seasonal_periods) {
+        const ptr0 = passArray32ToWasm0(seasonal_periods, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.autotbatsforecaster_new(ptr0, len0);
+        this.__wbg_ptr = ret >>> 0;
+        AutoTBATSForecasterFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * @returns {string}
+     */
+    get name() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.autotbatsforecaster_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);
+        }
+    }
+    /**
+     * @param {number} horizon
+     * @returns {Forecast}
+     */
+    predict(horizon) {
+        const ret = wasm.autotbatsforecaster_predict(this.__wbg_ptr, horizon);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return Forecast.__wrap(ret[0]);
+    }
+}
+if (Symbol.dispose) AutoTBATSForecaster.prototype[Symbol.dispose] = AutoTBATSForecaster.prototype.free;
+
+/**
+ * AutoTheta - Automatic Theta model selection.
+ */
+export class AutoThetaForecaster {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        AutoThetaForecasterFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_autothetaforecaster_free(ptr, 0);
+    }
+    /**
+     * @param {number} horizon
+     * @param {number} level
+     * @returns {Forecast}
+     */
+    predictWithIntervals(horizon, level) {
+        const ret = wasm.autothetaforecaster_predictWithIntervals(this.__wbg_ptr, horizon, level);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return Forecast.__wrap(ret[0]);
+    }
+    /**
+     * @param {TimeSeries} series
+     */
+    fit(series) {
+        _assertClass(series, TimeSeries);
+        const ret = wasm.autothetaforecaster_fit(this.__wbg_ptr, series.__wbg_ptr);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    constructor() {
+        const ret = wasm.autothetaforecaster_new();
+        this.__wbg_ptr = ret >>> 0;
+        AutoThetaForecasterFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * @returns {string}
+     */
+    get name() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.autothetaforecaster_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);
+        }
+    }
+    /**
+     * @param {number} horizon
+     * @returns {Forecast}
+     */
+    predict(horizon) {
+        const ret = wasm.autothetaforecaster_predict(this.__wbg_ptr, horizon);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return Forecast.__wrap(ret[0]);
+    }
+}
+if (Symbol.dispose) AutoThetaForecaster.prototype[Symbol.dispose] = AutoThetaForecaster.prototype.free;
+
+/**
+ * Croston's method for intermittent demand forecasting.
+ */
+export class CrostonForecaster {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        CrostonForecasterFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_crostonforecaster_free(ptr, 0);
+    }
+    /**
+     * @param {TimeSeries} series
+     */
+    fit(series) {
+        _assertClass(series, TimeSeries);
+        const ret = wasm.crostonforecaster_fit(this.__wbg_ptr, series.__wbg_ptr);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    constructor() {
+        const ret = wasm.crostonforecaster_new();
+        this.__wbg_ptr = ret >>> 0;
+        CrostonForecasterFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * @returns {string}
+     */
+    get name() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.crostonforecaster_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);
+        }
+    }
+    /**
+     * @param {number} horizon
+     * @returns {Forecast}
+     */
+    predict(horizon) {
+        const ret = wasm.crostonforecaster_predict(this.__wbg_ptr, horizon);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return Forecast.__wrap(ret[0]);
+    }
+}
+if (Symbol.dispose) CrostonForecaster.prototype[Symbol.dispose] = CrostonForecaster.prototype.free;
+
+/**
+ * Dynamic Theta forecaster - updates coefficients dynamically.
+ */
+export class DynamicThetaForecaster {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(DynamicThetaForecaster.prototype);
+        obj.__wbg_ptr = ptr;
+        DynamicThetaForecasterFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        DynamicThetaForecasterFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_dynamicthetaforecaster_free(ptr, 0);
+    }
+    /**
+     * @param {number} horizon
+     * @param {number} level
+     * @returns {Forecast}
+     */
+    predictWithIntervals(horizon, level) {
+        const ret = wasm.dynamicthetaforecaster_predictWithIntervals(this.__wbg_ptr, horizon, level);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return Forecast.__wrap(ret[0]);
+    }
+    /**
+     * @param {TimeSeries} series
+     */
+    fit(series) {
+        _assertClass(series, TimeSeries);
+        const ret = wasm.dynamicthetaforecaster_fit(this.__wbg_ptr, series.__wbg_ptr);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * @param alpha - Smoothing parameter for the forecast
+     * @param {number} alpha
+     */
+    constructor(alpha) {
+        const ret = wasm.dynamicthetaforecaster_new(alpha);
+        this.__wbg_ptr = ret >>> 0;
+        DynamicThetaForecasterFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * @returns {string}
+     */
+    get name() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.dynamicthetaforecaster_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);
+        }
+    }
+    /**
+     * @param {number} horizon
+     * @returns {Forecast}
+     */
+    predict(horizon) {
+        const ret = wasm.dynamicthetaforecaster_predict(this.__wbg_ptr, horizon);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return Forecast.__wrap(ret[0]);
+    }
+    /**
+     * Create a seasonal Dynamic Theta model.
+     * @param period - Seasonal period
+     * @param {number} period
+     * @returns {DynamicThetaForecaster}
+     */
+    static seasonal(period) {
+        const ret = wasm.dynamicthetaforecaster_seasonal(period);
+        return DynamicThetaForecaster.__wrap(ret);
+    }
+    /**
+     * Create an optimized Dynamic Theta model.
+     * @returns {DynamicThetaForecaster}
+     */
+    static optimized() {
+        const ret = wasm.dynamicthetaforecaster_optimized();
+        return DynamicThetaForecaster.__wrap(ret);
+    }
+}
+if (Symbol.dispose) DynamicThetaForecaster.prototype[Symbol.dispose] = DynamicThetaForecaster.prototype.free;
+
+/**
+ * ETS (Error-Trend-Seasonal) state-space model.
+ * Use string codes: "A" = Additive, "M" = Multiplicative, "N" = None
+ */
+export class ETSForecaster {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        ETSForecasterFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_etsforecaster_free(ptr, 0);
+    }
+    /**
+     * @param {TimeSeries} series
+     */
+    fit(series) {
+        _assertClass(series, TimeSeries);
+        const ret = wasm.etsforecaster_fit(this.__wbg_ptr, series.__wbg_ptr);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * Create an ETS model with specified components.
+     * @param error - Error type: "A" (additive) or "M" (multiplicative)
+     * @param trend - Trend type: "N" (none), "A" (additive), or "Ad" (additive damped)
+     * @param seasonal - Seasonal type: "N" (none), "A" (additive), or "M" (multiplicative)
+     * @param period - Seasonal period (ignored if seasonal is "N")
+     * @param {string} error
+     * @param {string} trend
+     * @param {string} seasonal
+     * @param {number} period
+     */
+    constructor(error, trend, seasonal, period) {
+        const ptr0 = passStringToWasm0(error, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(trend, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ptr2 = passStringToWasm0(seasonal, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len2 = WASM_VECTOR_LEN;
+        const ret = wasm.etsforecaster_new(ptr0, len0, ptr1, len1, ptr2, len2, period);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        this.__wbg_ptr = ret[0] >>> 0;
+        ETSForecasterFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * @returns {string}
+     */
+    get name() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.etsforecaster_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);
+        }
+    }
+    /**
+     * @param {number} horizon
+     * @returns {Forecast}
+     */
+    predict(horizon) {
+        const ret = wasm.etsforecaster_predict(this.__wbg_ptr, horizon);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return Forecast.__wrap(ret[0]);
+    }
+}
+if (Symbol.dispose) ETSForecaster.prototype[Symbol.dispose] = ETSForecaster.prototype.free;
+
+/**
+ * Forecast result wrapper for JavaScript.
+ *
+ * Contains point predictions and optional prediction intervals.
+ */
+export class Forecast {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(Forecast.prototype);
+        obj.__wbg_ptr = ptr;
+        ForecastFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        ForecastFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_forecast_free(ptr, 0);
+    }
+    /**
+     * Get lower prediction interval bounds.
+     *
+     * @returns Array of lower bounds, or undefined if not available
+     * @returns {Float64Array | undefined}
+     */
+    get lower() {
+        const ret = wasm.forecast_lower(this.__wbg_ptr);
+        let v1;
+        if (ret[0] !== 0) {
+            v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+            wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+        }
+        return v1;
+    }
+    /**
+     * Get upper prediction interval bounds.
+     *
+     * @returns Array of upper bounds, or undefined if not available
+     * @returns {Float64Array | undefined}
+     */
+    get upper() {
+        const ret = wasm.forecast_upper(this.__wbg_ptr);
+        let v1;
+        if (ret[0] !== 0) {
+            v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+            wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+        }
+        return v1;
+    }
+    /**
+     * Get point predictions.
+     * @returns {Float64Array}
+     */
+    get values() {
+        const ret = wasm.forecast_values(this.__wbg_ptr);
+        var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+        return v1;
+    }
+    /**
+     * Get the forecast horizon (number of predictions).
+     * @returns {number}
+     */
+    get horizon() {
+        const ret = wasm.forecast_horizon(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Check if lower prediction interval is available.
+     * @returns {boolean}
+     */
+    hasLower() {
+        const ret = wasm.forecast_hasLower(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * Check if upper prediction interval is available.
+     * @returns {boolean}
+     */
+    hasUpper() {
+        const ret = wasm.forecast_hasUpper(this.__wbg_ptr);
+        return ret !== 0;
+    }
+}
+if (Symbol.dispose) Forecast.prototype[Symbol.dispose] = Forecast.prototype.free;
+
+/**
+ * GARCH - Generalized Autoregressive Conditional Heteroskedasticity.
+ */
+export class GARCHForecaster {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        GARCHForecasterFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_garchforecaster_free(ptr, 0);
+    }
+    /**
+     * @param {TimeSeries} series
+     */
+    fit(series) {
+        _assertClass(series, TimeSeries);
+        const ret = wasm.garchforecaster_fit(this.__wbg_ptr, series.__wbg_ptr);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * @param p - GARCH order (lagged variance terms)
+     * @param q - ARCH order (lagged squared residuals)
+     * @param {number} p
+     * @param {number} q
+     */
+    constructor(p, q) {
+        const ret = wasm.garchforecaster_new(p, q);
+        this.__wbg_ptr = ret >>> 0;
+        GARCHForecasterFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * @returns {string}
+     */
+    get name() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.garchforecaster_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);
+        }
+    }
+    /**
+     * @param {number} horizon
+     * @returns {Forecast}
+     */
+    predict(horizon) {
+        const ret = wasm.garchforecaster_predict(this.__wbg_ptr, horizon);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return Forecast.__wrap(ret[0]);
+    }
+}
+if (Symbol.dispose) GARCHForecaster.prototype[Symbol.dispose] = GARCHForecaster.prototype.free;
+
+/**
+ * Holt Linear Trend (Double Exponential Smoothing) forecaster.
+ */
+export class HoltForecaster {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        HoltForecasterFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_holtforecaster_free(ptr, 0);
+    }
+    /**
+     * @param {TimeSeries} series
+     */
+    fit(series) {
+        _assertClass(series, TimeSeries);
+        const ret = wasm.holtforecaster_fit(this.__wbg_ptr, series.__wbg_ptr);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * @param alpha - Level smoothing parameter (0 < alpha <= 1)
+     * @param beta - Trend smoothing parameter (0 < beta <= 1)
+     * @param {number} alpha
+     * @param {number} beta
+     */
+    constructor(alpha, beta) {
+        const ret = wasm.holtforecaster_new(alpha, beta);
+        this.__wbg_ptr = ret >>> 0;
+        HoltForecasterFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * @returns {string}
+     */
+    get name() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.holtforecaster_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);
+        }
+    }
+    /**
+     * @param {number} horizon
+     * @returns {Forecast}
+     */
+    predict(horizon) {
+        const ret = wasm.holtforecaster_predict(this.__wbg_ptr, horizon);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return Forecast.__wrap(ret[0]);
+    }
+}
+if (Symbol.dispose) HoltForecaster.prototype[Symbol.dispose] = HoltForecaster.prototype.free;
+
+/**
+ * Holt-Winters (Triple Exponential Smoothing) forecaster.
+ */
+export class HoltWintersForecaster {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(HoltWintersForecaster.prototype);
+        obj.__wbg_ptr = ptr;
+        HoltWintersForecasterFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        HoltWintersForecasterFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_holtwintersforecaster_free(ptr, 0);
+    }
+    /**
+     * Create with multiplicative seasonality.
+     * @param {number} alpha
+     * @param {number} beta
+     * @param {number} gamma
+     * @param {number} period
+     * @returns {HoltWintersForecaster}
+     */
+    static multiplicative(alpha, beta, gamma, period) {
+        const ret = wasm.holtwintersforecaster_multiplicative(alpha, beta, gamma, period);
+        return HoltWintersForecaster.__wrap(ret);
+    }
+    /**
+     * @param {TimeSeries} series
+     */
+    fit(series) {
+        _assertClass(series, TimeSeries);
+        const ret = wasm.holtwintersforecaster_fit(this.__wbg_ptr, series.__wbg_ptr);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * Create with additive seasonality.
+     * @param alpha - Level smoothing parameter
+     * @param beta - Trend smoothing parameter
+     * @param gamma - Seasonal smoothing parameter
+     * @param period - Seasonal period
+     * @param {number} alpha
+     * @param {number} beta
+     * @param {number} gamma
+     * @param {number} period
+     */
+    constructor(alpha, beta, gamma, period) {
+        const ret = wasm.holtwintersforecaster_new(alpha, beta, gamma, period);
+        this.__wbg_ptr = ret >>> 0;
+        HoltWintersForecasterFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * @returns {string}
+     */
+    get name() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.holtwintersforecaster_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);
+        }
+    }
+    /**
+     * @param {number} horizon
+     * @returns {Forecast}
+     */
+    predict(horizon) {
+        const ret = wasm.holtwintersforecaster_predict(this.__wbg_ptr, horizon);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return Forecast.__wrap(ret[0]);
+    }
+}
+if (Symbol.dispose) HoltWintersForecaster.prototype[Symbol.dispose] = HoltWintersForecaster.prototype.free;
+
+/**
+ * IMAPA (Intermittent Multiple Aggregation Prediction Algorithm).
+ */
+export class IMAPAForecaster {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        IMAPAForecasterFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_imapaforecaster_free(ptr, 0);
+    }
+    /**
+     * @param {TimeSeries} series
+     */
+    fit(series) {
+        _assertClass(series, TimeSeries);
+        const ret = wasm.imapaforecaster_fit(this.__wbg_ptr, series.__wbg_ptr);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    constructor() {
+        const ret = wasm.imapaforecaster_new();
+        this.__wbg_ptr = ret >>> 0;
+        IMAPAForecasterFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * @returns {string}
+     */
+    get name() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.imapaforecaster_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);
+        }
+    }
+    /**
+     * @param {number} horizon
+     * @returns {Forecast}
+     */
+    predict(horizon) {
+        const ret = wasm.imapaforecaster_predict(this.__wbg_ptr, horizon);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return Forecast.__wrap(ret[0]);
+    }
+}
+if (Symbol.dispose) IMAPAForecaster.prototype[Symbol.dispose] = IMAPAForecaster.prototype.free;
+
+/**
+ * MFLES - Multiple Frequency Locally Estimated Scatterplot Smoothing.
+ */
+export class MFLESForecaster {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        MFLESForecasterFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_mflesforecaster_free(ptr, 0);
+    }
+    /**
+     * @param {TimeSeries} series
+     */
+    fit(series) {
+        _assertClass(series, TimeSeries);
+        const ret = wasm.mflesforecaster_fit(this.__wbg_ptr, series.__wbg_ptr);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * @param seasonal_periods - Array of seasonal periods
+     * @param {Uint32Array} seasonal_periods
+     */
+    constructor(seasonal_periods) {
+        const ptr0 = passArray32ToWasm0(seasonal_periods, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.mflesforecaster_new(ptr0, len0);
+        this.__wbg_ptr = ret >>> 0;
+        MFLESForecasterFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * @returns {string}
+     */
+    get name() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.mflesforecaster_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);
+        }
+    }
+    /**
+     * @param {number} horizon
+     * @returns {Forecast}
+     */
+    predict(horizon) {
+        const ret = wasm.mflesforecaster_predict(this.__wbg_ptr, horizon);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return Forecast.__wrap(ret[0]);
+    }
+}
+if (Symbol.dispose) MFLESForecaster.prototype[Symbol.dispose] = MFLESForecaster.prototype.free;
+
+/**
+ * MSTL Forecaster - Multiple Seasonal-Trend decomposition using LOESS.
+ */
+export class MSTLForecasterWrapper {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        MSTLForecasterWrapperFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_mstlforecasterwrapper_free(ptr, 0);
+    }
+    /**
+     * @param {TimeSeries} series
+     */
+    fit(series) {
+        _assertClass(series, TimeSeries);
+        const ret = wasm.mstlforecasterwrapper_fit(this.__wbg_ptr, series.__wbg_ptr);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * @param seasonal_periods - Array of seasonal periods
+     * @param {Uint32Array} seasonal_periods
+     */
+    constructor(seasonal_periods) {
+        const ptr0 = passArray32ToWasm0(seasonal_periods, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.mstlforecasterwrapper_new(ptr0, len0);
+        this.__wbg_ptr = ret >>> 0;
+        MSTLForecasterWrapperFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * @returns {string}
+     */
+    get name() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.mstlforecasterwrapper_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);
+        }
+    }
+    /**
+     * @param {number} horizon
+     * @returns {Forecast}
+     */
+    predict(horizon) {
+        const ret = wasm.mstlforecasterwrapper_predict(this.__wbg_ptr, horizon);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return Forecast.__wrap(ret[0]);
+    }
+}
+if (Symbol.dispose) MSTLForecasterWrapper.prototype[Symbol.dispose] = MSTLForecasterWrapper.prototype.free;
+
+/**
+ * Mean (Historic Average) forecaster - uses the historical mean as forecast.
+ */
+export class MeanForecaster {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        MeanForecasterFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_meanforecaster_free(ptr, 0);
+    }
+    /**
+     * @param {number} horizon
+     * @param {number} level
+     * @returns {Forecast}
+     */
+    predictWithIntervals(horizon, level) {
+        const ret = wasm.meanforecaster_predictWithIntervals(this.__wbg_ptr, horizon, level);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return Forecast.__wrap(ret[0]);
+    }
+    /**
+     * @param {TimeSeries} series
+     */
+    fit(series) {
+        _assertClass(series, TimeSeries);
+        const ret = wasm.meanforecaster_fit(this.__wbg_ptr, series.__wbg_ptr);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    constructor() {
+        const ret = wasm.meanforecaster_new();
+        this.__wbg_ptr = ret >>> 0;
+        MeanForecasterFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * @returns {string}
+     */
+    get name() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.meanforecaster_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);
+        }
+    }
+    /**
+     * @param {number} horizon
+     * @returns {Forecast}
+     */
+    predict(horizon) {
+        const ret = wasm.meanforecaster_predict(this.__wbg_ptr, horizon);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return Forecast.__wrap(ret[0]);
+    }
+}
+if (Symbol.dispose) MeanForecaster.prototype[Symbol.dispose] = MeanForecaster.prototype.free;
+
+/**
+ * Naive forecaster - uses the last observation as forecast.
+ */
+export class NaiveForecaster {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        NaiveForecasterFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_naiveforecaster_free(ptr, 0);
+    }
+    /**
+     * @param {number} horizon
+     * @param {number} level
+     * @returns {Forecast}
+     */
+    predictWithIntervals(horizon, level) {
+        const ret = wasm.naiveforecaster_predictWithIntervals(this.__wbg_ptr, horizon, level);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return Forecast.__wrap(ret[0]);
+    }
+    /**
+     * @param {TimeSeries} series
+     */
+    fit(series) {
+        _assertClass(series, TimeSeries);
+        const ret = wasm.naiveforecaster_fit(this.__wbg_ptr, series.__wbg_ptr);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    constructor() {
+        const ret = wasm.naiveforecaster_new();
+        this.__wbg_ptr = ret >>> 0;
+        NaiveForecasterFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * @returns {string}
+     */
+    get name() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.naiveforecaster_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);
+        }
+    }
+    /**
+     * @param {number} horizon
+     * @returns {Forecast}
+     */
+    predict(horizon) {
+        const ret = wasm.naiveforecaster_predict(this.__wbg_ptr, horizon);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return Forecast.__wrap(ret[0]);
+    }
+}
+if (Symbol.dispose) NaiveForecaster.prototype[Symbol.dispose] = NaiveForecaster.prototype.free;
+
+/**
+ * Optimized Theta forecaster - automatically optimizes parameters.
+ */
+export class OptimizedThetaForecaster {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        OptimizedThetaForecasterFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_optimizedthetaforecaster_free(ptr, 0);
+    }
+    /**
+     * @param {number} horizon
+     * @param {number} level
+     * @returns {Forecast}
+     */
+    predictWithIntervals(horizon, level) {
+        const ret = wasm.optimizedthetaforecaster_predictWithIntervals(this.__wbg_ptr, horizon, level);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return Forecast.__wrap(ret[0]);
+    }
+    /**
+     * @param {TimeSeries} series
+     */
+    fit(series) {
+        _assertClass(series, TimeSeries);
+        const ret = wasm.optimizedthetaforecaster_fit(this.__wbg_ptr, series.__wbg_ptr);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    constructor() {
+        const ret = wasm.optimizedthetaforecaster_new();
+        this.__wbg_ptr = ret >>> 0;
+        OptimizedThetaForecasterFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * @returns {string}
+     */
+    get name() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.optimizedthetaforecaster_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);
+        }
+    }
+    /**
+     * @param {number} horizon
+     * @returns {Forecast}
+     */
+    predict(horizon) {
+        const ret = wasm.optimizedthetaforecaster_predict(this.__wbg_ptr, horizon);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return Forecast.__wrap(ret[0]);
+    }
+}
+if (Symbol.dispose) OptimizedThetaForecaster.prototype[Symbol.dispose] = OptimizedThetaForecaster.prototype.free;
+
+/**
+ * Random Walk with Drift forecaster.
+ */
+export class RandomWalkDriftForecaster {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        RandomWalkDriftForecasterFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_randomwalkdriftforecaster_free(ptr, 0);
+    }
+    /**
+     * @param {number} horizon
+     * @param {number} level
+     * @returns {Forecast}
+     */
+    predictWithIntervals(horizon, level) {
+        const ret = wasm.randomwalkdriftforecaster_predictWithIntervals(this.__wbg_ptr, horizon, level);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return Forecast.__wrap(ret[0]);
+    }
+    /**
+     * @param {TimeSeries} series
+     */
+    fit(series) {
+        _assertClass(series, TimeSeries);
+        const ret = wasm.randomwalkdriftforecaster_fit(this.__wbg_ptr, series.__wbg_ptr);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    constructor() {
+        const ret = wasm.randomwalkdriftforecaster_new();
+        this.__wbg_ptr = ret >>> 0;
+        RandomWalkDriftForecasterFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * @returns {string}
+     */
+    get name() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.randomwalkdriftforecaster_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);
+        }
+    }
+    /**
+     * @param {number} horizon
+     * @returns {Forecast}
+     */
+    predict(horizon) {
+        const ret = wasm.randomwalkdriftforecaster_predict(this.__wbg_ptr, horizon);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return Forecast.__wrap(ret[0]);
+    }
+}
+if (Symbol.dispose) RandomWalkDriftForecaster.prototype[Symbol.dispose] = RandomWalkDriftForecaster.prototype.free;
+
+/**
+ * SARIMA forecaster - Seasonal ARIMA.
+ */
+export class SARIMAForecaster {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        SARIMAForecasterFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_sarimaforecaster_free(ptr, 0);
+    }
+    /**
+     * @param {number} horizon
+     * @param {number} level
+     * @returns {Forecast}
+     */
+    predictWithIntervals(horizon, level) {
+        const ret = wasm.sarimaforecaster_predictWithIntervals(this.__wbg_ptr, horizon, level);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return Forecast.__wrap(ret[0]);
+    }
+    /**
+     * @param {TimeSeries} series
+     */
+    fit(series) {
+        _assertClass(series, TimeSeries);
+        const ret = wasm.sarimaforecaster_fit(this.__wbg_ptr, series.__wbg_ptr);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * @param p - AR order
+     * @param d - Differencing order
+     * @param q - MA order
+     * @param seasonal_p - Seasonal AR order
+     * @param seasonal_d - Seasonal differencing order
+     * @param seasonal_q - Seasonal MA order
+     * @param period - Seasonal period
+     * @param {number} p
+     * @param {number} d
+     * @param {number} q
+     * @param {number} seasonal_p
+     * @param {number} seasonal_d
+     * @param {number} seasonal_q
+     * @param {number} period
+     */
+    constructor(p, d, q, seasonal_p, seasonal_d, seasonal_q, period) {
+        const ret = wasm.sarimaforecaster_new(p, d, q, seasonal_p, seasonal_d, seasonal_q, period);
+        this.__wbg_ptr = ret >>> 0;
+        SARIMAForecasterFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * @returns {string}
+     */
+    get name() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.sarimaforecaster_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);
+        }
+    }
+    /**
+     * @param {number} horizon
+     * @returns {Forecast}
+     */
+    predict(horizon) {
+        const ret = wasm.sarimaforecaster_predict(this.__wbg_ptr, horizon);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return Forecast.__wrap(ret[0]);
+    }
+}
+if (Symbol.dispose) SARIMAForecaster.prototype[Symbol.dispose] = SARIMAForecaster.prototype.free;
+
+/**
+ * Simple Exponential Smoothing forecaster.
+ */
+export class SESForecaster {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        SESForecasterFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_sesforecaster_free(ptr, 0);
+    }
+    /**
+     * @param {TimeSeries} series
+     */
+    fit(series) {
+        _assertClass(series, TimeSeries);
+        const ret = wasm.sesforecaster_fit(this.__wbg_ptr, series.__wbg_ptr);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * @param alpha - Smoothing parameter (0 < alpha <= 1)
+     * @param {number} alpha
+     */
+    constructor(alpha) {
+        const ret = wasm.sesforecaster_new(alpha);
+        this.__wbg_ptr = ret >>> 0;
+        SESForecasterFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * @returns {string}
+     */
+    get name() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.sesforecaster_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);
+        }
+    }
+    /**
+     * @param {number} horizon
+     * @returns {Forecast}
+     */
+    predict(horizon) {
+        const ret = wasm.sesforecaster_predict(this.__wbg_ptr, horizon);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return Forecast.__wrap(ret[0]);
+    }
+}
+if (Symbol.dispose) SESForecaster.prototype[Symbol.dispose] = SESForecaster.prototype.free;
+
+/**
+ * Simple Moving Average forecaster.
+ */
+export class SMAForecaster {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        SMAForecasterFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_smaforecaster_free(ptr, 0);
+    }
+    /**
+     * @param {TimeSeries} series
+     */
+    fit(series) {
+        _assertClass(series, TimeSeries);
+        const ret = wasm.smaforecaster_fit(this.__wbg_ptr, series.__wbg_ptr);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * @param window - Window size for the moving average
+     * @param {number} window
+     */
+    constructor(window) {
+        const ret = wasm.smaforecaster_new(window);
+        this.__wbg_ptr = ret >>> 0;
+        SMAForecasterFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * @returns {string}
+     */
+    get name() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.smaforecaster_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);
+        }
+    }
+    /**
+     * @param {number} horizon
+     * @returns {Forecast}
+     */
+    predict(horizon) {
+        const ret = wasm.smaforecaster_predict(this.__wbg_ptr, horizon);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return Forecast.__wrap(ret[0]);
+    }
+}
+if (Symbol.dispose) SMAForecaster.prototype[Symbol.dispose] = SMAForecaster.prototype.free;
+
+/**
+ * Seasonal Exponential Smoothing forecaster.
+ */
+export class SeasonalESForecaster {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        SeasonalESForecasterFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_seasonalesforecaster_free(ptr, 0);
+    }
+    /**
+     * @param {TimeSeries} series
+     */
+    fit(series) {
+        _assertClass(series, TimeSeries);
+        const ret = wasm.seasonalesforecaster_fit(this.__wbg_ptr, series.__wbg_ptr);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * @param period - Seasonal period
+     * @param {number} period
+     */
+    constructor(period) {
+        const ret = wasm.seasonalesforecaster_new(period);
+        this.__wbg_ptr = ret >>> 0;
+        SeasonalESForecasterFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * @returns {string}
+     */
+    get name() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.seasonalesforecaster_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);
+        }
+    }
+    /**
+     * @param {number} horizon
+     * @returns {Forecast}
+     */
+    predict(horizon) {
+        const ret = wasm.seasonalesforecaster_predict(this.__wbg_ptr, horizon);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return Forecast.__wrap(ret[0]);
+    }
+}
+if (Symbol.dispose) SeasonalESForecaster.prototype[Symbol.dispose] = SeasonalESForecaster.prototype.free;
+
+/**
+ * Seasonal Naive forecaster - uses observations from the same season.
+ */
+export class SeasonalNaiveForecaster {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        SeasonalNaiveForecasterFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_seasonalnaiveforecaster_free(ptr, 0);
+    }
+    /**
+     * @param {number} horizon
+     * @param {number} level
+     * @returns {Forecast}
+     */
+    predictWithIntervals(horizon, level) {
+        const ret = wasm.seasonalnaiveforecaster_predictWithIntervals(this.__wbg_ptr, horizon, level);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return Forecast.__wrap(ret[0]);
+    }
+    /**
+     * @param {TimeSeries} series
+     */
+    fit(series) {
+        _assertClass(series, TimeSeries);
+        const ret = wasm.seasonalnaiveforecaster_fit(this.__wbg_ptr, series.__wbg_ptr);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * @param period - Seasonal period (e.g., 12 for monthly data with yearly seasonality)
+     * @param {number} period
+     */
+    constructor(period) {
+        const ret = wasm.seasonalnaiveforecaster_new(period);
+        this.__wbg_ptr = ret >>> 0;
+        SeasonalNaiveForecasterFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * @returns {string}
+     */
+    get name() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.seasonalnaiveforecaster_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);
+        }
+    }
+    /**
+     * @param {number} horizon
+     * @returns {Forecast}
+     */
+    predict(horizon) {
+        const ret = wasm.seasonalnaiveforecaster_predict(this.__wbg_ptr, horizon);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return Forecast.__wrap(ret[0]);
+    }
+}
+if (Symbol.dispose) SeasonalNaiveForecaster.prototype[Symbol.dispose] = SeasonalNaiveForecaster.prototype.free;
+
+/**
+ * Seasonal Window Average forecaster.
+ */
+export class SeasonalWindowAverageForecaster {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        SeasonalWindowAverageForecasterFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_seasonalwindowaverageforecaster_free(ptr, 0);
+    }
+    /**
+     * @param {TimeSeries} series
+     */
+    fit(series) {
+        _assertClass(series, TimeSeries);
+        const ret = wasm.seasonalwindowaverageforecaster_fit(this.__wbg_ptr, series.__wbg_ptr);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * @param period - Seasonal period
+     * @param window - Number of seasonal cycles to average
+     * @param {number} period
+     * @param {number} window
+     */
+    constructor(period, window) {
+        const ret = wasm.seasonalwindowaverageforecaster_new(period, window);
+        this.__wbg_ptr = ret >>> 0;
+        SeasonalWindowAverageForecasterFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * @returns {string}
+     */
+    get name() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.seasonalwindowaverageforecaster_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);
+        }
+    }
+    /**
+     * @param {number} horizon
+     * @returns {Forecast}
+     */
+    predict(horizon) {
+        const ret = wasm.seasonalwindowaverageforecaster_predict(this.__wbg_ptr, horizon);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return Forecast.__wrap(ret[0]);
+    }
+}
+if (Symbol.dispose) SeasonalWindowAverageForecaster.prototype[Symbol.dispose] = SeasonalWindowAverageForecaster.prototype.free;
+
+/**
+ * TBATS - Trigonometric seasonality, Box-Cox, ARMA errors, Trend, Seasonal.
+ */
+export class TBATSForecaster {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        TBATSForecasterFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_tbatsforecaster_free(ptr, 0);
+    }
+    /**
+     * @param {TimeSeries} series
+     */
+    fit(series) {
+        _assertClass(series, TimeSeries);
+        const ret = wasm.tbatsforecaster_fit(this.__wbg_ptr, series.__wbg_ptr);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * @param seasonal_periods - Array of seasonal periods (e.g., [7, 365] for daily data)
+     * @param {Uint32Array} seasonal_periods
+     */
+    constructor(seasonal_periods) {
+        const ptr0 = passArray32ToWasm0(seasonal_periods, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.tbatsforecaster_new(ptr0, len0);
+        this.__wbg_ptr = ret >>> 0;
+        TBATSForecasterFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * @returns {string}
+     */
+    get name() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.tbatsforecaster_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);
+        }
+    }
+    /**
+     * @param {number} horizon
+     * @returns {Forecast}
+     */
+    predict(horizon) {
+        const ret = wasm.tbatsforecaster_predict(this.__wbg_ptr, horizon);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return Forecast.__wrap(ret[0]);
+    }
+}
+if (Symbol.dispose) TBATSForecaster.prototype[Symbol.dispose] = TBATSForecaster.prototype.free;
+
+/**
+ * TSB (Teunter-Syntetos-Babai) method for intermittent demand.
+ */
+export class TSBForecaster {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        TSBForecasterFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_tsbforecaster_free(ptr, 0);
+    }
+    /**
+     * @param {TimeSeries} series
+     */
+    fit(series) {
+        _assertClass(series, TimeSeries);
+        const ret = wasm.tsbforecaster_fit(this.__wbg_ptr, series.__wbg_ptr);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    constructor() {
+        const ret = wasm.tsbforecaster_new();
+        this.__wbg_ptr = ret >>> 0;
+        TSBForecasterFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * @returns {string}
+     */
+    get name() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.tsbforecaster_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);
+        }
+    }
+    /**
+     * @param {number} horizon
+     * @returns {Forecast}
+     */
+    predict(horizon) {
+        const ret = wasm.tsbforecaster_predict(this.__wbg_ptr, horizon);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return Forecast.__wrap(ret[0]);
+    }
+}
+if (Symbol.dispose) TSBForecaster.prototype[Symbol.dispose] = TSBForecaster.prototype.free;
+
+/**
+ * Theta forecaster - the standard Theta method.
+ */
+export class ThetaForecaster {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        ThetaForecasterFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_thetaforecaster_free(ptr, 0);
+    }
+    /**
+     * @param {number} horizon
+     * @param {number} level
+     * @returns {Forecast}
+     */
+    predictWithIntervals(horizon, level) {
+        const ret = wasm.thetaforecaster_predictWithIntervals(this.__wbg_ptr, horizon, level);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return Forecast.__wrap(ret[0]);
+    }
+    /**
+     * @param {TimeSeries} series
+     */
+    fit(series) {
+        _assertClass(series, TimeSeries);
+        const ret = wasm.thetaforecaster_fit(this.__wbg_ptr, series.__wbg_ptr);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    constructor() {
+        const ret = wasm.thetaforecaster_new();
+        this.__wbg_ptr = ret >>> 0;
+        ThetaForecasterFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * @returns {string}
+     */
+    get name() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.thetaforecaster_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);
+        }
+    }
+    /**
+     * @param {number} horizon
+     * @returns {Forecast}
+     */
+    predict(horizon) {
+        const ret = wasm.thetaforecaster_predict(this.__wbg_ptr, horizon);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return Forecast.__wrap(ret[0]);
+    }
+}
+if (Symbol.dispose) ThetaForecaster.prototype[Symbol.dispose] = ThetaForecaster.prototype.free;
+
+/**
+ * A time series wrapper for JavaScript.
+ *
+ * Represents a univariate time series with values indexed by position.
+ * Timestamps are optional and can be provided as milliseconds since Unix epoch.
+ */
+export class TimeSeries {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(TimeSeries.prototype);
+        obj.__wbg_ptr = ptr;
+        TimeSeriesFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        TimeSeriesFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_timeseries_free(ptr, 0);
+    }
+    /**
+     * Create a time series with timestamps.
+     *
+     * @param values - Array of numeric values
+     * @param timestamps - Array of timestamps as milliseconds since Unix epoch
+     * @returns A new TimeSeries instance
+     * @param {Float64Array} values
+     * @param {Float64Array} timestamps_ms
+     * @returns {TimeSeries}
+     */
+    static withTimestamps(values, timestamps_ms) {
+        const ptr0 = passArrayF64ToWasm0(values, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passArrayF64ToWasm0(timestamps_ms, wasm.__wbindgen_malloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.timeseries_withTimestamps(ptr0, len0, ptr1, len1);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return TimeSeries.__wrap(ret[0]);
+    }
+    /**
+     * Check if the series has missing values (NaN).
+     * @returns {boolean}
+     */
+    hasMissingValues() {
+        const ret = wasm.timeseries_hasMissingValues(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * Create a new time series from an array of values.
+     *
+     * @param values - Array of numeric values
+     * @returns A new TimeSeries instance
+     * @param {Float64Array} values
+     */
+    constructor(values) {
+        const ptr0 = passArrayF64ToWasm0(values, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.timeseries_new(ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        this.__wbg_ptr = ret[0] >>> 0;
+        TimeSeriesFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * Get a slice of values.
+     *
+     * @param start - Start index (inclusive)
+     * @param end - End index (exclusive)
+     * @returns Array of values in the specified range
+     * @param {number} start
+     * @param {number} end
+     * @returns {TimeSeries}
+     */
+    slice(start, end) {
+        const ret = wasm.timeseries_slice(this.__wbg_ptr, start, end);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return TimeSeries.__wrap(ret[0]);
+    }
+    /**
+     * Get the number of observations.
+     * @returns {number}
+     */
+    get length() {
+        const ret = wasm.timeseries_length(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Get all values as an array.
+     * @returns {Float64Array}
+     */
+    get values() {
+        const ret = wasm.timeseries_values(this.__wbg_ptr);
+        var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+        return v1;
+    }
+    /**
+     * Check if the series is empty.
+     * @returns {boolean}
+     */
+    isEmpty() {
+        const ret = wasm.timeseries_isEmpty(this.__wbg_ptr);
+        return ret !== 0;
+    }
+}
+if (Symbol.dispose) TimeSeries.prototype[Symbol.dispose] = TimeSeries.prototype.free;
+
+/**
+ * Window Average forecaster - uses the last N observations.
+ */
+export class WindowAverageForecaster {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        WindowAverageForecasterFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_windowaverageforecaster_free(ptr, 0);
+    }
+    /**
+     * @param {TimeSeries} series
+     */
+    fit(series) {
+        _assertClass(series, TimeSeries);
+        const ret = wasm.windowaverageforecaster_fit(this.__wbg_ptr, series.__wbg_ptr);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * @param window_size - Size of the rolling window
+     * @param {number} window_size
+     */
+    constructor(window_size) {
+        const ret = wasm.windowaverageforecaster_new(window_size);
+        this.__wbg_ptr = ret >>> 0;
+        WindowAverageForecasterFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * @returns {string}
+     */
+    get name() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.windowaverageforecaster_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);
+        }
+    }
+    /**
+     * @param {number} horizon
+     * @returns {Forecast}
+     */
+    predict(horizon) {
+        const ret = wasm.windowaverageforecaster_predict(this.__wbg_ptr, horizon);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return Forecast.__wrap(ret[0]);
+    }
+}
+if (Symbol.dispose) WindowAverageForecaster.prototype[Symbol.dispose] = WindowAverageForecaster.prototype.free;
+
+/**
+ * Initialize the WASM module.
+ *
+ * This function is called automatically when the module is loaded.
+ */
+export function init() {
+    wasm.init();
+}
+
+/**
+ * Get the library version.
+ * @returns {string}
+ */
+export function version() {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+        const ret = wasm.version();
+        deferred1_0 = ret[0];
+        deferred1_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+    }
+}
+
+const EXPECTED_RESPONSE_TYPES = new Set(['basic', 'cors', 'default']);
+
+async function __wbg_load(module, imports) {
+    if (typeof Response === 'function' && module instanceof Response) {
+        if (typeof WebAssembly.instantiateStreaming === 'function') {
+            try {
+                return await WebAssembly.instantiateStreaming(module, imports);
+            } catch (e) {
+                const validResponse = module.ok && EXPECTED_RESPONSE_TYPES.has(module.type);
+
+                if (validResponse && module.headers.get('Content-Type') !== 'application/wasm') {
+                    console.warn("`WebAssembly.instantiateStreaming` failed because your server does not serve Wasm with `application/wasm` MIME type. Falling back to `WebAssembly.instantiate` which is slower. Original error:\n", e);
+
+                } else {
+                    throw e;
+                }
+            }
+        }
+
+        const bytes = await module.arrayBuffer();
+        return await WebAssembly.instantiate(bytes, imports);
+    } else {
+        const instance = await WebAssembly.instantiate(module, imports);
+
+        if (instance instanceof WebAssembly.Instance) {
+            return { instance, module };
+        } else {
+            return instance;
+        }
+    }
+}
+
+function __wbg_get_imports() {
+    const imports = {};
+    imports.wbg = {};
+    imports.wbg.__wbg_Error_52673b7de5a0ca89 = function(arg0, arg1) {
+        const ret = Error(getStringFromWasm0(arg0, arg1));
+        return ret;
+    };
+    imports.wbg.__wbg___wbindgen_throw_dd24417ed36fc46e = function(arg0, arg1) {
+        throw new Error(getStringFromWasm0(arg0, arg1));
+    };
+    imports.wbg.__wbg_getTime_ad1e9878a735af08 = function(arg0) {
+        const ret = arg0.getTime();
+        return ret;
+    };
+    imports.wbg.__wbg_new_0_23cedd11d9b40c9d = function() {
+        const ret = new Date();
+        return ret;
+    };
+    imports.wbg.__wbindgen_init_externref_table = function() {
+        const table = wasm.__wbindgen_externrefs;
+        const offset = table.grow(4);
+        table.set(0, undefined);
+        table.set(offset + 0, undefined);
+        table.set(offset + 1, null);
+        table.set(offset + 2, true);
+        table.set(offset + 3, false);
+    };
+
+    return imports;
+}
+
+function __wbg_finalize_init(instance, module) {
+    wasm = instance.exports;
+    __wbg_init.__wbindgen_wasm_module = module;
+    cachedFloat64ArrayMemory0 = null;
+    cachedUint32ArrayMemory0 = null;
+    cachedUint8ArrayMemory0 = null;
+
+
+    wasm.__wbindgen_start();
+    return wasm;
+}
+
+function initSync(module) {
+    if (wasm !== undefined) return wasm;
+
+
+    if (typeof module !== 'undefined') {
+        if (Object.getPrototypeOf(module) === Object.prototype) {
+            ({module} = module)
+        } else {
+            console.warn('using deprecated parameters for `initSync()`; pass a single object instead')
+        }
+    }
+
+    const imports = __wbg_get_imports();
+    if (!(module instanceof WebAssembly.Module)) {
+        module = new WebAssembly.Module(module);
+    }
+    const instance = new WebAssembly.Instance(module, imports);
+    return __wbg_finalize_init(instance, module);
+}
+
+async function __wbg_init(module_or_path) {
+    if (wasm !== undefined) return wasm;
+
+
+    if (typeof module_or_path !== 'undefined') {
+        if (Object.getPrototypeOf(module_or_path) === Object.prototype) {
+            ({module_or_path} = module_or_path)
+        } else {
+            console.warn('using deprecated parameters for the initialization function; pass a single object instead')
+        }
+    }
+
+    if (typeof module_or_path === 'undefined') {
+        module_or_path = new URL('anofox_forecast_js_bg.wasm', import.meta.url);
+    }
+    const imports = __wbg_get_imports();
+
+    if (typeof module_or_path === 'string' || (typeof Request === 'function' && module_or_path instanceof Request) || (typeof URL === 'function' && module_or_path instanceof URL)) {
+        module_or_path = fetch(module_or_path);
+    }
+
+    const { instance, module } = await __wbg_load(await module_or_path, imports);
+
+    return __wbg_finalize_init(instance, module);
+}
+
+export { initSync };
+export default __wbg_init;