@nirs4all/methods 1.0.17 → 1.1.0

package/dist/estimatorRolesGenerated.js

@@ -0,0 +1,3825 @@
+// SPDX-License-Identifier: CECILL-2.1
+// Generated by scripts/generate_js_roles.py from `n4m_cli --manifest-json`. Do not edit.
+// Native ABI 2.13.0.
+import { NativeEstimator, NativeMethod, NativeProcedure, } from "./estimatorRoles.js";
+/** Native `aom_pop.aom_chain_fixed_fit` (regressor). */
+export class AOMFixedCandidate extends NativeEstimator {
+    methodId = "aom_pop.aom_chain_fixed_fit";
+    paramTypes = {
+        op_kinds: "int_array",
+        param_offsets: "int_array",
+        chain_params: "double_array",
+        head: "enum",
+        param: "double",
+        center_x: "bool",
+        scale_x: "bool",
+        center_y: "bool",
+        scale_y: "bool",
+        moment_policy: "enum",
+    };
+    constructor(params = {}) {
+        super();
+        this.params = { ...params };
+    }
+    predict(X) {
+        return this.predictMatrix(X);
+    }
+}
+NativeMethod.register("aom_pop.aom_chain_fixed_fit", AOMFixedCandidate);
+/** Native `aom_pop.aom_chain_ridge_pls` (regressor). */
+export class AOMChainRidgePLS extends NativeEstimator {
+    methodId = "aom_pop.aom_chain_ridge_pls";
+    paramTypes = {
+        chain_offsets: "int_array",
+        op_kinds: "int_array",
+        param_offsets: "int_array",
+        chain_params: "double_array",
+        pls_components: "int_array",
+        ridge_lambdas: "double_array",
+        cv: "int",
+        center_x: "bool",
+        center_y: "bool",
+    };
+    constructor(params = {}) {
+        super();
+        this.params = { ...params };
+    }
+    predict(X) {
+        return this.predictMatrix(X);
+    }
+}
+NativeMethod.register("aom_pop.aom_chain_ridge_pls", AOMChainRidgePLS);
+/** Native `aom_pop.aom_chain_sweep` (regressor). */
+export class AOMChainSweep extends NativeEstimator {
+    methodId = "aom_pop.aom_chain_sweep";
+    paramTypes = {
+        chain_offsets: "int_array",
+        op_kinds: "int_array",
+        param_offsets: "int_array",
+        chain_params: "double_array",
+        cv: "int",
+        ridge_lambdas: "double_array",
+        pls_components: "int_array",
+        heads: "enum",
+        center_x: "bool",
+        scale_x: "bool",
+        center_y: "bool",
+        scale_y: "bool",
+        moment_policy: "enum",
+    };
+    constructor(params = {}) {
+        super();
+        this.params = { ...params };
+    }
+    predict(X) {
+        return this.predictMatrix(X);
+    }
+}
+NativeMethod.register("aom_pop.aom_chain_sweep", AOMChainSweep);
+/** Native `aom_pop.aom_pls` (regressor). */
+export class AOMPLS extends NativeEstimator {
+    methodId = "aom_pop.aom_pls";
+    paramTypes = {
+        max_components: "int",
+        op_kinds: "int_array",
+        param_offsets: "int_array",
+        op_params: "double_array",
+        cv: "int",
+        center_x: "bool",
+        scale_x: "bool",
+        center_y: "bool",
+        scale_y: "bool",
+    };
+    constructor(params = {}) {
+        super();
+        this.params = { ...params };
+    }
+    predict(X) {
+        return this.predictMatrix(X);
+    }
+}
+NativeMethod.register("aom_pop.aom_pls", AOMPLS);
+/** Native `aom_pop.aom_pls_superblock` (regressor). */
+export class AOMPLSSuperblock extends NativeEstimator {
+    methodId = "aom_pop.aom_pls_superblock";
+    paramTypes = {
+        op_kinds: "int_array",
+        param_offsets: "int_array",
+        op_params: "double_array",
+        pls_components: "int_array",
+        cv: "int",
+        block_scaling: "enum",
+        center_x: "bool",
+        center_y: "bool",
+    };
+    constructor(params = {}) {
+        super();
+        this.params = { ...params };
+    }
+    predict(X) {
+        return this.predictMatrix(X);
+    }
+}
+NativeMethod.register("aom_pop.aom_pls_superblock", AOMPLSSuperblock);
+/** Native `aom_pop.aom_preprocessing` (transformer). */
+export class AOMPreprocessing extends NativeEstimator {
+    methodId = "aom_pop.aom_preprocessing";
+    paramTypes = {
+        op_kinds: "int_array",
+        param_offsets: "int_array",
+        op_params: "double_array",
+        gating_mode: "enum",
+    };
+    constructor(params = {}) {
+        super();
+        this.params = { ...params };
+    }
+    transform(X) {
+        return this.transformMatrix(X);
+    }
+}
+NativeMethod.register("aom_pop.aom_preprocessing", AOMPreprocessing);
+/** Native `aom_pop.aom_ridge_pls_superblock` (regressor). */
+export class AOMRidgePLSSuperblock extends NativeEstimator {
+    methodId = "aom_pop.aom_ridge_pls_superblock";
+    paramTypes = {
+        op_kinds: "int_array",
+        param_offsets: "int_array",
+        op_params: "double_array",
+        pls_components: "int_array",
+        ridge_lambdas: "double_array",
+        cv: "int",
+        block_scaling: "enum",
+        center_x: "bool",
+    };
+    constructor(params = {}) {
+        super();
+        this.params = { ...params };
+    }
+    predict(X) {
+        return this.predictMatrix(X);
+    }
+}
+NativeMethod.register("aom_pop.aom_ridge_pls_superblock", AOMRidgePLSSuperblock);
+/** Native `aom_pop.aom_sweep` (regressor). */
+export class AOMSweep extends NativeEstimator {
+    methodId = "aom_pop.aom_sweep";
+    paramTypes = {
+        profile: "enum",
+        cv: "int",
+        ridge_lambdas: "double_array",
+        pls_components: "int_array",
+        heads: "enum",
+        center_x: "bool",
+        scale_x: "bool",
+        center_y: "bool",
+        scale_y: "bool",
+        moment_policy: "enum",
+    };
+    constructor(params = {}) {
+        super();
+        this.params = { ...params };
+    }
+    predict(X) {
+        return this.predictMatrix(X);
+    }
+}
+NativeMethod.register("aom_pop.aom_sweep", AOMSweep);
+/** Native `aom_pop.calibration` (regressor). */
+export class AOMCalibration extends NativeEstimator {
+    methodId = "aom_pop.calibration";
+    paramTypes = {
+        head: "enum",
+        fast: "bool",
+        max_components: "int",
+        alphas: "double_array",
+        cv: "int",
+        branches: "int_array",
+        max_depth: "int",
+        rank: "int",
+    };
+    constructor(params = {}) {
+        super();
+        this.params = { ...params };
+    }
+    predict(X) {
+        return this.predictMatrix(X);
+    }
+}
+NativeMethod.register("aom_pop.calibration", AOMCalibration);
+/** Native `aom_pop.linear_stack_compress` (generic). */
+export class LinearStackCompress extends NativeProcedure {
+    methodId = "aom_pop.linear_stack_compress";
+    paramTypes = {
+        base_intercepts: "double_array",
+        meta_weights: "double_array",
+        meta_intercept: "double_array",
+    };
+    constructor(params = {}) {
+        super();
+        this.params = { ...params };
+    }
+    run(X, y, inputs = {}) {
+        return this.runOutputs(X, y, inputs);
+    }
+}
+NativeMethod.register("aom_pop.linear_stack_compress", LinearStackCompress);
+/** Native `aom_pop.operator_pls_stack` (regressor). */
+export class AOMOperatorPLSStack extends NativeEstimator {
+    methodId = "aom_pop.operator_pls_stack";
+    paramTypes = {
+        profile: "enum",
+        cv: "int",
+        components: "int_array",
+        alphas: "double_array",
+        std_penalty: "double",
+        gap_penalty: "double",
+        center_x: "bool",
+        scale_x: "bool",
+        center_y: "bool",
+        scale_y: "bool",
+    };
+    constructor(params = {}) {
+        super();
+        this.params = { ...params };
+    }
+    predict(X) {
+        return this.predictMatrix(X);
+    }
+}
+NativeMethod.register("aom_pop.operator_pls_stack", AOMOperatorPLSStack);
+/** Native `aom_pop.pop_pls` (regressor). */
+export class POPPLS extends NativeEstimator {
+    methodId = "aom_pop.pop_pls";
+    paramTypes = {
+        max_components: "int",
+        op_kinds: "int_array",
+        param_offsets: "int_array",
+        op_params: "double_array",
+        cv: "int",
+        center_x: "bool",
+        scale_x: "bool",
+        center_y: "bool",
+        scale_y: "bool",
+    };
+    constructor(params = {}) {
+        super();
+        this.params = { ...params };
+    }
+    predict(X) {
+        return this.predictMatrix(X);
+    }
+}
+NativeMethod.register("aom_pop.pop_pls", POPPLS);
+/** Native `aom_pop.ridge_active_superblock` (regressor). */
+export class AOMRidgeActiveSuperblock extends NativeEstimator {
+    methodId = "aom_pop.ridge_active_superblock";
+    paramTypes = {
+        op_kinds: "int_array",
+        param_offsets: "int_array",
+        op_params: "double_array",
+        alphas: "double_array",
+        cv: "int",
+        active_top_m: "int",
+        active_diversity_threshold: "double",
+        active_score_method: "enum",
+        active_max_per_family: "int",
+        keep_identity: "bool",
+        block_scaling: "enum",
+        center_x: "bool",
+        center_y: "bool",
+    };
+    constructor(params = {}) {
+        super();
+        this.params = { ...params };
+    }
+    predict(X) {
+        return this.predictMatrix(X);
+    }
+}
+NativeMethod.register("aom_pop.ridge_active_superblock", AOMRidgeActiveSuperblock);
+/** Native `aom_pop.ridge_blender` (regressor). */
+export class AOMRidgeBlender extends NativeEstimator {
+    methodId = "aom_pop.ridge_blender";
+    paramTypes = {
+        profile: "enum",
+        cv: "int",
+        ridge_lambdas: "double_array",
+        regularizer: "double",
+        center_x: "bool",
+        scale_x: "bool",
+        center_y: "bool",
+        scale_y: "bool",
+    };
+    constructor(params = {}) {
+        super();
+        this.params = { ...params };
+    }
+    predict(X) {
+        return this.predictMatrix(X);
+    }
+}
+NativeMethod.register("aom_pop.ridge_blender", AOMRidgeBlender);
+/** Native `aom_pop.ridge_global` (regressor). */
+export class AOMRidgeGlobal extends NativeEstimator {
+    methodId = "aom_pop.ridge_global";
+    paramTypes = {
+        op_kinds: "int_array",
+        param_offsets: "int_array",
+        op_params: "double_array",
+        cv: "int",
+        ridge_lambdas: "double_array",
+        center_x: "bool",
+        scale_x: "bool",
+        center_y: "bool",
+        scale_y: "bool",
+        moment_policy: "enum",
+    };
+    constructor(params = {}) {
+        super();
+        this.params = { ...params };
+    }
+    predict(X) {
+        return this.predictMatrix(X);
+    }
+}
+NativeMethod.register("aom_pop.ridge_global", AOMRidgeGlobal);
+/** Native `aom_pop.ridge_mkl_superblock` (regressor). */
+export class AOMRidgeMKLSuperblock extends NativeEstimator {
+    methodId = "aom_pop.ridge_mkl_superblock";
+    paramTypes = {
+        op_kinds: "int_array",
+        param_offsets: "int_array",
+        op_params: "double_array",
+        alphas: "double_array",
+        cv: "int",
+        mkl_top_k: "int",
+        block_scaling: "enum",
+        center_x: "bool",
+        center_y: "bool",
+    };
+    constructor(params = {}) {
+        super();
+        this.params = { ...params };
+    }
+    predict(X) {
+        return this.predictMatrix(X);
+    }
+}
+NativeMethod.register("aom_pop.ridge_mkl_superblock", AOMRidgeMKLSuperblock);
+/** Native `aom_pop.ridge_superblock` (regressor). */
+export class AOMRidgeSuperblock extends NativeEstimator {
+    methodId = "aom_pop.ridge_superblock";
+    paramTypes = {
+        op_kinds: "int_array",
+        param_offsets: "int_array",
+        op_params: "double_array",
+        alphas: "double_array",
+        cv: "int",
+        block_scaling: "enum",
+        center_x: "bool",
+        center_y: "bool",
+    };
+    constructor(params = {}) {
+        super();
+        this.params = { ...params };
+    }
+    predict(X) {
+        return this.predictMatrix(X);
+    }
+}
+NativeMethod.register("aom_pop.ridge_superblock", AOMRidgeSuperblock);
+/** Native `aom_pop.robust_hpo` (regressor). */
+export class AOMRobustHPO extends NativeEstimator {
+    methodId = "aom_pop.robust_hpo";
+    paramTypes = {
+        profile: "enum",
+        cv: "int",
+        heads: "enum",
+    };
+    constructor(params = {}) {
+        super();
+        this.params = { ...params };
+    }
+    predict(X) {
+        return this.predictMatrix(X);
+    }
+}
+NativeMethod.register("aom_pop.robust_hpo", AOMRobustHPO);
+/** Native `augmentation.drift.linear_drift` (augmenter). */
+export class LinearDrift extends NativeProcedure {
+    methodId = "augmentation.drift.linear_drift";
+    paramTypes = {
+        offset_min: "double",
+        offset_max: "double",
+        slope_min: "double",
+        slope_max: "double",
+        seed: "int",
+    };
+    constructor(params = {}) {
+        super();
+        this.params = { ...params };
+    }
+    augment(X, axis) {
+        return this.augmentMatrix(X, axis);
+    }
+}
+NativeMethod.register("augmentation.drift.linear_drift", LinearDrift);
+/** Native `augmentation.drift.path_length` (augmenter). */
+export class PathLength extends NativeProcedure {
+    methodId = "augmentation.drift.path_length";
+    paramTypes = {
+        path_length_std: "double",
+        min_path_length: "double",
+        seed: "int",
+    };
+    constructor(params = {}) {
+        super();
+        this.params = { ...params };
+    }
+    augment(X, axis) {
+        return this.augmentMatrix(X, axis);
+    }
+}
+NativeMethod.register("augmentation.drift.path_length", PathLength);
+/** Native `augmentation.drift.poly_drift` (augmenter). */
+export class PolyDrift extends NativeProcedure {
+    methodId = "augmentation.drift.poly_drift";
+    paramTypes = {
+        coeff_min: "double_array",
+        coeff_max: "double_array",
+        seed: "int",
+    };
+    constructor(params = {}) {
+        super();
+        this.params = { ...params };
+    }
+    augment(X, axis) {
+        return this.augmentMatrix(X, axis);
+    }
+}
+NativeMethod.register("augmentation.drift.poly_drift", PolyDrift);
+/** Native `augmentation.edge_artifacts.detector_rolloff` (augmenter). Required inputs: axis. */
+export class DetectorRolloff extends NativeProcedure {
+    methodId = "augmentation.edge_artifacts.detector_rolloff";
+    paramTypes = {
+        detector_model: "enum",
+        effect_strength: "double",
+        noise_amplification: "double",
+        include_baseline_distortion: "bool",
+        seed: "int",
+    };
+    constructor(params = {}) {
+        super();
+        this.params = { ...params };
+    }
+    augment(X, axis) {
+        return this.augmentMatrix(X, axis);
+    }
+}
+NativeMethod.register("augmentation.edge_artifacts.detector_rolloff", DetectorRolloff);
+/** Native `augmentation.edge_artifacts.edge_artifacts` (augmenter). Required inputs: axis. */
+export class EdgeArtifacts extends NativeProcedure {
+    methodId = "augmentation.edge_artifacts.edge_artifacts";
+    paramTypes = {
+        detector_roll_off: "bool",
+        stray_light: "bool",
+        edge_curvature: "bool",
+        truncated_peaks: "bool",
+        overall_strength: "double",
+        detector_model: "enum",
+        seed: "int",
+    };
+    constructor(params = {}) {
+        super();
+        this.params = { ...params };
+    }
+    augment(X, axis) {
+        return this.augmentMatrix(X, axis);
+    }
+}
+NativeMethod.register("augmentation.edge_artifacts.edge_artifacts", EdgeArtifacts);
+/** Native `augmentation.edge_artifacts.edge_curvature` (augmenter). Required inputs: axis. */
+export class EdgeCurvature extends NativeProcedure {
+    methodId = "augmentation.edge_artifacts.edge_curvature";
+    paramTypes = {
+        curvature_strength: "double",
+        curvature_type: "enum",
+        asymmetry: "double",
+        edge_focus: "double",
+        seed: "int",
+    };
+    constructor(params = {}) {
+        super();
+        this.params = { ...params };
+    }
+    augment(X, axis) {
+        return this.augmentMatrix(X, axis);
+    }
+}
+NativeMethod.register("augmentation.edge_artifacts.edge_curvature", EdgeCurvature);
+/** Native `augmentation.edge_artifacts.stray_light` (augmenter). */
+export class StrayLight extends NativeProcedure {
+    methodId = "augmentation.edge_artifacts.stray_light";
+    paramTypes = {
+        stray_light_fraction: "double",
+        edge_enhancement: "double",
+        edge_width: "double",
+        include_peak_truncation: "bool",
+        seed: "int",
+    };
+    constructor(params = {}) {
+        super();
+        this.params = { ...params };
+    }
+    augment(X, axis) {
+        return this.augmentMatrix(X, axis);
+    }
+}
+NativeMethod.register("augmentation.edge_artifacts.stray_light", StrayLight);
+/** Native `augmentation.edge_artifacts.truncated_peak` (augmenter). Required inputs: axis. */
+export class TruncatedPeak extends NativeProcedure {
+    methodId = "augmentation.edge_artifacts.truncated_peak";
+    paramTypes = {
+        peak_probability: "double",
+        amplitude_min: "double",
+        amplitude_max: "double",
+        width_min: "double",
+        width_max: "double",
+        left_edge: "bool",
+        right_edge: "bool",
+        seed: "int",
+    };
+    constructor(params = {}) {
+        super();
+        this.params = { ...params };
+    }
+    augment(X, axis) {
+        return this.augmentMatrix(X, axis);
+    }
+}
+NativeMethod.register("augmentation.edge_artifacts.truncated_peak", TruncatedPeak);
+/** Native `augmentation.environmental.moisture` (augmenter). Required inputs: axis. */
+export class Moisture extends NativeProcedure {
+    methodId = "augmentation.environmental.moisture";
+    paramTypes = {
+        water_activity_delta: "double",
+        use_aw_range: "bool",
+        aw_low: "double",
+        aw_high: "double",
+        reference_water_activity: "double",
+        free_water_fraction: "double",
+        bound_water_shift: "double",
+        moisture_content: "double",
+        enable_shift: "bool",
+        enable_intensity: "bool",
+        seed: "int",
+    };
+    constructor(params = {}) {
+        super();
+        this.params = { ...params };
+    }
+    augment(X, axis) {
+        return this.augmentMatrix(X, axis);
+    }
+}
+NativeMethod.register("augmentation.environmental.moisture", Moisture);
+/** Native `augmentation.environmental.temperature` (augmenter). Required inputs: axis. */
+export class Temperature extends NativeProcedure {
+    methodId = "augmentation.environmental.temperature";
+    paramTypes = {
+        temperature_delta: "double",
+        use_temp_range: "bool",
+        temp_low: "double",
+        temp_high: "double",
+        enable_shift: "bool",
+        enable_intensity: "bool",
+        enable_broadening: "bool",
+        region_specific: "bool",
+        seed: "int",
+    };
+    constructor(params = {}) {
+        super();
+        this.params = { ...params };
+    }
+    augment(X, axis) {
+        return this.augmentMatrix(X, axis);
+    }
+}
+NativeMethod.register("augmentation.environmental.temperature", Temperature);
+/** Native `augmentation.mixup.local_mixup` (augmenter). Required inputs: y. */
+export class LocalMixup extends NativeProcedure {
+    methodId = "augmentation.mixup.local_mixup";
+    paramTypes = {
+        alpha: "double",
+        k_neighbors: "int",
+        seed: "int",
+    };
+    constructor(params = {}) {
+        super();
+        this.params = { ...params };
+    }
+    augment(X, y, axis) {
+        return this.augmentWithTargets(X, y, axis);
+    }
+}
+NativeMethod.register("augmentation.mixup.local_mixup", LocalMixup);
+/** Native `augmentation.mixup.mixup` (augmenter). Required inputs: y. */
+export class Mixup extends NativeProcedure {
+    methodId = "augmentation.mixup.mixup";
+    paramTypes = {
+        alpha: "double",
+        seed: "int",
+    };
+    constructor(params = {}) {
+        super();
+        this.params = { ...params };
+    }
+    augment(X, y, axis) {
+        return this.augmentWithTargets(X, y, axis);
+    }
+}
+NativeMethod.register("augmentation.mixup.mixup", Mixup);
+/** Native `augmentation.noise.gaussian_noise` (augmenter). */
+export class GaussianNoise extends NativeProcedure {
+    methodId = "augmentation.noise.gaussian_noise";
+    paramTypes = {
+        sigma: "double",
+        seed: "int",
+    };
+    constructor(params = {}) {
+        super();
+        this.params = { ...params };
+    }
+    augment(X, axis) {
+        return this.augmentMatrix(X, axis);
+    }
+}
+NativeMethod.register("augmentation.noise.gaussian_noise", GaussianNoise);
+/** Native `augmentation.noise.hetero_noise` (augmenter). */
+export class HeteroNoise extends NativeProcedure {
+    methodId = "augmentation.noise.hetero_noise";
+    paramTypes = {
+        noise_base: "double",
+        noise_signal_dep: "double",
+        seed: "int",
+    };
+    constructor(params = {}) {
+        super();
+        this.params = { ...params };
+    }
+    augment(X, axis) {
+        return this.augmentMatrix(X, axis);
+    }
+}
+NativeMethod.register("augmentation.noise.hetero_noise", HeteroNoise);
+/** Native `augmentation.noise.multiplicative_noise` (augmenter). */
+export class MultiplicativeNoise extends NativeProcedure {
+    methodId = "augmentation.noise.multiplicative_noise";
+    paramTypes = {
+        sigma_gain: "double",
+        seed: "int",
+    };
+    constructor(params = {}) {
+        super();
+        this.params = { ...params };
+    }
+    augment(X, axis) {
+        return this.augmentMatrix(X, axis);
+    }
+}
+NativeMethod.register("augmentation.noise.multiplicative_noise", MultiplicativeNoise);
+/** Native `augmentation.noise.spike_noise` (augmenter). */
+export class SpikeNoise extends NativeProcedure {
+    methodId = "augmentation.noise.spike_noise";
+    paramTypes = {
+        n_spikes_min: "int",
+        n_spikes_max: "int",
+        amplitude_min: "double",
+        amplitude_max: "double",
+        seed: "int",
+    };
+    constructor(params = {}) {
+        super();
+        this.params = { ...params };
+    }
+    augment(X, axis) {
+        return this.augmentMatrix(X, axis);
+    }
+}
+NativeMethod.register("augmentation.noise.spike_noise", SpikeNoise);
+/** Native `augmentation.random.random_x_op` (augmenter). */
+export class RandomXOp extends NativeProcedure {
+    methodId = "augmentation.random.random_x_op";
+    paramTypes = {
+        op_kind: "enum",
+        operator_range_min: "double",
+        operator_range_max: "double",
+        seed: "int",
+    };
+    constructor(params = {}) {
+        super();
+        this.params = { ...params };
+    }
+    augment(X, axis) {
+        return this.augmentMatrix(X, axis);
+    }
+}
+NativeMethod.register("augmentation.random.random_x_op", RandomXOp);
+/** Native `augmentation.random.rotate_translate` (augmenter). */
+export class RotateTranslate extends NativeProcedure {
+    methodId = "augmentation.random.rotate_translate";
+    paramTypes = {
+        p_range: "double",
+        y_factor: "double",
+        seed: "int",
+    };
+    constructor(params = {}) {
+        super();
+        this.params = { ...params };
+    }
+    augment(X, axis) {
+        return this.augmentMatrix(X, axis);
+    }
+}
+NativeMethod.register("augmentation.random.rotate_translate", RotateTranslate);
+/** Native `augmentation.scattering.batch_effect` (augmenter). */
+export class BatchEffect extends NativeProcedure {
+    methodId = "augmentation.scattering.batch_effect";
+    paramTypes = {
+        offset_std: "double",
+        slope_std: "double",
+        gain_std: "double",
+        variation_scope: "enum",
+        seed: "int",
+    };
+    constructor(params = {}) {
+        super();
+        this.params = { ...params };
+    }
+    augment(X, axis) {
+        return this.augmentMatrix(X, axis);
+    }
+}
+NativeMethod.register("augmentation.scattering.batch_effect", BatchEffect);
+/** Native `augmentation.scattering.dead_band` (augmenter). */
+export class DeadBand extends NativeProcedure {
+    methodId = "augmentation.scattering.dead_band";
+    paramTypes = {
+        n_bands: "int",
+        width_low: "int",
+        width_high: "int",
+        noise_std: "double",
+        probability: "double",
+        variation_scope: "enum",
+        seed: "int",
+    };
+    constructor(params = {}) {
+        super();
+        this.params = { ...params };
+    }
+    augment(X, axis) {
+        return this.augmentMatrix(X, axis);
+    }
+}
+NativeMethod.register("augmentation.scattering.dead_band", DeadBand);
+/** Native `augmentation.scattering.emsc_distort` (augmenter). Required inputs: axis. */
+export class EMSCDistort extends NativeProcedure {
+    methodId = "augmentation.scattering.emsc_distort";
+    paramTypes = {
+        mult_low: "double",
+        mult_high: "double",
+        add_low: "double",
+        add_high: "double",
+        polynomial_order: "int",
+        polynomial_strength: "double",
+        correlation: "double",
+        seed: "int",
+    };
+    constructor(params = {}) {
+        super();
+        this.params = { ...params };
+    }
+    augment(X, axis) {
+        return this.augmentMatrix(X, axis);
+    }
+}
+NativeMethod.register("augmentation.scattering.emsc_distort", EMSCDistort);
+/** Native `augmentation.scattering.instrument_broaden` (augmenter). */
+export class InstrumentBroaden extends NativeProcedure {
+    methodId = "augmentation.scattering.instrument_broaden";
+    paramTypes = {
+        fwhm: "double",
+        use_fwhm_range: "bool",
+        fwhm_low: "double",
+        fwhm_high: "double",
+        variation_scope: "enum",
+        seed: "int",
+    };
+    constructor(params = {}) {
+        super();
+        this.params = { ...params };
+    }
+    augment(X, axis) {
+        return this.augmentMatrix(X, axis);
+    }
+}
+NativeMethod.register("augmentation.scattering.instrument_broaden", InstrumentBroaden);
+/** Native `augmentation.scattering.particle_size` (augmenter). Required inputs: axis. */
+export class ParticleSize extends NativeProcedure {
+    methodId = "augmentation.scattering.particle_size";
+    paramTypes = {
+        mean_size_um: "double",
+        size_variation_um: "double",
+        use_size_range: "bool",
+        size_range_low_um: "double",
+        size_range_high_um: "double",
+        reference_size_um: "double",
+        wavelength_exponent: "double",
+        size_effect_strength: "double",
+        include_path_length: "bool",
+        path_length_sensitivity: "double",
+        seed: "int",
+    };
+    constructor(params = {}) {
+        super();
+        this.params = { ...params };
+    }
+    augment(X, axis) {
+        return this.augmentMatrix(X, axis);
+    }
+}
+NativeMethod.register("augmentation.scattering.particle_size", ParticleSize);
+/** Native `augmentation.scattering.scatter_sim_msc` (augmenter). */
+export class ScatterSimMSC extends NativeProcedure {
+    methodId = "augmentation.scattering.scatter_sim_msc";
+    paramTypes = {
+        a_low: "double",
+        a_high: "double",
+        b_low: "double",
+        b_high: "double",
+        seed: "int",
+    };
+    constructor(params = {}) {
+        super();
+        this.params = { ...params };
+    }
+    augment(X, axis) {
+        return this.augmentMatrix(X, axis);
+    }
+}
+NativeMethod.register("augmentation.scattering.scatter_sim_msc", ScatterSimMSC);
+/** Native `augmentation.spectral.band_mask` (augmenter). */
+export class BandMask extends NativeProcedure {
+    methodId = "augmentation.spectral.band_mask";
+    paramTypes = {
+        n_bands_lo: "int",
+        n_bands_hi: "int",
+        bw_lo: "int",
+        bw_hi: "int",
+        mode: "enum",
+        seed: "int",
+    };
+    constructor(params = {}) {
+        super();
+        this.params = { ...params };
+    }
+    augment(X, axis) {
+        return this.augmentMatrix(X, axis);
+    }
+}
+NativeMethod.register("augmentation.spectral.band_mask", BandMask);
+/** Native `augmentation.spectral.band_perturb` (augmenter). */
+export class BandPerturb extends NativeProcedure {
+    methodId = "augmentation.spectral.band_perturb";
+    paramTypes = {
+        n_bands: "int",
+        bw_lo: "int",
+        bw_hi: "int",
+        gain_lo: "double",
+        gain_hi: "double",
+        offset_lo: "double",
+        offset_hi: "double",
+        seed: "int",
+    };
+    constructor(params = {}) {
+        super();
+        this.params = { ...params };
+    }
+    augment(X, axis) {
+        return this.augmentMatrix(X, axis);
+    }
+}
+NativeMethod.register("augmentation.spectral.band_perturb", BandPerturb);
+/** Native `augmentation.spectral.channel_dropout` (augmenter). */
+export class ChannelDropout extends NativeProcedure {
+    methodId = "augmentation.spectral.channel_dropout";
+    paramTypes = {
+        dropout_prob: "double",
+        mode: "enum",
+        seed: "int",
+    };
+    constructor(params = {}) {
+        super();
+        this.params = { ...params };
+    }
+    augment(X, axis) {
+        return this.augmentMatrix(X, axis);
+    }
+}
+NativeMethod.register("augmentation.spectral.channel_dropout", ChannelDropout);
+/** Native `augmentation.spectral.gauss_jitter` (augmenter). */
+export class GaussJitter extends NativeProcedure {
+    methodId = "augmentation.spectral.gauss_jitter";
+    paramTypes = {
+        sigma_lo: "double",
+        sigma_hi: "double",
+        kernel_width: "int",
+        seed: "int",
+    };
+    constructor(params = {}) {
+        super();
+        this.params = { ...params };
+    }
+    augment(X, axis) {
+        return this.augmentMatrix(X, axis);
+    }
+}
+NativeMethod.register("augmentation.spectral.gauss_jitter", GaussJitter);
+/** Native `augmentation.spectral.local_clip` (augmenter). */
+export class LocalClip extends NativeProcedure {
+    methodId = "augmentation.spectral.local_clip";
+    paramTypes = {
+        n_regions: "int",
+        width_lo: "int",
+        width_hi: "int",
+        seed: "int",
+    };
+    constructor(params = {}) {
+        super();
+        this.params = { ...params };
+    }
+    augment(X, axis) {
+        return this.augmentMatrix(X, axis);
+    }
+}
+NativeMethod.register("augmentation.spectral.local_clip", LocalClip);
+/** Native `augmentation.spectral.magnitude_warp` (augmenter). */
+export class MagnitudeWarp extends NativeProcedure {
+    methodId = "augmentation.spectral.magnitude_warp";
+    paramTypes = {
+        n_control_points: "int",
+        gain_lo: "double",
+        gain_hi: "double",
+        seed: "int",
+    };
+    constructor(params = {}) {
+        super();
+        this.params = { ...params };
+    }
+    augment(X, axis) {
+        return this.augmentMatrix(X, axis);
+    }
+}
+NativeMethod.register("augmentation.spectral.magnitude_warp", MagnitudeWarp);
+/** Native `augmentation.spectral.unsharp_mask` (augmenter). */
+export class UnsharpMask extends NativeProcedure {
+    methodId = "augmentation.spectral.unsharp_mask";
+    paramTypes = {
+        amount_lo: "double",
+        amount_hi: "double",
+        sigma: "double",
+        kernel_width: "int",
+        seed: "int",
+    };
+    constructor(params = {}) {
+        super();
+        this.params = { ...params };
+    }
+    augment(X, axis) {
+        return this.augmentMatrix(X, axis);
+    }
+}
+NativeMethod.register("augmentation.spectral.unsharp_mask", UnsharpMask);
+/** Native `augmentation.splines.spline_curve_simplification` (augmenter). */
+export class SplineCurveSimplification extends NativeProcedure {
+    methodId = "augmentation.splines.spline_curve_simplification";
+    paramTypes = {
+        spline_points: "int",
+        uniform: "bool",
+        seed: "int",
+    };
+    constructor(params = {}) {
+        super();
+        this.params = { ...params };
+    }
+    augment(X, axis) {
+        return this.augmentMatrix(X, axis);
+    }
+}
+NativeMethod.register("augmentation.splines.spline_curve_simplification", SplineCurveSimplification);
+/** Native `augmentation.splines.spline_smoothing` (augmenter). */
+export class SplineSmoothing extends NativeProcedure {
+    methodId = "augmentation.splines.spline_smoothing";
+    paramTypes = {
+        seed: "int",
+    };
+    constructor(params = {}) {
+        super();
+        this.params = { ...params };
+    }
+    augment(X, axis) {
+        return this.augmentMatrix(X, axis);
+    }
+}
+NativeMethod.register("augmentation.splines.spline_smoothing", SplineSmoothing);
+/** Native `augmentation.splines.spline_x_perturbations` (augmenter). */
+export class SplineXPerturbations extends NativeProcedure {
+    methodId = "augmentation.splines.spline_x_perturbations";
+    paramTypes = {
+        spline_degree: "int",
+        perturbation_density: "double",
+        perturbation_range_min: "double",
+        perturbation_range_max: "double",
+        seed: "int",
+    };
+    constructor(params = {}) {
+        super();
+        this.params = { ...params };
+    }
+    augment(X, axis) {
+        return this.augmentMatrix(X, axis);
+    }
+}
+NativeMethod.register("augmentation.splines.spline_x_perturbations", SplineXPerturbations);
+/** Native `augmentation.splines.spline_x_simplification` (augmenter). */
+export class SplineXSimplification extends NativeProcedure {
+    methodId = "augmentation.splines.spline_x_simplification";
+    paramTypes = {
+        spline_points: "int",
+        uniform: "bool",
+        seed: "int",
+    };
+    constructor(params = {}) {
+        super();
+        this.params = { ...params };
+    }
+    augment(X, axis) {
+        return this.augmentMatrix(X, axis);
+    }
+}
+NativeMethod.register("augmentation.splines.spline_x_simplification", SplineXSimplification);
+/** Native `augmentation.splines.spline_y_perturbations` (augmenter). */
+export class SplineYPerturbations extends NativeProcedure {
+    methodId = "augmentation.splines.spline_y_perturbations";
+    paramTypes = {
+        spline_points: "int",
+        perturbation_intensity: "double",
+        seed: "int",
+    };
+    constructor(params = {}) {
+        super();
+        this.params = { ...params };
+    }
+    augment(X, axis) {
+        return this.augmentMatrix(X, axis);
+    }
+}
+NativeMethod.register("augmentation.splines.spline_y_perturbations", SplineYPerturbations);
+/** Native `augmentation.wavelength.local_warp` (augmenter). */
+export class LocalWarp extends NativeProcedure {
+    methodId = "augmentation.wavelength.local_warp";
+    paramTypes = {
+        n_control_points: "int",
+        max_shift: "double",
+        seed: "int",
+    };
+    constructor(params = {}) {
+        super();
+        this.params = { ...params };
+    }
+    augment(X, axis) {
+        return this.augmentMatrix(X, axis);
+    }
+}
+NativeMethod.register("augmentation.wavelength.local_warp", LocalWarp);
+/** Native `augmentation.wavelength.wavelength_shift` (augmenter). */
+export class WavelengthShift extends NativeProcedure {
+    methodId = "augmentation.wavelength.wavelength_shift";
+    paramTypes = {
+        shift_lo: "double",
+        shift_hi: "double",
+        seed: "int",
+    };
+    constructor(params = {}) {
+        super();
+        this.params = { ...params };
+    }
+    augment(X, axis) {
+        return this.augmentMatrix(X, axis);
+    }
+}
+NativeMethod.register("augmentation.wavelength.wavelength_shift", WavelengthShift);
+/** Native `augmentation.wavelength.wavelength_stretch` (augmenter). */
+export class WavelengthStretch extends NativeProcedure {
+    methodId = "augmentation.wavelength.wavelength_stretch";
+    paramTypes = {
+        stretch_lo: "double",
+        stretch_hi: "double",
+        seed: "int",
+    };
+    constructor(params = {}) {
+        super();
+        this.params = { ...params };
+    }
+    augment(X, axis) {
+        return this.augmentMatrix(X, axis);
+    }
+}
+NativeMethod.register("augmentation.wavelength.wavelength_stretch", WavelengthStretch);
+/** Native `diagnostics.approximate_press` (generic). Required inputs: y. */
+export class ApproximatePress extends NativeProcedure {
+    methodId = "diagnostics.approximate_press";
+    paramTypes = {
+        max_components: "int",
+    };
+    constructor(params = {}) {
+        super();
+        this.params = { ...params };
+    }
+    run(X, y, inputs = {}) {
+        return this.runOutputs(X, y, inputs);
+    }
+}
+NativeMethod.register("diagnostics.approximate_press", ApproximatePress);
+/** Native `diagnostics.model_selection` (generic). */
+export class ModelSelection extends NativeProcedure {
+    methodId = "diagnostics.model_selection";
+    paramTypes = {};
+    constructor(params = {}) {
+        super();
+        this.params = { ...params };
+    }
+    run(X, y, inputs = {}) {
+        return this.runOutputs(X, y, inputs);
+    }
+}
+NativeMethod.register("diagnostics.model_selection", ModelSelection);
+/** Native `diagnostics.pls_diagnostics` (generic). Required inputs: y. */
+export class PLSDiagnostics extends NativeProcedure {
+    methodId = "diagnostics.pls_diagnostics";
+    paramTypes = {
+        n_components: "int",
+        center_x: "bool",
+        scale_x: "bool",
+        center_y: "bool",
+        scale_y: "bool",
+    };
+    constructor(params = {}) {
+        super();
+        this.params = { ...params };
+    }
+    run(X, y, inputs = {}) {
+        return this.runOutputs(X, y, inputs);
+    }
+}
+NativeMethod.register("diagnostics.pls_diagnostics", PLSDiagnostics);
+/** Native `diagnostics.pls_monitoring` (generic). Required inputs: y, target_domain. */
+export class PLSMonitoring extends NativeProcedure {
+    methodId = "diagnostics.pls_monitoring";
+    paramTypes = {
+        n_components: "int",
+        center_x: "bool",
+        scale_x: "bool",
+        center_y: "bool",
+        scale_y: "bool",
+        alpha: "double",
+    };
+    constructor(params = {}) {
+        super();
+        this.params = { ...params };
+    }
+    run(X, y, inputs = {}) {
+        return this.runOutputs(X, y, inputs);
+    }
+}
+NativeMethod.register("diagnostics.pls_monitoring", PLSMonitoring);
+/** Native `diagnostics.regression_metrics` (generic). Required inputs: y. */
+export class RegressionMetrics extends NativeProcedure {
+    methodId = "diagnostics.regression_metrics";
+    paramTypes = {};
+    constructor(params = {}) {
+        super();
+        this.params = { ...params };
+    }
+    run(X, y, inputs = {}) {
+        return this.runOutputs(X, y, inputs);
+    }
+}
+NativeMethod.register("diagnostics.regression_metrics", RegressionMetrics);
+/** Native `filters.correlation` (selector). */
+export class CorrelationFilter extends NativeEstimator {
+    methodId = "filters.correlation";
+    paramTypes = {
+        threshold: "double",
+        top_k: "int",
+    };
+    constructor(params = {}) {
+        super();
+        this.params = { ...params };
+    }
+    transform(X) {
+        return this.transformMatrix(X);
+    }
+    selectedIndices() {
+        return this.selectedIndexArray();
+    }
+}
+NativeMethod.register("filters.correlation", CorrelationFilter);
+/** Native `filters.high_leverage` (sample_filter). */
+export class HighLeverageFilter extends NativeEstimator {
+    methodId = "filters.high_leverage";
+    paramTypes = {
+        method: "enum",
+        threshold_multiplier: "double",
+        absolute_threshold: "double",
+        n_components: "int",
+        center: "bool",
+    };
+    constructor(params = {}) {
+        super();
+        this.params = { ...params };
+    }
+    getMask(X, y) {
+        return this.maskArray(X, y);
+    }
+}
+NativeMethod.register("filters.high_leverage", HighLeverageFilter);
+/** Native `filters.spectral_quality` (sample_filter). */
+export class SpectralQualityFilter extends NativeEstimator {
+    methodId = "filters.spectral_quality";
+    paramTypes = {
+        max_nan_ratio: "double",
+        max_zero_ratio: "double",
+        min_variance: "double",
+        max_value: "double",
+        min_value: "double",
+        check_inf: "bool",
+    };
+    constructor(params = {}) {
+        super();
+        this.params = { ...params };
+    }
+    getMask(X, y) {
+        return this.maskArray(X, y);
+    }
+}
+NativeMethod.register("filters.spectral_quality", SpectralQualityFilter);
+/** Native `filters.variance` (selector). */
+export class VarianceFilter extends NativeEstimator {
+    methodId = "filters.variance";
+    paramTypes = {
+        threshold: "double",
+        top_k: "int",
+    };
+    constructor(params = {}) {
+        super();
+        this.params = { ...params };
+    }
+    transform(X) {
+        return this.transformMatrix(X);
+    }
+    selectedIndices() {
+        return this.selectedIndexArray();
+    }
+}
+NativeMethod.register("filters.variance", VarianceFilter);
+/** Native `filters.x_outlier` (sample_filter). */
+export class XOutlierFilter extends NativeEstimator {
+    methodId = "filters.x_outlier";
+    paramTypes = {
+        method: "enum",
+        threshold: "double",
+        n_components: "int",
+        contamination: "double",
+        seed: "int",
+        n_estimators: "int",
+        max_samples: "int",
+    };
+    constructor(params = {}) {
+        super();
+        this.params = { ...params };
+    }
+    getMask(X, y) {
+        return this.maskArray(X, y);
+    }
+}
+NativeMethod.register("filters.x_outlier", XOutlierFilter);
+/** Native `filters.y_outlier` (sample_filter). */
+export class YOutlierFilter extends NativeEstimator {
+    methodId = "filters.y_outlier";
+    paramTypes = {
+        method: "enum",
+        threshold: "double",
+        lower_percentile: "double",
+        upper_percentile: "double",
+    };
+    constructor(params = {}) {
+        super();
+        this.params = { ...params };
+    }
+    getMask(X, y) {
+        return this.maskArray(X, y);
+    }
+}
+NativeMethod.register("filters.y_outlier", YOutlierFilter);
+/** Native `models.classification.pls_lda` (classifier). Required fit inputs: labels. */
+export class PLSLDA extends NativeEstimator {
+    methodId = "models.classification.pls_lda";
+    paramTypes = {
+        n_components: "int",
+    };
+    labelTarget = true;
+    constructor(params = {}) {
+        super();
+        this.params = { ...params };
+    }
+    decisionFunction(X) {
+        return this.decisionMatrix(X);
+    }
+    predictLabels(X) {
+        return this.labelArray(X);
+    }
+    classes() {
+        return this.classArray();
+    }
+}
+NativeMethod.register("models.classification.pls_lda", PLSLDA);
+/** Native `models.classification.pls_logistic` (classifier). Required fit inputs: labels. */
+export class PLSLogistic extends NativeEstimator {
+    methodId = "models.classification.pls_logistic";
+    paramTypes = {
+        n_components: "int",
+        max_iter: "int",
+    };
+    labelTarget = true;
+    constructor(params = {}) {
+        super();
+        this.params = { ...params };
+    }
+    decisionFunction(X) {
+        return this.decisionMatrix(X);
+    }
+    predictLabels(X) {
+        return this.labelArray(X);
+    }
+    classes() {
+        return this.classArray();
+    }
+    predictProba(X) {
+        return this.probaMatrix(X);
+    }
+}
+NativeMethod.register("models.classification.pls_logistic", PLSLogistic);
+/** Native `models.classification.pls_qda` (classifier). Required fit inputs: labels. */
+export class PLSQDA extends NativeEstimator {
+    methodId = "models.classification.pls_qda";
+    paramTypes = {
+        n_components: "int",
+    };
+    labelTarget = true;
+    constructor(params = {}) {
+        super();
+        this.params = { ...params };
+    }
+    decisionFunction(X) {
+        return this.decisionMatrix(X);
+    }
+    predictLabels(X) {
+        return this.labelArray(X);
+    }
+    classes() {
+        return this.classArray();
+    }
+    predictProba(X) {
+        return this.probaMatrix(X);
+    }
+}
+NativeMethod.register("models.classification.pls_qda", PLSQDA);
+/** Native `models.ensembles.bagging_pls` (regressor). */
+export class BaggingPLS extends NativeEstimator {
+    methodId = "models.ensembles.bagging_pls";
+    paramTypes = {
+        n_components: "int",
+        n_estimators: "int",
+        seed: "int",
+    };
+    constructor(params = {}) {
+        super();
+        this.params = { ...params };
+    }
+    predict(X) {
+        return this.predictMatrix(X);
+    }
+}
+NativeMethod.register("models.ensembles.bagging_pls", BaggingPLS);
+/** Native `models.ensembles.boosting_pls` (regressor). */
+export class BoostingPLS extends NativeEstimator {
+    methodId = "models.ensembles.boosting_pls";
+    paramTypes = {
+        n_components: "int",
+        n_estimators: "int",
+        learning_rate: "double",
+    };
+    constructor(params = {}) {
+        super();
+        this.params = { ...params };
+    }
+    predict(X) {
+        return this.predictMatrix(X);
+    }
+}
+NativeMethod.register("models.ensembles.boosting_pls", BoostingPLS);
+/** Native `models.ensembles.random_subspace_pls` (regressor). */
+export class RandomSubspacePLS extends NativeEstimator {
+    methodId = "models.ensembles.random_subspace_pls";
+    paramTypes = {
+        n_components: "int",
+        n_estimators: "int",
+        features_per_subspace: "int",
+        seed: "int",
+    };
+    constructor(params = {}) {
+        super();
+        this.params = { ...params };
+    }
+    predict(X) {
+        return this.predictMatrix(X);
+    }
+}
+NativeMethod.register("models.ensembles.random_subspace_pls", RandomSubspacePLS);
+/** Native `models.heads.pls_cox` (regressor). */
+export class PLSCox extends NativeEstimator {
+    methodId = "models.heads.pls_cox";
+    paramTypes = {
+        n_components: "int",
+        max_iter: "int",
+        tol: "double",
+    };
+    constructor(params = {}) {
+        super();
+        this.params = { ...params };
+    }
+    predict(X) {
+        return this.predictMatrix(X);
+    }
+}
+NativeMethod.register("models.heads.pls_cox", PLSCox);
+/** Native `models.heads.pls_glm` (regressor). */
+export class PLSGLM extends NativeEstimator {
+    methodId = "models.heads.pls_glm";
+    paramTypes = {
+        n_components: "int",
+        family: "enum",
+        max_iter: "int",
+        tol: "double",
+    };
+    constructor(params = {}) {
+        super();
+        this.params = { ...params };
+    }
+    predict(X) {
+        return this.predictMatrix(X);
+    }
+}
+NativeMethod.register("models.heads.pls_glm", PLSGLM);
+/** Native `models.local.lw_pls` (regressor). */
+export class LWPLS extends NativeEstimator {
+    methodId = "models.local.lw_pls";
+    paramTypes = {
+        n_components: "int",
+        n_neighbors: "int",
+        mode: "enum",
+    };
+    constructor(params = {}) {
+        super();
+        this.params = { ...params };
+    }
+    predict(X) {
+        return this.predictMatrix(X);
+    }
+}
+NativeMethod.register("models.local.lw_pls", LWPLS);
+/** Native `models.multiblock.mb_pls` (regressor). Required fit inputs: blocks. */
+export class MBPLS extends NativeEstimator {
+    methodId = "models.multiblock.mb_pls";
+    paramTypes = {
+        n_components: "int",
+    };
+    constructor(params = {}) {
+        super();
+        this.params = { ...params };
+    }
+    predict(X) {
+        return this.predictMatrix(X);
+    }
+}
+NativeMethod.register("models.multiblock.mb_pls", MBPLS);
+/** Native `models.multiblock.mir_pls` (regressor). */
+export class MIRPLS extends NativeEstimator {
+    methodId = "models.multiblock.mir_pls";
+    paramTypes = {
+        n_components: "int",
+    };
+    constructor(params = {}) {
+        super();
+        this.params = { ...params };
+    }
+    predict(X) {
+        return this.predictMatrix(X);
+    }
+}
+NativeMethod.register("models.multiblock.mir_pls", MIRPLS);
+/** Native `models.multiblock.o2pls` (regressor). */
+export class O2PLS extends NativeEstimator {
+    methodId = "models.multiblock.o2pls";
+    paramTypes = {
+        n_predictive: "int",
+        n_x_orthogonal: "int",
+        n_y_orthogonal: "int",
+    };
+    constructor(params = {}) {
+        super();
+        this.params = { ...params };
+    }
+    predict(X) {
+        return this.predictMatrix(X);
+    }
+}
+NativeMethod.register("models.multiblock.o2pls", O2PLS);
+/** Native `models.multiblock.on_pls` (transformer). Required fit inputs: blocks. */
+export class OnPLS extends NativeEstimator {
+    methodId = "models.multiblock.on_pls";
+    paramTypes = {
+        n_joint: "int",
+        n_unique_per_block: "int_array",
+    };
+    constructor(params = {}) {
+        super();
+        this.params = { ...params };
+    }
+    transform(X) {
+        return this.transformMatrix(X);
+    }
+}
+NativeMethod.register("models.multiblock.on_pls", OnPLS);
+/** Native `models.multiblock.rosa` (regressor). Required fit inputs: blocks. */
+export class ROSA extends NativeEstimator {
+    methodId = "models.multiblock.rosa";
+    paramTypes = {
+        n_components: "int",
+    };
+    constructor(params = {}) {
+        super();
+        this.params = { ...params };
+    }
+    predict(X) {
+        return this.predictMatrix(X);
+    }
+}
+NativeMethod.register("models.multiblock.rosa", ROSA);
+/** Native `models.multiblock.so_pls` (regressor). Required fit inputs: blocks. */
+export class SOPLS extends NativeEstimator {
+    methodId = "models.multiblock.so_pls";
+    paramTypes = {
+        n_components_per_block: "int_array",
+    };
+    constructor(params = {}) {
+        super();
+        this.params = { ...params };
+    }
+    predict(X) {
+        return this.predictMatrix(X);
+    }
+}
+NativeMethod.register("models.multiblock.so_pls", SOPLS);
+/** Native `models.pls.cppls` (regressor). */
+export class CPPLS extends NativeEstimator {
+    methodId = "models.pls.cppls";
+    paramTypes = {
+        n_components: "int",
+        gamma: "double",
+    };
+    constructor(params = {}) {
+        super();
+        this.params = { ...params };
+    }
+    predict(X) {
+        return this.predictMatrix(X);
+    }
+}
+NativeMethod.register("models.pls.cppls", CPPLS);
+/** Native `models.pls.kernel` (regressor). */
+export class KernelPLS extends NativeEstimator {
+    methodId = "models.pls.kernel";
+    paramTypes = {
+        n_components: "int",
+        kernel: "enum",
+        gamma: "double",
+        coef0: "double",
+        degree: "int",
+    };
+    constructor(params = {}) {
+        super();
+        this.params = { ...params };
+    }
+    predict(X) {
+        return this.predictMatrix(X);
+    }
+}
+NativeMethod.register("models.pls.kernel", KernelPLS);
+/** Native `models.pls.pcr` (transformer, regressor). */
+export class PCR extends NativeEstimator {
+    methodId = "models.pls.pcr";
+    paramTypes = {
+        n_components: "int",
+        center_x: "bool",
+        scale_x: "bool",
+        center_y: "bool",
+        scale_y: "bool",
+    };
+    constructor(params = {}) {
+        super();
+        this.params = { ...params };
+    }
+    predict(X) {
+        return this.predictMatrix(X);
+    }
+    transform(X) {
+        return this.transformMatrix(X);
+    }
+}
+NativeMethod.register("models.pls.pcr", PCR);
+/** Native `models.pls.pls_fit_simple` (transformer, regressor). */
+export class SimplePLS extends NativeEstimator {
+    methodId = "models.pls.pls_fit_simple";
+    paramTypes = {
+        n_components: "int",
+    };
+    constructor(params = {}) {
+        super();
+        this.params = { ...params };
+    }
+    predict(X) {
+        return this.predictMatrix(X);
+    }
+    transform(X) {
+        return this.transformMatrix(X);
+    }
+}
+NativeMethod.register("models.pls.pls_fit_simple", SimplePLS);
+/** Native `models.pls.pls_regression` (transformer, regressor). */
+export class PLSRegression extends NativeEstimator {
+    methodId = "models.pls.pls_regression";
+    paramTypes = {
+        n_components: "int",
+        solver: "enum",
+        center_x: "bool",
+        scale_x: "bool",
+        center_y: "bool",
+        scale_y: "bool",
+    };
+    constructor(params = {}) {
+        super();
+        this.params = { ...params };
+    }
+    predict(X) {
+        return this.predictMatrix(X);
+    }
+    transform(X) {
+        return this.transformMatrix(X);
+    }
+}
+NativeMethod.register("models.pls.pls_regression", PLSRegression);
+/** Native `models.regularized.continuum_regression` (regressor). */
+export class ContinuumRegression extends NativeEstimator {
+    methodId = "models.regularized.continuum_regression";
+    paramTypes = {
+        n_components: "int",
+        tau: "double",
+    };
+    constructor(params = {}) {
+        super();
+        this.params = { ...params };
+    }
+    predict(X) {
+        return this.predictMatrix(X);
+    }
+}
+NativeMethod.register("models.regularized.continuum_regression", ContinuumRegression);
+/** Native `models.regularized.ridge` (regressor). */
+export class Ridge extends NativeEstimator {
+    methodId = "models.regularized.ridge";
+    paramTypes = {
+        alpha: "double",
+        center_x: "bool",
+        scale_x: "bool",
+        center_y: "bool",
+    };
+    constructor(params = {}) {
+        super();
+        this.params = { ...params };
+    }
+    predict(X) {
+        return this.predictMatrix(X);
+    }
+}
+NativeMethod.register("models.regularized.ridge", Ridge);
+/** Native `models.regularized.ridge_pls` (regressor). */
+export class RidgePLS extends NativeEstimator {
+    methodId = "models.regularized.ridge_pls";
+    paramTypes = {
+        n_components: "int",
+        ridge_lambda: "double",
+        center_x: "bool",
+        scale_x: "bool",
+        center_y: "bool",
+        scale_y: "bool",
+    };
+    constructor(params = {}) {
+        super();
+        this.params = { ...params };
+    }
+    predict(X) {
+        return this.predictMatrix(X);
+    }
+}
+NativeMethod.register("models.regularized.ridge_pls", RidgePLS);
+/** Native `models.regularized.robust_pls` (regressor). */
+export class RobustPLS extends NativeEstimator {
+    methodId = "models.regularized.robust_pls";
+    paramTypes = {
+        n_components: "int",
+        huber_k: "double",
+        max_irls_iter: "int",
+        center_x: "bool",
+        scale_x: "bool",
+        center_y: "bool",
+        scale_y: "bool",
+    };
+    constructor(params = {}) {
+        super();
+        this.params = { ...params };
+    }
+    predict(X) {
+        return this.predictMatrix(X);
+    }
+}
+NativeMethod.register("models.regularized.robust_pls", RobustPLS);
+/** Native `models.regularized.weighted_pls` (regressor). */
+export class WeightedPLS extends NativeEstimator {
+    methodId = "models.regularized.weighted_pls";
+    paramTypes = {
+        n_components: "int",
+        center_x: "bool",
+        scale_x: "bool",
+        center_y: "bool",
+        scale_y: "bool",
+    };
+    constructor(params = {}) {
+        super();
+        this.params = { ...params };
+    }
+    predict(X) {
+        return this.predictMatrix(X);
+    }
+}
+NativeMethod.register("models.regularized.weighted_pls", WeightedPLS);
+/** Native `models.sparse.fused_sparse_pls` (regressor). */
+export class FusedSparsePLS extends NativeEstimator {
+    methodId = "models.sparse.fused_sparse_pls";
+    paramTypes = {
+        n_components: "int",
+        l1_lambda: "double",
+        fusion_lambda: "double",
+    };
+    constructor(params = {}) {
+        super();
+        this.params = { ...params };
+    }
+    predict(X) {
+        return this.predictMatrix(X);
+    }
+}
+NativeMethod.register("models.sparse.fused_sparse_pls", FusedSparsePLS);
+/** Native `models.sparse.group_sparse_pls` (regressor). Required fit inputs: feature_groups. */
+export class GroupSparsePLS extends NativeEstimator {
+    methodId = "models.sparse.group_sparse_pls";
+    paramTypes = {
+        n_components: "int",
+        group_lambda: "double",
+    };
+    constructor(params = {}) {
+        super();
+        this.params = { ...params };
+    }
+    predict(X) {
+        return this.predictMatrix(X);
+    }
+}
+NativeMethod.register("models.sparse.group_sparse_pls", GroupSparsePLS);
+/** Native `models.sparse.sparse_pls_da` (classifier). Required fit inputs: labels. */
+export class SparsePLSDA extends NativeEstimator {
+    methodId = "models.sparse.sparse_pls_da";
+    paramTypes = {
+        n_components: "int",
+        sparsity_lambda: "double",
+    };
+    labelTarget = true;
+    constructor(params = {}) {
+        super();
+        this.params = { ...params };
+    }
+    decisionFunction(X) {
+        return this.decisionMatrix(X);
+    }
+    predictLabels(X) {
+        return this.labelArray(X);
+    }
+    classes() {
+        return this.classArray();
+    }
+}
+NativeMethod.register("models.sparse.sparse_pls_da", SparsePLSDA);
+/** Native `models.sparse.sparse_simpls` (regressor). */
+export class SparseSIMPLS extends NativeEstimator {
+    methodId = "models.sparse.sparse_simpls";
+    paramTypes = {
+        n_components: "int",
+        sparsity_lambda: "double",
+    };
+    constructor(params = {}) {
+        super();
+        this.params = { ...params };
+    }
+    predict(X) {
+        return this.predictMatrix(X);
+    }
+}
+NativeMethod.register("models.sparse.sparse_simpls", SparseSIMPLS);
+/** Native `models.specialized.ecr` (regressor). */
+export class ECR extends NativeEstimator {
+    methodId = "models.specialized.ecr";
+    paramTypes = {
+        n_components: "int",
+        alpha: "double",
+    };
+    constructor(params = {}) {
+        super();
+        this.params = { ...params };
+    }
+    predict(X) {
+        return this.predictMatrix(X);
+    }
+}
+NativeMethod.register("models.specialized.ecr", ECR);
+/** Native `models.specialized.gpr_pls` (regressor). */
+export class GPRPLS extends NativeEstimator {
+    methodId = "models.specialized.gpr_pls";
+    paramTypes = {
+        n_components: "int",
+        length_scale: "double",
+        noise_level: "double",
+    };
+    constructor(params = {}) {
+        super();
+        this.params = { ...params };
+    }
+    predict(X) {
+        return this.predictMatrix(X);
+    }
+}
+NativeMethod.register("models.specialized.gpr_pls", GPRPLS);
+/** Native `models.specialized.missing_aware_nipals` (regressor). */
+export class MissingAwareNIPALS extends NativeEstimator {
+    methodId = "models.specialized.missing_aware_nipals";
+    paramTypes = {
+        n_components: "int",
+    };
+    constructor(params = {}) {
+        super();
+        this.params = { ...params };
+    }
+    predict(X) {
+        return this.predictMatrix(X);
+    }
+}
+NativeMethod.register("models.specialized.missing_aware_nipals", MissingAwareNIPALS);
+/** Native `models.specialized.recursive` (transformer, regressor). */
+export class RecursivePLS extends NativeEstimator {
+    methodId = "models.specialized.recursive";
+    paramTypes = {
+        n_components: "int",
+        window_size: "int",
+    };
+    constructor(params = {}) {
+        super();
+        this.params = { ...params };
+    }
+    predict(X) {
+        return this.predictMatrix(X);
+    }
+    transform(X) {
+        return this.transformMatrix(X);
+    }
+}
+NativeMethod.register("models.specialized.recursive", RecursivePLS);
+/** Native `models.specialized.tensor_pls` (regressor). */
+export class NPLS extends NativeEstimator {
+    methodId = "models.specialized.tensor_pls";
+    paramTypes = {
+        n_components: "int",
+        mode_j: "int",
+        mode_k: "int",
+    };
+    constructor(params = {}) {
+        super();
+        this.params = { ...params };
+    }
+    predict(X) {
+        return this.predictMatrix(X);
+    }
+}
+NativeMethod.register("models.specialized.tensor_pls", NPLS);
+/** Native `models.transfer.di_pls` (regressor). Required fit inputs: target_domain. */
+export class DIPLS extends NativeEstimator {
+    methodId = "models.transfer.di_pls";
+    paramTypes = {
+        n_components: "int",
+        di_lambda: "double",
+    };
+    constructor(params = {}) {
+        super();
+        this.params = { ...params };
+    }
+    predict(X) {
+        return this.predictMatrix(X);
+    }
+}
+NativeMethod.register("models.transfer.di_pls", DIPLS);
+/** Native `models.transfer.ds` (transformer). Required fit inputs: target_domain. */
+export class DS extends NativeEstimator {
+    methodId = "models.transfer.ds";
+    paramTypes = {};
+    constructor(params = {}) {
+        super();
+        this.params = { ...params };
+    }
+    transform(X) {
+        return this.transformMatrix(X);
+    }
+}
+NativeMethod.register("models.transfer.ds", DS);
+/** Native `models.transfer.pds` (transformer). Required fit inputs: target_domain. */
+export class PDS extends NativeEstimator {
+    methodId = "models.transfer.pds";
+    paramTypes = {
+        window_half_width: "int",
+    };
+    constructor(params = {}) {
+        super();
+        this.params = { ...params };
+    }
+    transform(X) {
+        return this.transformMatrix(X);
+    }
+}
+NativeMethod.register("models.transfer.pds", PDS);
+/** Native `preprocessing.alignment.cow_align` (transformer). */
+export class CorrelationOptimizedWarping extends NativeEstimator {
+    methodId = "preprocessing.alignment.cow_align";
+    paramTypes = {
+        reference: "double_array",
+        interval_size: "int",
+        max_shift: "int",
+    };
+    constructor(params = {}) {
+        super();
+        this.params = { ...params };
+    }
+    transform(X) {
+        return this.transformMatrix(X);
+    }
+}
+NativeMethod.register("preprocessing.alignment.cow_align", CorrelationOptimizedWarping);
+/** Native `preprocessing.alignment.dtw_align` (transformer). */
+export class DynamicTimeWarpingAlignment extends NativeEstimator {
+    methodId = "preprocessing.alignment.dtw_align";
+    paramTypes = {
+        reference: "double_array",
+    };
+    constructor(params = {}) {
+        super();
+        this.params = { ...params };
+    }
+    transform(X) {
+        return this.transformMatrix(X);
+    }
+}
+NativeMethod.register("preprocessing.alignment.dtw_align", DynamicTimeWarpingAlignment);
+/** Native `preprocessing.alignment.icoshift_align` (transformer). */
+export class IcoshiftAlignment extends NativeEstimator {
+    methodId = "preprocessing.alignment.icoshift_align";
+    paramTypes = {
+        reference: "double_array",
+        interval_size: "int",
+        max_shift: "int",
+    };
+    constructor(params = {}) {
+        super();
+        this.params = { ...params };
+    }
+    transform(X) {
+        return this.transformMatrix(X);
+    }
+}
+NativeMethod.register("preprocessing.alignment.icoshift_align", IcoshiftAlignment);
+/** Native `preprocessing.alignment.xcorr_align` (transformer). */
+export class CrossCorrelationAlignment extends NativeEstimator {
+    methodId = "preprocessing.alignment.xcorr_align";
+    paramTypes = {
+        reference: "double_array",
+        max_shift: "int",
+    };
+    constructor(params = {}) {
+        super();
+        this.params = { ...params };
+    }
+    transform(X) {
+        return this.transformMatrix(X);
+    }
+}
+NativeMethod.register("preprocessing.alignment.xcorr_align", CrossCorrelationAlignment);
+/** Native `preprocessing.baselines.airpls` (transformer). */
+export class AirPLS extends NativeEstimator {
+    methodId = "preprocessing.baselines.airpls";
+    paramTypes = {
+        lam: "double",
+        max_iter: "int",
+        tol: "double",
+    };
+    constructor(params = {}) {
+        super();
+        this.params = { ...params };
+    }
+    transform(X) {
+        return this.transformMatrix(X);
+    }
+}
+NativeMethod.register("preprocessing.baselines.airpls", AirPLS);
+/** Native `preprocessing.baselines.arpls` (transformer). */
+export class ArPLS extends NativeEstimator {
+    methodId = "preprocessing.baselines.arpls";
+    paramTypes = {
+        lam: "double",
+        max_iter: "int",
+        tol: "double",
+    };
+    constructor(params = {}) {
+        super();
+        this.params = { ...params };
+    }
+    transform(X) {
+        return this.transformMatrix(X);
+    }
+}
+NativeMethod.register("preprocessing.baselines.arpls", ArPLS);
+/** Native `preprocessing.baselines.asls` (transformer). */
+export class AsLS extends NativeEstimator {
+    methodId = "preprocessing.baselines.asls";
+    paramTypes = {
+        lam: "double",
+        p: "double",
+        max_iter: "int",
+        tol: "double",
+    };
+    constructor(params = {}) {
+        super();
+        this.params = { ...params };
+    }
+    transform(X) {
+        return this.transformMatrix(X);
+    }
+}
+NativeMethod.register("preprocessing.baselines.asls", AsLS);
+/** Native `preprocessing.baselines.beads` (transformer). */
+export class BEADS extends NativeEstimator {
+    methodId = "preprocessing.baselines.beads";
+    paramTypes = {
+        lam_0: "double",
+        lam_1: "double",
+        lam_2: "double",
+        max_iter: "int",
+        tol: "double",
+    };
+    constructor(params = {}) {
+        super();
+        this.params = { ...params };
+    }
+    transform(X) {
+        return this.transformMatrix(X);
+    }
+}
+NativeMethod.register("preprocessing.baselines.beads", BEADS);
+/** Native `preprocessing.baselines.detrend` (transformer). */
+export class Detrend extends NativeEstimator {
+    methodId = "preprocessing.baselines.detrend";
+    paramTypes = {
+        polyorder: "int",
+    };
+    constructor(params = {}) {
+        super();
+        this.params = { ...params };
+    }
+    transform(X) {
+        return this.transformMatrix(X);
+    }
+}
+NativeMethod.register("preprocessing.baselines.detrend", Detrend);
+/** Native `preprocessing.baselines.iasls` (transformer). */
+export class IAsLS extends NativeEstimator {
+    methodId = "preprocessing.baselines.iasls";
+    paramTypes = {
+        lam: "double",
+        p: "double",
+        lam_1: "double",
+        polyorder: "int",
+        diff_order: "int",
+        max_iter: "int",
+        tol: "double",
+    };
+    constructor(params = {}) {
+        super();
+        this.params = { ...params };
+    }
+    transform(X) {
+        return this.transformMatrix(X);
+    }
+}
+NativeMethod.register("preprocessing.baselines.iasls", IAsLS);
+/** Native `preprocessing.baselines.imodpoly` (transformer). */
+export class IModPoly extends NativeEstimator {
+    methodId = "preprocessing.baselines.imodpoly";
+    paramTypes = {
+        polyorder: "int",
+        max_iter: "int",
+        tol: "double",
+    };
+    constructor(params = {}) {
+        super();
+        this.params = { ...params };
+    }
+    transform(X) {
+        return this.transformMatrix(X);
+    }
+}
+NativeMethod.register("preprocessing.baselines.imodpoly", IModPoly);
+/** Native `preprocessing.baselines.modpoly` (transformer). */
+export class ModPoly extends NativeEstimator {
+    methodId = "preprocessing.baselines.modpoly";
+    paramTypes = {
+        polyorder: "int",
+        max_iter: "int",
+        tol: "double",
+    };
+    constructor(params = {}) {
+        super();
+        this.params = { ...params };
+    }
+    transform(X) {
+        return this.transformMatrix(X);
+    }
+}
+NativeMethod.register("preprocessing.baselines.modpoly", ModPoly);
+/** Native `preprocessing.baselines.rolling_ball` (transformer). */
+export class RollingBall extends NativeEstimator {
+    methodId = "preprocessing.baselines.rolling_ball";
+    paramTypes = {
+        half_window: "int",
+        smooth_half_window: "int",
+    };
+    constructor(params = {}) {
+        super();
+        this.params = { ...params };
+    }
+    transform(X) {
+        return this.transformMatrix(X);
+    }
+}
+NativeMethod.register("preprocessing.baselines.rolling_ball", RollingBall);
+/** Native `preprocessing.baselines.saps` (transformer). Required fit inputs: target_domain. */
+export class ScoreAugmentedProjectionStandardization extends NativeEstimator {
+    methodId = "preprocessing.baselines.saps";
+    paramTypes = {
+        n_components: "int",
+        score_weight: "double",
+        fit_intercept: "bool",
+        ridge: "double",
+    };
+    constructor(params = {}) {
+        super();
+        this.params = { ...params };
+    }
+    transform(X) {
+        return this.transformMatrix(X);
+    }
+}
+NativeMethod.register("preprocessing.baselines.saps", ScoreAugmentedProjectionStandardization);
+/** Native `preprocessing.baselines.snip` (transformer). */
+export class SNIP extends NativeEstimator {
+    methodId = "preprocessing.baselines.snip";
+    paramTypes = {
+        max_half_window: "int",
+    };
+    constructor(params = {}) {
+        super();
+        this.params = { ...params };
+    }
+    transform(X) {
+        return this.transformMatrix(X);
+    }
+}
+NativeMethod.register("preprocessing.baselines.snip", SNIP);
+/** Native `preprocessing.derivatives.derivate` (transformer). */
+export class Derivate extends NativeEstimator {
+    methodId = "preprocessing.derivatives.derivate";
+    paramTypes = {
+        order: "int",
+        delta: "double",
+    };
+    constructor(params = {}) {
+        super();
+        this.params = { ...params };
+    }
+    transform(X) {
+        return this.transformMatrix(X);
+    }
+}
+NativeMethod.register("preprocessing.derivatives.derivate", Derivate);
+/** Native `preprocessing.derivatives.first_derivative` (transformer). */
+export class FirstDerivative extends NativeEstimator {
+    methodId = "preprocessing.derivatives.first_derivative";
+    paramTypes = {
+        delta: "double",
+        edge_order: "int",
+    };
+    constructor(params = {}) {
+        super();
+        this.params = { ...params };
+    }
+    transform(X) {
+        return this.transformMatrix(X);
+    }
+}
+NativeMethod.register("preprocessing.derivatives.first_derivative", FirstDerivative);
+/** Native `preprocessing.derivatives.norris_williams` (transformer). */
+export class NorrisWilliams extends NativeEstimator {
+    methodId = "preprocessing.derivatives.norris_williams";
+    paramTypes = {
+        segment: "int",
+        gap: "int",
+        derivative_order: "int",
+        delta: "double",
+    };
+    constructor(params = {}) {
+        super();
+        this.params = { ...params };
+    }
+    transform(X) {
+        return this.transformMatrix(X);
+    }
+}
+NativeMethod.register("preprocessing.derivatives.norris_williams", NorrisWilliams);
+/** Native `preprocessing.derivatives.savitzky_golay` (transformer). */
+export class SavitzkyGolay extends NativeEstimator {
+    methodId = "preprocessing.derivatives.savitzky_golay";
+    paramTypes = {
+        window_length: "int",
+        polyorder: "int",
+        deriv: "int",
+        delta: "double",
+        mode: "enum",
+        cval: "double",
+    };
+    constructor(params = {}) {
+        super();
+        this.params = { ...params };
+    }
+    transform(X) {
+        return this.transformMatrix(X);
+    }
+}
+NativeMethod.register("preprocessing.derivatives.savitzky_golay", SavitzkyGolay);
+/** Native `preprocessing.derivatives.second_derivative` (transformer). */
+export class SecondDerivative extends NativeEstimator {
+    methodId = "preprocessing.derivatives.second_derivative";
+    paramTypes = {
+        delta: "double",
+        edge_order: "int",
+    };
+    constructor(params = {}) {
+        super();
+        this.params = { ...params };
+    }
+    transform(X) {
+        return this.transformMatrix(X);
+    }
+}
+NativeMethod.register("preprocessing.derivatives.second_derivative", SecondDerivative);
+/** Native `preprocessing.feature_selection.flexible_pca` (transformer). */
+export class FlexiblePCA extends NativeEstimator {
+    methodId = "preprocessing.feature_selection.flexible_pca";
+    paramTypes = {
+        n_components: "double",
+    };
+    constructor(params = {}) {
+        super();
+        this.params = { ...params };
+    }
+    transform(X) {
+        return this.transformMatrix(X);
+    }
+}
+NativeMethod.register("preprocessing.feature_selection.flexible_pca", FlexiblePCA);
+/** Native `preprocessing.feature_selection.flexible_svd` (transformer). */
+export class FlexibleSVD extends NativeEstimator {
+    methodId = "preprocessing.feature_selection.flexible_svd";
+    paramTypes = {
+        n_components: "double",
+    };
+    constructor(params = {}) {
+        super();
+        this.params = { ...params };
+    }
+    transform(X) {
+        return this.transformMatrix(X);
+    }
+}
+NativeMethod.register("preprocessing.feature_selection.flexible_svd", FlexibleSVD);
+/** Native `preprocessing.orthogonalization.epo` (transformer). */
+export class EPO extends NativeEstimator {
+    methodId = "preprocessing.orthogonalization.epo";
+    paramTypes = {
+        scale: "bool",
+    };
+    constructor(params = {}) {
+        super();
+        this.params = { ...params };
+    }
+    transform(X) {
+        return this.transformMatrix(X);
+    }
+}
+NativeMethod.register("preprocessing.orthogonalization.epo", EPO);
+/** Native `preprocessing.orthogonalization.osc` (transformer). */
+export class OSC extends NativeEstimator {
+    methodId = "preprocessing.orthogonalization.osc";
+    paramTypes = {
+        n_components: "int",
+        scale: "bool",
+    };
+    constructor(params = {}) {
+        super();
+        this.params = { ...params };
+    }
+    transform(X) {
+        return this.transformMatrix(X);
+    }
+}
+NativeMethod.register("preprocessing.orthogonalization.osc", OSC);
+/** Native `preprocessing.resampling.crop` (transformer). */
+export class CropTransformer extends NativeEstimator {
+    methodId = "preprocessing.resampling.crop";
+    paramTypes = {
+        start: "int",
+        end: "int",
+    };
+    constructor(params = {}) {
+        super();
+        this.params = { ...params };
+    }
+    transform(X) {
+        return this.transformMatrix(X);
+    }
+}
+NativeMethod.register("preprocessing.resampling.crop", CropTransformer);
+/** Native `preprocessing.resampling.kbins_discretizer` (transformer). */
+export class IntegerKBinsDiscretizer extends NativeEstimator {
+    methodId = "preprocessing.resampling.kbins_discretizer";
+    paramTypes = {
+        n_bins: "int",
+        strategy: "enum",
+    };
+    constructor(params = {}) {
+        super();
+        this.params = { ...params };
+    }
+    transform(X) {
+        return this.transformMatrix(X);
+    }
+}
+NativeMethod.register("preprocessing.resampling.kbins_discretizer", IntegerKBinsDiscretizer);
+/** Native `preprocessing.resampling.range_discretizer` (transformer). */
+export class RangeDiscretizer extends NativeEstimator {
+    methodId = "preprocessing.resampling.range_discretizer";
+    paramTypes = {
+        edges: "double_array",
+    };
+    constructor(params = {}) {
+        super();
+        this.params = { ...params };
+    }
+    transform(X) {
+        return this.transformMatrix(X);
+    }
+}
+NativeMethod.register("preprocessing.resampling.range_discretizer", RangeDiscretizer);
+/** Native `preprocessing.resampling.resample_transformer` (transformer). */
+export class ResampleTransformer extends NativeEstimator {
+    methodId = "preprocessing.resampling.resample_transformer";
+    paramTypes = {
+        num_samples: "int",
+    };
+    constructor(params = {}) {
+        super();
+        this.params = { ...params };
+    }
+    transform(X) {
+        return this.transformMatrix(X);
+    }
+}
+NativeMethod.register("preprocessing.resampling.resample_transformer", ResampleTransformer);
+/** Native `preprocessing.resampling.resampler` (transformer). Required fit inputs: axis. */
+export class Resampler extends NativeEstimator {
+    methodId = "preprocessing.resampling.resampler";
+    paramTypes = {
+        target_wavelengths: "double_array",
+        method: "enum",
+        crop_min: "double",
+        crop_max: "double",
+        use_crop: "bool",
+        fill_value: "double",
+        bounds_error: "bool",
+        extrapolate: "bool",
+        tgt_min: "double",
+        tgt_step: "double",
+        tgt_n: "int",
+    };
+    constructor(params = {}) {
+        super();
+        this.params = { ...params };
+    }
+    transform(X) {
+        return this.transformMatrix(X);
+    }
+}
+NativeMethod.register("preprocessing.resampling.resampler", Resampler);
+/** Native `preprocessing.scaling.baseline` (transformer). */
+export class BaselineCenter extends NativeEstimator {
+    methodId = "preprocessing.scaling.baseline";
+    paramTypes = {};
+    constructor(params = {}) {
+        super();
+        this.params = { ...params };
+    }
+    transform(X) {
+        return this.transformMatrix(X);
+    }
+}
+NativeMethod.register("preprocessing.scaling.baseline", BaselineCenter);
+/** Native `preprocessing.scaling.log_transform` (transformer). */
+export class LogTransform extends NativeEstimator {
+    methodId = "preprocessing.scaling.log_transform";
+    paramTypes = {
+        base: "double",
+        offset: "double",
+        auto_offset: "bool",
+        min_value: "double",
+    };
+    constructor(params = {}) {
+        super();
+        this.params = { ...params };
+    }
+    transform(X) {
+        return this.transformMatrix(X);
+    }
+}
+NativeMethod.register("preprocessing.scaling.log_transform", LogTransform);
+/** Native `preprocessing.scaling.normalize` (transformer). */
+export class Normalize extends NativeEstimator {
+    methodId = "preprocessing.scaling.normalize";
+    paramTypes = {
+        feature_min: "double",
+        feature_max: "double",
+    };
+    constructor(params = {}) {
+        super();
+        this.params = { ...params };
+    }
+    transform(X) {
+        return this.transformMatrix(X);
+    }
+}
+NativeMethod.register("preprocessing.scaling.normalize", Normalize);
+/** Native `preprocessing.scaling.simple_scale` (transformer). */
+export class SimpleScale extends NativeEstimator {
+    methodId = "preprocessing.scaling.simple_scale";
+    paramTypes = {};
+    constructor(params = {}) {
+        super();
+        this.params = { ...params };
+    }
+    transform(X) {
+        return this.transformMatrix(X);
+    }
+}
+NativeMethod.register("preprocessing.scaling.simple_scale", SimpleScale);
+/** Native `preprocessing.scatter.area_normalization` (transformer). */
+export class AreaNormalization extends NativeEstimator {
+    methodId = "preprocessing.scatter.area_normalization";
+    paramTypes = {
+        method: "enum",
+    };
+    constructor(params = {}) {
+        super();
+        this.params = { ...params };
+    }
+    transform(X) {
+        return this.transformMatrix(X);
+    }
+}
+NativeMethod.register("preprocessing.scatter.area_normalization", AreaNormalization);
+/** Native `preprocessing.scatter.emsc` (transformer). */
+export class EMSC extends NativeEstimator {
+    methodId = "preprocessing.scatter.emsc";
+    paramTypes = {
+        degree: "int",
+    };
+    constructor(params = {}) {
+        super();
+        this.params = { ...params };
+    }
+    transform(X) {
+        return this.transformMatrix(X);
+    }
+}
+NativeMethod.register("preprocessing.scatter.emsc", EMSC);
+/** Native `preprocessing.scatter.local_centering` (transformer). Required fit inputs: target_domain. */
+export class LocalCentering extends NativeEstimator {
+    methodId = "preprocessing.scatter.local_centering";
+    paramTypes = {};
+    constructor(params = {}) {
+        super();
+        this.params = { ...params };
+    }
+    transform(X) {
+        return this.transformMatrix(X);
+    }
+}
+NativeMethod.register("preprocessing.scatter.local_centering", LocalCentering);
+/** Native `preprocessing.scatter.local_snv` (transformer). */
+export class LSNV extends NativeEstimator {
+    methodId = "preprocessing.scatter.local_snv";
+    paramTypes = {
+        window: "int",
+        pad_mode: "enum",
+        constant_value: "double",
+    };
+    constructor(params = {}) {
+        super();
+        this.params = { ...params };
+    }
+    transform(X) {
+        return this.transformMatrix(X);
+    }
+}
+NativeMethod.register("preprocessing.scatter.local_snv", LSNV);
+/** Native `preprocessing.scatter.localized_msc` (transformer). */
+export class LocalizedMSC extends NativeEstimator {
+    methodId = "preprocessing.scatter.localized_msc";
+    paramTypes = {
+        window_size: "int",
+        reference: "double_array",
+        eps: "double",
+    };
+    constructor(params = {}) {
+        super();
+        this.params = { ...params };
+    }
+    transform(X) {
+        return this.transformMatrix(X);
+    }
+}
+NativeMethod.register("preprocessing.scatter.localized_msc", LocalizedMSC);
+/** Native `preprocessing.scatter.msc` (transformer). */
+export class MSC extends NativeEstimator {
+    methodId = "preprocessing.scatter.msc";
+    paramTypes = {};
+    constructor(params = {}) {
+        super();
+        this.params = { ...params };
+    }
+    transform(X) {
+        return this.transformMatrix(X);
+    }
+}
+NativeMethod.register("preprocessing.scatter.msc", MSC);
+/** Native `preprocessing.scatter.piecewise_msc` (transformer). */
+export class PiecewiseMSC extends NativeEstimator {
+    methodId = "preprocessing.scatter.piecewise_msc";
+    paramTypes = {
+        window_size: "int",
+        reference: "double_array",
+        eps: "double",
+    };
+    constructor(params = {}) {
+        super();
+        this.params = { ...params };
+    }
+    transform(X) {
+        return this.transformMatrix(X);
+    }
+}
+NativeMethod.register("preprocessing.scatter.piecewise_msc", PiecewiseMSC);
+/** Native `preprocessing.scatter.piecewise_snv` (transformer). */
+export class PiecewiseSNV extends NativeEstimator {
+    methodId = "preprocessing.scatter.piecewise_snv";
+    paramTypes = {
+        window_size: "int",
+        ddof: "int",
+        eps: "double",
+    };
+    constructor(params = {}) {
+        super();
+        this.params = { ...params };
+    }
+    transform(X) {
+        return this.transformMatrix(X);
+    }
+}
+NativeMethod.register("preprocessing.scatter.piecewise_snv", PiecewiseSNV);
+/** Native `preprocessing.scatter.robust_snv` (transformer). */
+export class RNV extends NativeEstimator {
+    methodId = "preprocessing.scatter.robust_snv";
+    paramTypes = {
+        with_center: "bool",
+        with_scale: "bool",
+        k: "double",
+    };
+    constructor(params = {}) {
+        super();
+        this.params = { ...params };
+    }
+    transform(X) {
+        return this.transformMatrix(X);
+    }
+}
+NativeMethod.register("preprocessing.scatter.robust_snv", RNV);
+/** Native `preprocessing.scatter.snv` (transformer). */
+export class SNV extends NativeEstimator {
+    methodId = "preprocessing.scatter.snv";
+    paramTypes = {
+        with_mean: "bool",
+        with_std: "bool",
+        ddof: "int",
+    };
+    constructor(params = {}) {
+        super();
+        this.params = { ...params };
+    }
+    transform(X) {
+        return this.transformMatrix(X);
+    }
+}
+NativeMethod.register("preprocessing.scatter.snv", SNV);
+/** Native `preprocessing.scatter.vsn` (transformer). */
+export class VariableSortingNormalization extends NativeEstimator {
+    methodId = "preprocessing.scatter.vsn";
+    paramTypes = {
+        eps: "double",
+    };
+    constructor(params = {}) {
+        super();
+        this.params = { ...params };
+    }
+    transform(X) {
+        return this.transformMatrix(X);
+    }
+}
+NativeMethod.register("preprocessing.scatter.vsn", VariableSortingNormalization);
+/** Native `preprocessing.scatter.weighted_snv` (transformer). */
+export class WeightedSNV extends NativeEstimator {
+    methodId = "preprocessing.scatter.weighted_snv";
+    paramTypes = {
+        weights: "double_array",
+        ddof: "int",
+        eps: "double",
+    };
+    constructor(params = {}) {
+        super();
+        this.params = { ...params };
+    }
+    transform(X) {
+        return this.transformMatrix(X);
+    }
+}
+NativeMethod.register("preprocessing.scatter.weighted_snv", WeightedSNV);
+/** Native `preprocessing.signal_conversion.fraction_to_percent` (transformer). */
+export class FractionToPercent extends NativeEstimator {
+    methodId = "preprocessing.signal_conversion.fraction_to_percent";
+    paramTypes = {};
+    constructor(params = {}) {
+        super();
+        this.params = { ...params };
+    }
+    transform(X) {
+        return this.transformMatrix(X);
+    }
+}
+NativeMethod.register("preprocessing.signal_conversion.fraction_to_percent", FractionToPercent);
+/** Native `preprocessing.signal_conversion.from_absorbance` (transformer). */
+export class FromAbsorbance extends NativeEstimator {
+    methodId = "preprocessing.signal_conversion.from_absorbance";
+    paramTypes = {
+        is_percent: "bool",
+    };
+    constructor(params = {}) {
+        super();
+        this.params = { ...params };
+    }
+    transform(X) {
+        return this.transformMatrix(X);
+    }
+}
+NativeMethod.register("preprocessing.signal_conversion.from_absorbance", FromAbsorbance);
+/** Native `preprocessing.signal_conversion.kubelka_munk` (transformer). */
+export class KubelkaMunk extends NativeEstimator {
+    methodId = "preprocessing.signal_conversion.kubelka_munk";
+    paramTypes = {
+        is_percent: "bool",
+        epsilon: "double",
+    };
+    constructor(params = {}) {
+        super();
+        this.params = { ...params };
+    }
+    transform(X) {
+        return this.transformMatrix(X);
+    }
+}
+NativeMethod.register("preprocessing.signal_conversion.kubelka_munk", KubelkaMunk);
+/** Native `preprocessing.signal_conversion.percent_to_fraction` (transformer). */
+export class PercentToFraction extends NativeEstimator {
+    methodId = "preprocessing.signal_conversion.percent_to_fraction";
+    paramTypes = {};
+    constructor(params = {}) {
+        super();
+        this.params = { ...params };
+    }
+    transform(X) {
+        return this.transformMatrix(X);
+    }
+}
+NativeMethod.register("preprocessing.signal_conversion.percent_to_fraction", PercentToFraction);
+/** Native `preprocessing.signal_conversion.to_absorbance` (transformer). */
+export class ToAbsorbance extends NativeEstimator {
+    methodId = "preprocessing.signal_conversion.to_absorbance";
+    paramTypes = {
+        is_percent: "bool",
+        epsilon: "double",
+        clip_negative: "bool",
+    };
+    constructor(params = {}) {
+        super();
+        this.params = { ...params };
+    }
+    transform(X) {
+        return this.transformMatrix(X);
+    }
+}
+NativeMethod.register("preprocessing.signal_conversion.to_absorbance", ToAbsorbance);
+/** Native `preprocessing.smoothing.gaussian` (transformer). */
+export class Gaussian extends NativeEstimator {
+    methodId = "preprocessing.smoothing.gaussian";
+    paramTypes = {
+        sigma: "double",
+        order: "int",
+        mode: "enum",
+        cval: "double",
+        truncate: "double",
+    };
+    constructor(params = {}) {
+        super();
+        this.params = { ...params };
+    }
+    transform(X) {
+        return this.transformMatrix(X);
+    }
+}
+NativeMethod.register("preprocessing.smoothing.gaussian", Gaussian);
+/** Native `preprocessing.specialized.fck_static` (transformer). */
+export class FCKStaticTransformer extends NativeEstimator {
+    methodId = "preprocessing.specialized.fck_static";
+    paramTypes = {
+        kernel_size: "int",
+        alphas: "double_array",
+        sigmas: "double_array",
+    };
+    constructor(params = {}) {
+        super();
+        this.params = { ...params };
+    }
+    transform(X) {
+        return this.transformMatrix(X);
+    }
+}
+NativeMethod.register("preprocessing.specialized.fck_static", FCKStaticTransformer);
+/** Native `preprocessing.transfer.direct_standardization` (transformer). Required fit inputs: target_domain. */
+export class DirectStandardization extends NativeEstimator {
+    methodId = "preprocessing.transfer.direct_standardization";
+    paramTypes = {
+        fit_intercept: "bool",
+        ridge: "double",
+    };
+    constructor(params = {}) {
+        super();
+        this.params = { ...params };
+    }
+    transform(X) {
+        return this.transformMatrix(X);
+    }
+}
+NativeMethod.register("preprocessing.transfer.direct_standardization", DirectStandardization);
+/** Native `preprocessing.transfer.piecewise_direct_standardization` (transformer). Required fit inputs: target_domain. */
+export class PiecewiseDirectStandardization extends NativeEstimator {
+    methodId = "preprocessing.transfer.piecewise_direct_standardization";
+    paramTypes = {
+        window_size: "int",
+        fit_intercept: "bool",
+        ridge: "double",
+    };
+    constructor(params = {}) {
+        super();
+        this.params = { ...params };
+    }
+    transform(X) {
+        return this.transformMatrix(X);
+    }
+}
+NativeMethod.register("preprocessing.transfer.piecewise_direct_standardization", PiecewiseDirectStandardization);
+/** Native `preprocessing.transfer.robust_direct_standardization` (transformer). Required fit inputs: target_domain. */
+export class RobustDirectStandardization extends NativeEstimator {
+    methodId = "preprocessing.transfer.robust_direct_standardization";
+    paramTypes = {
+        fit_intercept: "bool",
+        ridge: "double",
+        trim_quantile: "double",
+        max_iter: "int",
+    };
+    constructor(params = {}) {
+        super();
+        this.params = { ...params };
+    }
+    transform(X) {
+        return this.transformMatrix(X);
+    }
+}
+NativeMethod.register("preprocessing.transfer.robust_direct_standardization", RobustDirectStandardization);
+/** Native `preprocessing.transfer.slope_bias` (transformer). */
+export class SlopeBiasCorrection extends NativeEstimator {
+    methodId = "preprocessing.transfer.slope_bias";
+    paramTypes = {};
+    constructor(params = {}) {
+        super();
+        this.params = { ...params };
+    }
+    transform(X) {
+        return this.transformMatrix(X);
+    }
+}
+NativeMethod.register("preprocessing.transfer.slope_bias", SlopeBiasCorrection);
+/** Native `preprocessing.wavelets.haar` (transformer). */
+export class Haar extends NativeEstimator {
+    methodId = "preprocessing.wavelets.haar";
+    paramTypes = {};
+    constructor(params = {}) {
+        super();
+        this.params = { ...params };
+    }
+    transform(X) {
+        return this.transformMatrix(X);
+    }
+}
+NativeMethod.register("preprocessing.wavelets.haar", Haar);
+/** Native `preprocessing.wavelets.wavelet` (transformer). */
+export class Wavelet extends NativeEstimator {
+    methodId = "preprocessing.wavelets.wavelet";
+    paramTypes = {
+        family: "enum",
+        mode: "enum",
+    };
+    constructor(params = {}) {
+        super();
+        this.params = { ...params };
+    }
+    transform(X) {
+        return this.transformMatrix(X);
+    }
+}
+NativeMethod.register("preprocessing.wavelets.wavelet", Wavelet);
+/** Native `preprocessing.wavelets.wavelet_denoise` (transformer). */
+export class WaveletDenoise extends NativeEstimator {
+    methodId = "preprocessing.wavelets.wavelet_denoise";
+    paramTypes = {
+        family: "enum",
+        mode: "enum",
+        level: "int",
+        threshold_mode: "enum",
+        noise_estimator: "enum",
+    };
+    constructor(params = {}) {
+        super();
+        this.params = { ...params };
+    }
+    transform(X) {
+        return this.transformMatrix(X);
+    }
+}
+NativeMethod.register("preprocessing.wavelets.wavelet_denoise", WaveletDenoise);
+/** Native `preprocessing.wavelets.wavelet_features` (transformer). */
+export class WaveletFeatures extends NativeEstimator {
+    methodId = "preprocessing.wavelets.wavelet_features";
+    paramTypes = {
+        family: "enum",
+        mode: "enum",
+        max_level: "int",
+        entropy: "enum",
+    };
+    constructor(params = {}) {
+        super();
+        this.params = { ...params };
+    }
+    transform(X) {
+        return this.transformMatrix(X);
+    }
+}
+NativeMethod.register("preprocessing.wavelets.wavelet_features", WaveletFeatures);
+/** Native `preprocessing.wavelets.wavelet_pca` (transformer). */
+export class WaveletPCA extends NativeEstimator {
+    methodId = "preprocessing.wavelets.wavelet_pca";
+    paramTypes = {
+        family: "enum",
+        mode: "enum",
+        max_level: "int",
+        n_components: "double",
+    };
+    constructor(params = {}) {
+        super();
+        this.params = { ...params };
+    }
+    transform(X) {
+        return this.transformMatrix(X);
+    }
+}
+NativeMethod.register("preprocessing.wavelets.wavelet_pca", WaveletPCA);
+/** Native `preprocessing.wavelets.wavelet_svd` (transformer). */
+export class WaveletSVD extends NativeEstimator {
+    methodId = "preprocessing.wavelets.wavelet_svd";
+    paramTypes = {
+        family: "enum",
+        mode: "enum",
+        max_level: "int",
+        n_components: "double",
+    };
+    constructor(params = {}) {
+        super();
+        this.params = { ...params };
+    }
+    transform(X) {
+        return this.transformMatrix(X);
+    }
+}
+NativeMethod.register("preprocessing.wavelets.wavelet_svd", WaveletSVD);
+/** Native `selection.bipls` (selector). */
+export class BiPLS extends NativeEstimator {
+    methodId = "selection.bipls";
+    paramTypes = {
+        n_components: "int",
+        interval_width: "int",
+        min_intervals: "int",
+        cv: "int",
+    };
+    constructor(params = {}) {
+        super();
+        this.params = { ...params };
+    }
+    transform(X) {
+        return this.transformMatrix(X);
+    }
+    selectedIndices() {
+        return this.selectedIndexArray();
+    }
+}
+NativeMethod.register("selection.bipls", BiPLS);
+/** Native `selection.bve` (selector). */
+export class BVE extends NativeEstimator {
+    methodId = "selection.bve";
+    paramTypes = {
+        n_components: "int",
+        n_steps: "int",
+        min_features: "int",
+        cv: "int",
+    };
+    constructor(params = {}) {
+        super();
+        this.params = { ...params };
+    }
+    transform(X) {
+        return this.transformMatrix(X);
+    }
+    selectedIndices() {
+        return this.selectedIndexArray();
+    }
+}
+NativeMethod.register("selection.bve", BVE);
+/** Native `selection.cars` (selector). */
+export class CARS extends NativeEstimator {
+    methodId = "selection.cars";
+    paramTypes = {
+        n_components: "int",
+        n_iterations: "int",
+        min_features: "int",
+        cv: "int",
+    };
+    constructor(params = {}) {
+        super();
+        this.params = { ...params };
+    }
+    transform(X) {
+        return this.transformMatrix(X);
+    }
+    selectedIndices() {
+        return this.selectedIndexArray();
+    }
+}
+NativeMethod.register("selection.cars", CARS);
+/** Native `selection.emcuve` (selector). */
+export class EMCUVE extends NativeEstimator {
+    methodId = "selection.emcuve";
+    paramTypes = {
+        n_components: "int",
+        noise_features: "int",
+        noise_seed: "int",
+        n_ensembles: "int",
+        vote_threshold: "double",
+        cv: "int",
+    };
+    constructor(params = {}) {
+        super();
+        this.params = { ...params };
+    }
+    transform(X) {
+        return this.transformMatrix(X);
+    }
+    selectedIndices() {
+        return this.selectedIndexArray();
+    }
+}
+NativeMethod.register("selection.emcuve", EMCUVE);
+/** Native `selection.ga` (selector). */
+export class GA extends NativeEstimator {
+    methodId = "selection.ga";
+    paramTypes = {
+        n_components: "int",
+        n_generations: "int",
+        population_size: "int",
+        min_features: "int",
+        max_features: "int",
+        mutation_rate: "double",
+        cv: "int",
+        seed: "int",
+    };
+    constructor(params = {}) {
+        super();
+        this.params = { ...params };
+    }
+    transform(X) {
+        return this.transformMatrix(X);
+    }
+    selectedIndices() {
+        return this.selectedIndexArray();
+    }
+}
+NativeMethod.register("selection.ga", GA);
+/** Native `selection.interval` (transformer). */
+export class IntervalGenerator extends NativeEstimator {
+    methodId = "selection.interval";
+    paramTypes = {
+        interval_size: "int",
+        step: "int",
+    };
+    constructor(params = {}) {
+        super();
+        this.params = { ...params };
+    }
+    transform(X) {
+        return this.transformMatrix(X);
+    }
+}
+NativeMethod.register("selection.interval", IntervalGenerator);
+/** Native `selection.ipw` (selector). */
+export class IPW extends NativeEstimator {
+    methodId = "selection.ipw";
+    paramTypes = {
+        top_k: "int",
+        n_components: "int",
+        n_iterations: "int",
+        damping: "double",
+        weight_floor: "double",
+        cv: "int",
+    };
+    constructor(params = {}) {
+        super();
+        this.params = { ...params };
+    }
+    transform(X) {
+        return this.transformMatrix(X);
+    }
+    selectedIndices() {
+        return this.selectedIndexArray();
+    }
+}
+NativeMethod.register("selection.ipw", IPW);
+/** Native `selection.irf` (selector). */
+export class IRF extends NativeEstimator {
+    methodId = "selection.irf";
+    paramTypes = {
+        top_k: "int",
+        n_components: "int",
+        n_iterations: "int",
+        window_size: "int",
+        initial_intervals: "int",
+        cv: "int",
+        seed: "int",
+    };
+    constructor(params = {}) {
+        super();
+        this.params = { ...params };
+    }
+    transform(X) {
+        return this.transformMatrix(X);
+    }
+    selectedIndices() {
+        return this.selectedIndexArray();
+    }
+}
+NativeMethod.register("selection.irf", IRF);
+/** Native `selection.iriv` (selector). */
+export class IRIV extends NativeEstimator {
+    methodId = "selection.iriv";
+    paramTypes = {
+        n_components: "int",
+        max_rounds: "int",
+        cv: "int",
+        seed: "int",
+    };
+    constructor(params = {}) {
+        super();
+        this.params = { ...params };
+    }
+    transform(X) {
+        return this.transformMatrix(X);
+    }
+    selectedIndices() {
+        return this.selectedIndexArray();
+    }
+}
+NativeMethod.register("selection.iriv", IRIV);
+/** Native `selection.pso` (selector). */
+export class PSO extends NativeEstimator {
+    methodId = "selection.pso";
+    paramTypes = {
+        n_components: "int",
+        n_swarm: "int",
+        n_iterations: "int",
+        w: "double",
+        c1: "double",
+        c2: "double",
+        v_max: "double",
+        cv: "int",
+        seed: "int",
+    };
+    constructor(params = {}) {
+        super();
+        this.params = { ...params };
+    }
+    transform(X) {
+        return this.transformMatrix(X);
+    }
+    selectedIndices() {
+        return this.selectedIndexArray();
+    }
+}
+NativeMethod.register("selection.pso", PSO);
+/** Native `selection.random_frog` (selector). */
+export class RandomFrog extends NativeEstimator {
+    methodId = "selection.random_frog";
+    paramTypes = {
+        top_k: "int",
+        n_components: "int",
+        n_iterations: "int",
+        initial_size: "int",
+        min_size: "int",
+        max_size: "int",
+        cv: "int",
+        seed: "int",
+    };
+    constructor(params = {}) {
+        super();
+        this.params = { ...params };
+    }
+    transform(X) {
+        return this.transformMatrix(X);
+    }
+    selectedIndices() {
+        return this.selectedIndexArray();
+    }
+}
+NativeMethod.register("selection.random_frog", RandomFrog);
+/** Native `selection.randomization` (selector). */
+export class Randomization extends NativeEstimator {
+    methodId = "selection.randomization";
+    paramTypes = {
+        n_components: "int",
+        n_permutations: "int",
+        randomization_seed: "int",
+        alpha: "double",
+    };
+    constructor(params = {}) {
+        super();
+        this.params = { ...params };
+    }
+    transform(X) {
+        return this.transformMatrix(X);
+    }
+    selectedIndices() {
+        return this.selectedIndexArray();
+    }
+}
+NativeMethod.register("selection.randomization", Randomization);
+/** Native `selection.rep` (selector). */
+export class REP extends NativeEstimator {
+    methodId = "selection.rep";
+    paramTypes = {
+        n_components: "int",
+        n_steps: "int",
+        min_features: "int",
+        remove_count: "int",
+        cv: "int",
+    };
+    constructor(params = {}) {
+        super();
+        this.params = { ...params };
+    }
+    transform(X) {
+        return this.transformMatrix(X);
+    }
+    selectedIndices() {
+        return this.selectedIndexArray();
+    }
+}
+NativeMethod.register("selection.rep", REP);
+/** Native `selection.scars` (selector). */
+export class SCARS extends NativeEstimator {
+    methodId = "selection.scars";
+    paramTypes = {
+        n_components: "int",
+        n_iterations: "int",
+        min_features: "int",
+        sample_fraction: "double",
+        cv: "int",
+        seed: "int",
+    };
+    constructor(params = {}) {
+        super();
+        this.params = { ...params };
+    }
+    transform(X) {
+        return this.transformMatrix(X);
+    }
+    selectedIndices() {
+        return this.selectedIndexArray();
+    }
+}
+NativeMethod.register("selection.scars", SCARS);
+/** Native `selection.shaving` (selector). */
+export class Shaving extends NativeEstimator {
+    methodId = "selection.shaving";
+    paramTypes = {
+        n_components: "int",
+        n_steps: "int",
+        min_features: "int",
+        shave_fraction: "double",
+        cv: "int",
+    };
+    constructor(params = {}) {
+        super();
+        this.params = { ...params };
+    }
+    transform(X) {
+        return this.transformMatrix(X);
+    }
+    selectedIndices() {
+        return this.selectedIndexArray();
+    }
+}
+NativeMethod.register("selection.shaving", Shaving);
+/** Native `selection.sipls` (selector). */
+export class SiPLS extends NativeEstimator {
+    methodId = "selection.sipls";
+    paramTypes = {
+        n_components: "int",
+        interval_width: "int",
+        combination_size: "int",
+        cv: "int",
+    };
+    constructor(params = {}) {
+        super();
+        this.params = { ...params };
+    }
+    transform(X) {
+        return this.transformMatrix(X);
+    }
+    selectedIndices() {
+        return this.selectedIndexArray();
+    }
+}
+NativeMethod.register("selection.sipls", SiPLS);
+/** Native `selection.spa` (selector). */
+export class SPA extends NativeEstimator {
+    methodId = "selection.spa";
+    paramTypes = {
+        top_k: "int",
+        n_components: "int",
+    };
+    constructor(params = {}) {
+        super();
+        this.params = { ...params };
+    }
+    transform(X) {
+        return this.transformMatrix(X);
+    }
+    selectedIndices() {
+        return this.selectedIndexArray();
+    }
+}
+NativeMethod.register("selection.spa", SPA);
+/** Native `selection.st` (selector). */
+export class ST extends NativeEstimator {
+    methodId = "selection.st";
+    paramTypes = {
+        thresholds: "double_array",
+        n_components: "int",
+        min_selected: "int",
+        cv: "int",
+    };
+    constructor(params = {}) {
+        super();
+        this.params = { ...params };
+    }
+    transform(X) {
+        return this.transformMatrix(X);
+    }
+    selectedIndices() {
+        return this.selectedIndexArray();
+    }
+}
+NativeMethod.register("selection.st", ST);
+/** Native `selection.stability` (selector). */
+export class Stability extends NativeEstimator {
+    methodId = "selection.stability";
+    paramTypes = {
+        top_k: "int",
+        n_components: "int",
+        cv: "int",
+    };
+    constructor(params = {}) {
+        super();
+        this.params = { ...params };
+    }
+    transform(X) {
+        return this.transformMatrix(X);
+    }
+    selectedIndices() {
+        return this.selectedIndexArray();
+    }
+}
+NativeMethod.register("selection.stability", Stability);
+/** Native `selection.t2` (selector). */
+export class T2 extends NativeEstimator {
+    methodId = "selection.t2";
+    paramTypes = {
+        alpha_thresholds: "double_array",
+        n_components: "int",
+        min_selected: "int",
+        cv: "int",
+    };
+    constructor(params = {}) {
+        super();
+        this.params = { ...params };
+    }
+    transform(X) {
+        return this.transformMatrix(X);
+    }
+    selectedIndices() {
+        return this.selectedIndexArray();
+    }
+}
+NativeMethod.register("selection.t2", T2);
+/** Native `selection.uve` (selector). */
+export class UVE extends NativeEstimator {
+    methodId = "selection.uve";
+    paramTypes = {
+        n_components: "int",
+        noise_features: "int",
+        noise_seed: "int",
+        min_features: "int",
+        cv: "int",
+    };
+    constructor(params = {}) {
+        super();
+        this.params = { ...params };
+    }
+    transform(X) {
+        return this.transformMatrix(X);
+    }
+    selectedIndices() {
+        return this.selectedIndexArray();
+    }
+}
+NativeMethod.register("selection.uve", UVE);
+/** Native `selection.variable_select` (selector). */
+export class VariableSelect extends NativeEstimator {
+    methodId = "selection.variable_select";
+    paramTypes = {
+        top_k: "int",
+        n_components: "int",
+        rank_method: "enum",
+    };
+    constructor(params = {}) {
+        super();
+        this.params = { ...params };
+    }
+    transform(X) {
+        return this.transformMatrix(X);
+    }
+    selectedIndices() {
+        return this.selectedIndexArray();
+    }
+}
+NativeMethod.register("selection.variable_select", VariableSelect);
+/** Native `selection.vip_spa` (selector). */
+export class VIPSPA extends NativeEstimator {
+    methodId = "selection.vip_spa";
+    paramTypes = {
+        top_k: "int",
+        n_components: "int",
+        vip_threshold: "double",
+    };
+    constructor(params = {}) {
+        super();
+        this.params = { ...params };
+    }
+    transform(X) {
+        return this.transformMatrix(X);
+    }
+    selectedIndices() {
+        return this.selectedIndexArray();
+    }
+}
+NativeMethod.register("selection.vip_spa", VIPSPA);
+/** Native `selection.vissa` (selector). */
+export class VISSA extends NativeEstimator {
+    methodId = "selection.vissa";
+    paramTypes = {
+        n_components: "int",
+        n_iterations: "int",
+        n_submodels: "int",
+        ratio_kept: "double",
+        threshold: "double",
+        floor_probability: "double",
+        cv: "int",
+        seed: "int",
+    };
+    constructor(params = {}) {
+        super();
+        this.params = { ...params };
+    }
+    transform(X) {
+        return this.transformMatrix(X);
+    }
+    selectedIndices() {
+        return this.selectedIndexArray();
+    }
+}
+NativeMethod.register("selection.vissa", VISSA);
+/** Native `selection.wvc` (selector). */
+export class WVC extends NativeEstimator {
+    methodId = "selection.wvc";
+    paramTypes = {
+        top_k: "int",
+        n_components: "int",
+        normalize: "bool",
+    };
+    constructor(params = {}) {
+        super();
+        this.params = { ...params };
+    }
+    transform(X) {
+        return this.transformMatrix(X);
+    }
+    selectedIndices() {
+        return this.selectedIndexArray();
+    }
+}
+NativeMethod.register("selection.wvc", WVC);
+/** Native `selection.wvc_threshold` (selector). */
+export class WVCThreshold extends NativeEstimator {
+    methodId = "selection.wvc_threshold";
+    paramTypes = {
+        n_components: "int",
+        normalize: "bool",
+        score_threshold: "double",
+        threshold_factor: "double",
+        min_selected: "int",
+    };
+    constructor(params = {}) {
+        super();
+        this.params = { ...params };
+    }
+    transform(X) {
+        return this.transformMatrix(X);
+    }
+    selectedIndices() {
+        return this.selectedIndexArray();
+    }
+}
+NativeMethod.register("selection.wvc_threshold", WVCThreshold);
+/** Native `splitters.binned_strat_group_kfold` (splitter). Required inputs: y, groups. */
+export class BinnedStratifiedGroupKFold extends NativeProcedure {
+    methodId = "splitters.binned_strat_group_kfold";
+    paramTypes = {
+        n_splits: "int",
+        n_bins: "int",
+        strategy: "enum",
+        shuffle: "bool",
+        seed: "int",
+    };
+    constructor(params = {}) {
+        super();
+        this.params = { ...params };
+    }
+    split(X, y, groups) {
+        return this.splitFolds(X, y, groups);
+    }
+}
+NativeMethod.register("splitters.binned_strat_group_kfold", BinnedStratifiedGroupKFold);
+/** Native `splitters.kbins_stratified` (splitter). Required inputs: y. */
+export class KBinsStratified extends NativeProcedure {
+    methodId = "splitters.kbins_stratified";
+    paramTypes = {
+        test_size: "double",
+        seed: "int",
+        n_bins: "int",
+        strategy: "enum",
+    };
+    constructor(params = {}) {
+        super();
+        this.params = { ...params };
+    }
+    split(X, y, groups) {
+        return this.splitFolds(X, y, groups);
+    }
+}
+NativeMethod.register("splitters.kbins_stratified", KBinsStratified);
+/** Native `splitters.kennard_stone` (splitter). */
+export class KennardStone extends NativeProcedure {
+    methodId = "splitters.kennard_stone";
+    paramTypes = {
+        test_size: "double",
+    };
+    constructor(params = {}) {
+        super();
+        this.params = { ...params };
+    }
+    split(X, y, groups) {
+        return this.splitFolds(X, y, groups);
+    }
+}
+NativeMethod.register("splitters.kennard_stone", KennardStone);
+/** Native `splitters.kmeans` (splitter). */
+export class KMeans extends NativeProcedure {
+    methodId = "splitters.kmeans";
+    paramTypes = {
+        test_size: "double",
+        seed: "int",
+        max_iter: "int",
+    };
+    constructor(params = {}) {
+        super();
+        this.params = { ...params };
+    }
+    split(X, y, groups) {
+        return this.splitFolds(X, y, groups);
+    }
+}
+NativeMethod.register("splitters.kmeans", KMeans);
+/** Native `splitters.split_splitter` (splitter). */
+export class SPlitSplitter extends NativeProcedure {
+    methodId = "splitters.split_splitter";
+    paramTypes = {
+        test_size: "double",
+        seed: "int",
+    };
+    constructor(params = {}) {
+        super();
+        this.params = { ...params };
+    }
+    split(X, y, groups) {
+        return this.splitFolds(X, y, groups);
+    }
+}
+NativeMethod.register("splitters.split_splitter", SPlitSplitter);
+/** Native `splitters.spxy` (splitter). Required inputs: y. */
+export class SPXY extends NativeProcedure {
+    methodId = "splitters.spxy";
+    paramTypes = {
+        test_size: "double",
+    };
+    constructor(params = {}) {
+        super();
+        this.params = { ...params };
+    }
+    split(X, y, groups) {
+        return this.splitFolds(X, y, groups);
+    }
+}
+NativeMethod.register("splitters.spxy", SPXY);
+/** Native `splitters.spxy_fold` (splitter). Required inputs: y. */
+export class SPXYFold extends NativeProcedure {
+    methodId = "splitters.spxy_fold";
+    paramTypes = {
+        n_splits: "int",
+        y_metric: "enum",
+    };
+    constructor(params = {}) {
+        super();
+        this.params = { ...params };
+    }
+    split(X, y, groups) {
+        return this.splitFolds(X, y, groups);
+    }
+}
+NativeMethod.register("splitters.spxy_fold", SPXYFold);
+/** Native `splitters.spxy_g_fold` (splitter). Required inputs: y, groups. */
+export class SPXYGroupFold extends NativeProcedure {
+    methodId = "splitters.spxy_g_fold";
+    paramTypes = {
+        n_splits: "int",
+        y_metric: "enum",
+        aggregation: "enum",
+    };
+    constructor(params = {}) {
+        super();
+        this.params = { ...params };
+    }
+    split(X, y, groups) {
+        return this.splitFolds(X, y, groups);
+    }
+}
+NativeMethod.register("splitters.spxy_g_fold", SPXYGroupFold);
+/** Native `splitters.systematic_circular` (splitter). Required inputs: y. */
+export class SystematicCircular extends NativeProcedure {
+    methodId = "splitters.systematic_circular";
+    paramTypes = {
+        test_size: "double",
+        seed: "int",
+    };
+    constructor(params = {}) {
+        super();
+        this.params = { ...params };
+    }
+    split(X, y, groups) {
+        return this.splitFolds(X, y, groups);
+    }
+}
+NativeMethod.register("splitters.systematic_circular", SystematicCircular);
+/** Native `utilities.hotelling_t2` (generic). */
+export class HotellingT2 extends NativeProcedure {
+    methodId = "utilities.hotelling_t2";
+    paramTypes = {
+        n_components: "int",
+        alpha: "double",
+    };
+    constructor(params = {}) {
+        super();
+        this.params = { ...params };
+    }
+    run(X, y, inputs = {}) {
+        return this.runOutputs(X, y, inputs);
+    }
+}
+NativeMethod.register("utilities.hotelling_t2", HotellingT2);
+/** Native `utilities.moments` (generic). Required inputs: y. */
+export class Moments extends NativeProcedure {
+    methodId = "utilities.moments";
+    paramTypes = {};
+    constructor(params = {}) {
+        super();
+        this.params = { ...params };
+    }
+    run(X, y, inputs = {}) {
+        return this.runOutputs(X, y, inputs);
+    }
+}
+NativeMethod.register("utilities.moments", Moments);
+/** Native `utilities.q_residuals` (generic). */
+export class QResiduals extends NativeProcedure {
+    methodId = "utilities.q_residuals";
+    paramTypes = {
+        n_components: "int",
+        alpha: "double",
+    };
+    constructor(params = {}) {
+        super();
+        this.params = { ...params };
+    }
+    run(X, y, inputs = {}) {
+        return this.runOutputs(X, y, inputs);
+    }
+}
+NativeMethod.register("utilities.q_residuals", QResiduals);
+/** Native `utilities.signal_type_detector` (generic). */
+export class SignalTypeDetector extends NativeProcedure {
+    methodId = "utilities.signal_type_detector";
+    paramTypes = {
+        confidence_threshold: "double",
+    };
+    constructor(params = {}) {
+        super();
+        this.params = { ...params };
+    }
+    run(X, y, inputs = {}) {
+        return this.runOutputs(X, y, inputs);
+    }
+}
+NativeMethod.register("utilities.signal_type_detector", SignalTypeDetector);
+/** Native `utilities.sweep` (generic). Required inputs: y. */
+export class Sweep extends NativeProcedure {
+    methodId = "utilities.sweep";
+    paramTypes = {
+        cv: "int",
+        ridge_lambdas: "double_array",
+        pls_components: "int_array",
+        heads: "enum",
+        center_x: "bool",
+        scale_x: "bool",
+        center_y: "bool",
+        scale_y: "bool",
+    };
+    constructor(params = {}) {
+        super();
+        this.params = { ...params };
+    }
+    run(X, y, inputs = {}) {
+        return this.runOutputs(X, y, inputs);
+    }
+}
+NativeMethod.register("utilities.sweep", Sweep);
+/** Native `utilities.transfer_metrics` (generic). Required inputs: target_domain. */
+export class TransferMetrics extends NativeProcedure {
+    methodId = "utilities.transfer_metrics";
+    paramTypes = {
+        n_components: "int",
+        k_neighbors: "int",
+        seed: "int",
+    };
+    constructor(params = {}) {
+        super();
+        this.params = { ...params };
+    }
+    run(X, y, inputs = {}) {
+        return this.runOutputs(X, y, inputs);
+    }
+}
+NativeMethod.register("utilities.transfer_metrics", TransferMetrics);