@elaraai/east-py-datascience 0.0.2-beta.1 → 0.0.2-beta.11

package/dist/sklearn/sklearn.d.ts

@@ -10,7 +10,7 @@
  *
  * @packageDocumentation
  */
-import { StructType, VariantType, OptionType, IntegerType, BooleanType, FloatType, BlobType, ArrayType, StringType } from "@elaraai/east";
+import { StructType, VariantType, OptionType, IntegerType, BooleanType, FloatType, BlobType, ArrayType, StringType, NullType } from "@elaraai/east";
 export { VectorType, MatrixType, LabelVectorType } from "../types.js";
 export { XGBoostConfigType } from "../xgboost/xgboost.js";
 export { LightGBMConfigType } from "../lightgbm/lightgbm.js";
@@ -27,6 +27,19 @@ export declare const SplitConfigType: StructType<{
     /** Whether to shuffle data before splitting (default true) */
     shuffle: OptionType<BooleanType>;
 }>;
+/**
+ * Configuration for 3-way train/val/test split.
+ */
+export declare const ThreeWaySplitConfigType: StructType<{
+    /** Proportion of data for validation (default 0.15) */
+    val_size: OptionType<FloatType>;
+    /** Proportion of data for test/holdout (default 0.15) */
+    test_size: OptionType<FloatType>;
+    /** Random seed for reproducibility */
+    random_state: OptionType<IntegerType>;
+    /** Whether to shuffle data before splitting (default true) */
+    shuffle: OptionType<BooleanType>;
+}>;
 /**
  * Result of train/test split.
  */
@@ -41,33 +54,365 @@ export declare const SplitResultType: StructType<{
     y_test: ArrayType<FloatType>;
 }>;
 /**
- * Regression metrics result.
+ * Result of 3-way train/val/test split.
+ */
+export declare const ThreeWaySplitResultType: StructType<{
+    /** Training features */
+    X_train: ArrayType<ArrayType<FloatType>>;
+    /** Validation features */
+    X_val: ArrayType<ArrayType<FloatType>>;
+    /** Test/holdout features */
+    X_test: ArrayType<ArrayType<FloatType>>;
+    /** Training targets (matrix) */
+    Y_train: ArrayType<ArrayType<FloatType>>;
+    /** Validation targets (matrix) */
+    Y_val: ArrayType<ArrayType<FloatType>>;
+    /** Test/holdout targets (matrix) */
+    Y_test: ArrayType<ArrayType<FloatType>>;
+}>;
+/**
+ * Available regression metrics from sklearn.metrics.
+ */
+export declare const RegressionMetricType: VariantType<{
+    /** Mean Squared Error - sklearn.metrics.mean_squared_error */
+    mse: NullType;
+    /** Root Mean Squared Error - sqrt(MSE) */
+    rmse: NullType;
+    /** Mean Absolute Error - sklearn.metrics.mean_absolute_error */
+    mae: NullType;
+    /** R² (coefficient of determination) - sklearn.metrics.r2_score */
+    r2: NullType;
+    /** Mean Absolute Percentage Error - sklearn.metrics.mean_absolute_percentage_error */
+    mape: NullType;
+    /** Explained Variance Score - sklearn.metrics.explained_variance_score */
+    explained_variance: NullType;
+    /** Max Error - sklearn.metrics.max_error */
+    max_error: NullType;
+    /** Median Absolute Error - sklearn.metrics.median_absolute_error */
+    median_ae: NullType;
+}>;
+/**
+ * Single metric result (scalar value).
+ */
+export declare const MetricResultType: StructType<{
+    /** Which metric was computed */
+    metric: VariantType<{
+        /** Mean Squared Error - sklearn.metrics.mean_squared_error */
+        mse: NullType;
+        /** Root Mean Squared Error - sqrt(MSE) */
+        rmse: NullType;
+        /** Mean Absolute Error - sklearn.metrics.mean_absolute_error */
+        mae: NullType;
+        /** R² (coefficient of determination) - sklearn.metrics.r2_score */
+        r2: NullType;
+        /** Mean Absolute Percentage Error - sklearn.metrics.mean_absolute_percentage_error */
+        mape: NullType;
+        /** Explained Variance Score - sklearn.metrics.explained_variance_score */
+        explained_variance: NullType;
+        /** Max Error - sklearn.metrics.max_error */
+        max_error: NullType;
+        /** Median Absolute Error - sklearn.metrics.median_absolute_error */
+        median_ae: NullType;
+    }>;
+    /** Scalar metric value */
+    value: FloatType;
+}>;
+/**
+ * Result containing multiple computed metrics.
+ */
+export declare const MetricsResultType: ArrayType<StructType<{
+    /** Which metric was computed */
+    metric: VariantType<{
+        /** Mean Squared Error - sklearn.metrics.mean_squared_error */
+        mse: NullType;
+        /** Root Mean Squared Error - sqrt(MSE) */
+        rmse: NullType;
+        /** Mean Absolute Error - sklearn.metrics.mean_absolute_error */
+        mae: NullType;
+        /** R² (coefficient of determination) - sklearn.metrics.r2_score */
+        r2: NullType;
+        /** Mean Absolute Percentage Error - sklearn.metrics.mean_absolute_percentage_error */
+        mape: NullType;
+        /** Explained Variance Score - sklearn.metrics.explained_variance_score */
+        explained_variance: NullType;
+        /** Max Error - sklearn.metrics.max_error */
+        max_error: NullType;
+        /** Median Absolute Error - sklearn.metrics.median_absolute_error */
+        median_ae: NullType;
+    }>;
+    /** Scalar metric value */
+    value: FloatType;
+}>>;
+/**
+ * Aggregation strategy for multi-target metrics.
+ */
+export declare const MetricAggregationType: VariantType<{
+    /** Return metric for each target separately (default) */
+    per_target: NullType;
+    /** Average across all targets (uniform weights) */
+    uniform_average: NullType;
+}>;
+/**
+ * Configuration for multi-target metrics computation.
+ */
+export declare const MultiMetricsConfigType: StructType<{
+    /** How to aggregate metrics across targets (default: per_target) */
+    aggregation: OptionType<VariantType<{
+        /** Return metric for each target separately (default) */
+        per_target: NullType;
+        /** Average across all targets (uniform weights) */
+        uniform_average: NullType;
+    }>>;
+}>;
+/**
+ * Multi-target metric result.
+ */
+export declare const MultiMetricResultType: StructType<{
+    /** Which metric was computed */
+    metric: VariantType<{
+        /** Mean Squared Error - sklearn.metrics.mean_squared_error */
+        mse: NullType;
+        /** Root Mean Squared Error - sqrt(MSE) */
+        rmse: NullType;
+        /** Mean Absolute Error - sklearn.metrics.mean_absolute_error */
+        mae: NullType;
+        /** R² (coefficient of determination) - sklearn.metrics.r2_score */
+        r2: NullType;
+        /** Mean Absolute Percentage Error - sklearn.metrics.mean_absolute_percentage_error */
+        mape: NullType;
+        /** Explained Variance Score - sklearn.metrics.explained_variance_score */
+        explained_variance: NullType;
+        /** Max Error - sklearn.metrics.max_error */
+        max_error: NullType;
+        /** Median Absolute Error - sklearn.metrics.median_absolute_error */
+        median_ae: NullType;
+    }>;
+    /** Metric value(s) */
+    value: VariantType<{
+        /** Aggregated scalar value */
+        scalar: FloatType;
+        /** Per-target values [target_0, target_1, ...] */
+        per_target: ArrayType<FloatType>;
+    }>;
+}>;
+/**
+ * Result containing multiple computed metrics (multi-target).
+ */
+export declare const MultiMetricsResultType: ArrayType<StructType<{
+    /** Which metric was computed */
+    metric: VariantType<{
+        /** Mean Squared Error - sklearn.metrics.mean_squared_error */
+        mse: NullType;
+        /** Root Mean Squared Error - sqrt(MSE) */
+        rmse: NullType;
+        /** Mean Absolute Error - sklearn.metrics.mean_absolute_error */
+        mae: NullType;
+        /** R² (coefficient of determination) - sklearn.metrics.r2_score */
+        r2: NullType;
+        /** Mean Absolute Percentage Error - sklearn.metrics.mean_absolute_percentage_error */
+        mape: NullType;
+        /** Explained Variance Score - sklearn.metrics.explained_variance_score */
+        explained_variance: NullType;
+        /** Max Error - sklearn.metrics.max_error */
+        max_error: NullType;
+        /** Median Absolute Error - sklearn.metrics.median_absolute_error */
+        median_ae: NullType;
+    }>;
+    /** Metric value(s) */
+    value: VariantType<{
+        /** Aggregated scalar value */
+        scalar: FloatType;
+        /** Per-target values [target_0, target_1, ...] */
+        per_target: ArrayType<FloatType>;
+    }>;
+}>>;
+/**
+ * Available classification metrics from sklearn.metrics.
+ */
+export declare const ClassificationMetricType: VariantType<{
+    /** Accuracy - sklearn.metrics.accuracy_score */
+    accuracy: NullType;
+    /** Balanced Accuracy - sklearn.metrics.balanced_accuracy_score */
+    balanced_accuracy: NullType;
+    /** Precision - sklearn.metrics.precision_score */
+    precision: NullType;
+    /** Recall - sklearn.metrics.recall_score */
+    recall: NullType;
+    /** F1 Score - sklearn.metrics.f1_score */
+    f1: NullType;
+    /** Matthews Correlation Coefficient - sklearn.metrics.matthews_corrcoef */
+    matthews_corrcoef: NullType;
+    /** Cohen's Kappa - sklearn.metrics.cohen_kappa_score */
+    cohen_kappa: NullType;
+    /** Jaccard Score - sklearn.metrics.jaccard_score */
+    jaccard: NullType;
+}>;
+/**
+ * Averaging strategy for multi-class classification metrics.
+ */
+export declare const ClassificationAverageType: VariantType<{
+    /** Calculate metrics for each label, return unweighted mean */
+    macro: NullType;
+    /** Calculate metrics globally by counting total TP, FP, FN */
+    micro: NullType;
+    /** Calculate metrics for each label, return weighted mean by support */
+    weighted: NullType;
+    /** Only for binary classification */
+    binary: NullType;
+}>;
+/**
+ * Configuration for classification metrics.
+ */
+export declare const ClassificationMetricsConfigType: StructType<{
+    /** Averaging strategy for multi-class (default: macro) */
+    average: OptionType<VariantType<{
+        /** Calculate metrics for each label, return unweighted mean */
+        macro: NullType;
+        /** Calculate metrics globally by counting total TP, FP, FN */
+        micro: NullType;
+        /** Calculate metrics for each label, return weighted mean by support */
+        weighted: NullType;
+        /** Only for binary classification */
+        binary: NullType;
+    }>>;
+}>;
+/**
+ * Single classification metric result.
+ */
+export declare const ClassificationMetricResultType: StructType<{
+    /** Which metric was computed */
+    metric: VariantType<{
+        /** Accuracy - sklearn.metrics.accuracy_score */
+        accuracy: NullType;
+        /** Balanced Accuracy - sklearn.metrics.balanced_accuracy_score */
+        balanced_accuracy: NullType;
+        /** Precision - sklearn.metrics.precision_score */
+        precision: NullType;
+        /** Recall - sklearn.metrics.recall_score */
+        recall: NullType;
+        /** F1 Score - sklearn.metrics.f1_score */
+        f1: NullType;
+        /** Matthews Correlation Coefficient - sklearn.metrics.matthews_corrcoef */
+        matthews_corrcoef: NullType;
+        /** Cohen's Kappa - sklearn.metrics.cohen_kappa_score */
+        cohen_kappa: NullType;
+        /** Jaccard Score - sklearn.metrics.jaccard_score */
+        jaccard: NullType;
+    }>;
+    /** Scalar metric value */
+    value: FloatType;
+}>;
+/**
+ * Result containing multiple computed classification metrics.
  */
-export declare const RegressionMetricsType: StructType<{
-    /** Mean Squared Error */
-    mse: FloatType;
-    /** Root Mean Squared Error */
-    rmse: FloatType;
-    /** Mean Absolute Error */
-    mae: FloatType;
-    /** R-squared (coefficient of determination) */
-    r2: FloatType;
-    /** Mean Absolute Percentage Error */
-    mape: FloatType;
+export declare const ClassificationMetricResultsType: ArrayType<StructType<{
+    /** Which metric was computed */
+    metric: VariantType<{
+        /** Accuracy - sklearn.metrics.accuracy_score */
+        accuracy: NullType;
+        /** Balanced Accuracy - sklearn.metrics.balanced_accuracy_score */
+        balanced_accuracy: NullType;
+        /** Precision - sklearn.metrics.precision_score */
+        precision: NullType;
+        /** Recall - sklearn.metrics.recall_score */
+        recall: NullType;
+        /** F1 Score - sklearn.metrics.f1_score */
+        f1: NullType;
+        /** Matthews Correlation Coefficient - sklearn.metrics.matthews_corrcoef */
+        matthews_corrcoef: NullType;
+        /** Cohen's Kappa - sklearn.metrics.cohen_kappa_score */
+        cohen_kappa: NullType;
+        /** Jaccard Score - sklearn.metrics.jaccard_score */
+        jaccard: NullType;
+    }>;
+    /** Scalar metric value */
+    value: FloatType;
+}>>;
+/**
+ * Configuration for multi-target classification metrics.
+ */
+export declare const MultiClassificationConfigType: StructType<{
+    /** Averaging strategy for multi-class (default: macro) */
+    average: OptionType<VariantType<{
+        /** Calculate metrics for each label, return unweighted mean */
+        macro: NullType;
+        /** Calculate metrics globally by counting total TP, FP, FN */
+        micro: NullType;
+        /** Calculate metrics for each label, return weighted mean by support */
+        weighted: NullType;
+        /** Only for binary classification */
+        binary: NullType;
+    }>>;
+    /** How to aggregate across targets (default: per_target) */
+    aggregation: OptionType<VariantType<{
+        /** Return metric for each target separately (default) */
+        per_target: NullType;
+        /** Average across all targets (uniform weights) */
+        uniform_average: NullType;
+    }>>;
 }>;
 /**
- * Classification metrics result.
+ * Multi-target classification metric result.
  */
-export declare const ClassificationMetricsType: StructType<{
-    /** Accuracy score */
-    accuracy: FloatType;
-    /** Precision (weighted average) */
-    precision: FloatType;
-    /** Recall (weighted average) */
-    recall: FloatType;
-    /** F1 score (weighted average) */
-    f1: FloatType;
+export declare const MultiClassificationMetricResultType: StructType<{
+    /** Which metric was computed */
+    metric: VariantType<{
+        /** Accuracy - sklearn.metrics.accuracy_score */
+        accuracy: NullType;
+        /** Balanced Accuracy - sklearn.metrics.balanced_accuracy_score */
+        balanced_accuracy: NullType;
+        /** Precision - sklearn.metrics.precision_score */
+        precision: NullType;
+        /** Recall - sklearn.metrics.recall_score */
+        recall: NullType;
+        /** F1 Score - sklearn.metrics.f1_score */
+        f1: NullType;
+        /** Matthews Correlation Coefficient - sklearn.metrics.matthews_corrcoef */
+        matthews_corrcoef: NullType;
+        /** Cohen's Kappa - sklearn.metrics.cohen_kappa_score */
+        cohen_kappa: NullType;
+        /** Jaccard Score - sklearn.metrics.jaccard_score */
+        jaccard: NullType;
+    }>;
+    /** Metric value(s) */
+    value: VariantType<{
+        /** Aggregated scalar value */
+        scalar: FloatType;
+        /** Per-target values */
+        per_target: ArrayType<FloatType>;
+    }>;
 }>;
+/**
+ * Result containing multiple computed classification metrics (multi-target).
+ */
+export declare const MultiClassificationMetricResultsType: ArrayType<StructType<{
+    /** Which metric was computed */
+    metric: VariantType<{
+        /** Accuracy - sklearn.metrics.accuracy_score */
+        accuracy: NullType;
+        /** Balanced Accuracy - sklearn.metrics.balanced_accuracy_score */
+        balanced_accuracy: NullType;
+        /** Precision - sklearn.metrics.precision_score */
+        precision: NullType;
+        /** Recall - sklearn.metrics.recall_score */
+        recall: NullType;
+        /** F1 Score - sklearn.metrics.f1_score */
+        f1: NullType;
+        /** Matthews Correlation Coefficient - sklearn.metrics.matthews_corrcoef */
+        matthews_corrcoef: NullType;
+        /** Cohen's Kappa - sklearn.metrics.cohen_kappa_score */
+        cohen_kappa: NullType;
+        /** Jaccard Score - sklearn.metrics.jaccard_score */
+        jaccard: NullType;
+    }>;
+    /** Metric value(s) */
+    value: VariantType<{
+        /** Aggregated scalar value */
+        scalar: FloatType;
+        /** Per-target values */
+        per_target: ArrayType<FloatType>;
+    }>;
+}>>;
 /**
  * Model blob type for serialized sklearn models.
  *
@@ -117,6 +462,7 @@ export declare const RegressorChainBaseConfigType: VariantType<{
         reg_lambda: OptionType<FloatType>;
         random_state: OptionType<IntegerType>;
         n_jobs: OptionType<IntegerType>;
+        sample_weight: OptionType<ArrayType<FloatType>>;
     }>;
     /** LightGBM regressor */
     lightgbm: StructType<{
@@ -140,19 +486,19 @@ export declare const RegressorChainBaseConfigType: VariantType<{
         col_sample: OptionType<FloatType>;
         random_state: OptionType<IntegerType>;
         distribution: OptionType<VariantType<{
-            normal: StructType<{}>;
-            lognormal: StructType<{}>;
+            normal: NullType;
+            lognormal: NullType;
         }>>;
     }>;
     /** Gaussian Process regressor */
     gp: StructType<{
         kernel: OptionType<VariantType<{
-            rbf: StructType<{}>;
-            matern_1_2: StructType<{}>;
-            matern_3_2: StructType<{}>;
-            matern_5_2: StructType<{}>;
-            rational_quadratic: StructType<{}>;
-            dot_product: StructType<{}>;
+            rbf: NullType;
+            matern_1_2: NullType;
+            matern_3_2: NullType;
+            matern_5_2: NullType;
+            rational_quadratic: NullType;
+            dot_product: NullType;
         }>>;
         alpha: OptionType<FloatType>;
         n_restarts_optimizer: OptionType<IntegerType>;
@@ -178,6 +524,7 @@ export declare const RegressorChainConfigType: StructType<{
             reg_lambda: OptionType<FloatType>;
             random_state: OptionType<IntegerType>;
             n_jobs: OptionType<IntegerType>;
+            sample_weight: OptionType<ArrayType<FloatType>>;
         }>;
         /** LightGBM regressor */
         lightgbm: StructType<{
@@ -201,19 +548,19 @@ export declare const RegressorChainConfigType: StructType<{
             col_sample: OptionType<FloatType>;
             random_state: OptionType<IntegerType>;
             distribution: OptionType<VariantType<{
-                normal: StructType<{}>;
-                lognormal: StructType<{}>;
+                normal: NullType;
+                lognormal: NullType;
             }>>;
         }>;
         /** Gaussian Process regressor */
         gp: StructType<{
             kernel: OptionType<VariantType<{
-                rbf: StructType<{}>;
-                matern_1_2: StructType<{}>;
-                matern_3_2: StructType<{}>;
-                matern_5_2: StructType<{}>;
-                rational_quadratic: StructType<{}>;
-                dot_product: StructType<{}>;
+                rbf: NullType;
+                matern_1_2: NullType;
+                matern_3_2: NullType;
+                matern_5_2: NullType;
+                rational_quadratic: NullType;
+                dot_product: NullType;
             }>>;
             alpha: OptionType<FloatType>;
             n_restarts_optimizer: OptionType<IntegerType>;
@@ -389,46 +736,6 @@ export declare const sklearn_min_max_scaler_transform: import("@elaraai/east").P
         base_estimator_type: StringType;
     }>;
 }>, ArrayType<ArrayType<FloatType>>], ArrayType<ArrayType<FloatType>>>;
-/**
- * Compute regression metrics.
- *
- * @param y_true - True target values
- * @param y_pred - Predicted target values
- * @returns Regression metrics (MSE, RMSE, MAE, R2, MAPE)
- */
-export declare const sklearn_metrics_regression: import("@elaraai/east").PlatformDefinition<[ArrayType<FloatType>, ArrayType<FloatType>], StructType<{
-    /** Mean Squared Error */
-    mse: FloatType;
-    /** Root Mean Squared Error */
-    rmse: FloatType;
-    /** Mean Absolute Error */
-    mae: FloatType;
-    /** R-squared (coefficient of determination) */
-    r2: FloatType;
-    /** Mean Absolute Percentage Error */
-    mape: FloatType;
-}>>;
-/**
- * Compute classification metrics.
- *
- * @param y_true - True class labels
- * @param y_pred - Predicted class labels
- * @returns Classification metrics (accuracy, precision, recall, F1)
- */
-export declare const sklearn_metrics_classification: import("@elaraai/east").PlatformDefinition<[ArrayType<IntegerType>, ArrayType<IntegerType>], StructType<{
-    /** Accuracy score */
-    accuracy: FloatType;
-    /** Precision (weighted average) */
-    precision: FloatType;
-    /** Recall (weighted average) */
-    recall: FloatType;
-    /** F1 score (weighted average) */
-    f1: FloatType;
-}>>;
-/**
- * Multi-target output type for RegressorChain.
- */
-export declare const MultiTargetType: ArrayType<ArrayType<FloatType>>;
 /**
  * Train a RegressorChain for multi-target regression.
  *
@@ -455,6 +762,7 @@ export declare const sklearn_regressor_chain_train: import("@elaraai/east").Plat
             reg_lambda: OptionType<FloatType>;
             random_state: OptionType<IntegerType>;
             n_jobs: OptionType<IntegerType>;
+            sample_weight: OptionType<ArrayType<FloatType>>;
         }>;
         /** LightGBM regressor */
         lightgbm: StructType<{
@@ -478,19 +786,19 @@ export declare const sklearn_regressor_chain_train: import("@elaraai/east").Plat
             col_sample: OptionType<FloatType>;
             random_state: OptionType<IntegerType>;
             distribution: OptionType<VariantType<{
-                normal: StructType<{}>;
-                lognormal: StructType<{}>;
+                normal: NullType;
+                lognormal: NullType;
             }>>;
         }>;
         /** Gaussian Process regressor */
         gp: StructType<{
             kernel: OptionType<VariantType<{
-                rbf: StructType<{}>;
-                matern_1_2: StructType<{}>;
-                matern_3_2: StructType<{}>;
-                matern_5_2: StructType<{}>;
-                rational_quadratic: StructType<{}>;
-                dot_product: StructType<{}>;
+                rbf: NullType;
+                matern_1_2: NullType;
+                matern_3_2: NullType;
+                matern_5_2: NullType;
+                rational_quadratic: NullType;
+                dot_product: NullType;
             }>>;
             alpha: OptionType<FloatType>;
             n_restarts_optimizer: OptionType<IntegerType>;
@@ -563,6 +871,281 @@ export declare const sklearn_regressor_chain_predict: import("@elaraai/east").Pl
         base_estimator_type: StringType;
     }>;
 }>, ArrayType<ArrayType<FloatType>>], ArrayType<ArrayType<FloatType>>>;
+/**
+ * Split arrays into train, validation, and test subsets.
+ *
+ * @param X - Feature matrix
+ * @param Y - Target matrix (multi-target)
+ * @param config - Split configuration with val_size and test_size
+ * @returns Split result with X_train, X_val, X_test, Y_train, Y_val, Y_test
+ */
+export declare const sklearn_train_val_test_split: import("@elaraai/east").PlatformDefinition<[ArrayType<ArrayType<FloatType>>, ArrayType<ArrayType<FloatType>>, StructType<{
+    /** Proportion of data for validation (default 0.15) */
+    val_size: OptionType<FloatType>;
+    /** Proportion of data for test/holdout (default 0.15) */
+    test_size: OptionType<FloatType>;
+    /** Random seed for reproducibility */
+    random_state: OptionType<IntegerType>;
+    /** Whether to shuffle data before splitting (default true) */
+    shuffle: OptionType<BooleanType>;
+}>], StructType<{
+    /** Training features */
+    X_train: ArrayType<ArrayType<FloatType>>;
+    /** Validation features */
+    X_val: ArrayType<ArrayType<FloatType>>;
+    /** Test/holdout features */
+    X_test: ArrayType<ArrayType<FloatType>>;
+    /** Training targets (matrix) */
+    Y_train: ArrayType<ArrayType<FloatType>>;
+    /** Validation targets (matrix) */
+    Y_val: ArrayType<ArrayType<FloatType>>;
+    /** Test/holdout targets (matrix) */
+    Y_test: ArrayType<ArrayType<FloatType>>;
+}>>;
+/**
+ * Compute regression metrics for single-target predictions.
+ *
+ * @param y_true - True target values (1D vector)
+ * @param y_pred - Predicted target values (1D vector)
+ * @param metrics - Array of metrics to compute
+ * @returns Array of metric results with scalar values
+ */
+export declare const sklearn_compute_metrics: import("@elaraai/east").PlatformDefinition<[ArrayType<FloatType>, ArrayType<FloatType>, ArrayType<VariantType<{
+    /** Mean Squared Error - sklearn.metrics.mean_squared_error */
+    mse: NullType;
+    /** Root Mean Squared Error - sqrt(MSE) */
+    rmse: NullType;
+    /** Mean Absolute Error - sklearn.metrics.mean_absolute_error */
+    mae: NullType;
+    /** R² (coefficient of determination) - sklearn.metrics.r2_score */
+    r2: NullType;
+    /** Mean Absolute Percentage Error - sklearn.metrics.mean_absolute_percentage_error */
+    mape: NullType;
+    /** Explained Variance Score - sklearn.metrics.explained_variance_score */
+    explained_variance: NullType;
+    /** Max Error - sklearn.metrics.max_error */
+    max_error: NullType;
+    /** Median Absolute Error - sklearn.metrics.median_absolute_error */
+    median_ae: NullType;
+}>>], ArrayType<StructType<{
+    /** Which metric was computed */
+    metric: VariantType<{
+        /** Mean Squared Error - sklearn.metrics.mean_squared_error */
+        mse: NullType;
+        /** Root Mean Squared Error - sqrt(MSE) */
+        rmse: NullType;
+        /** Mean Absolute Error - sklearn.metrics.mean_absolute_error */
+        mae: NullType;
+        /** R² (coefficient of determination) - sklearn.metrics.r2_score */
+        r2: NullType;
+        /** Mean Absolute Percentage Error - sklearn.metrics.mean_absolute_percentage_error */
+        mape: NullType;
+        /** Explained Variance Score - sklearn.metrics.explained_variance_score */
+        explained_variance: NullType;
+        /** Max Error - sklearn.metrics.max_error */
+        max_error: NullType;
+        /** Median Absolute Error - sklearn.metrics.median_absolute_error */
+        median_ae: NullType;
+    }>;
+    /** Scalar metric value */
+    value: FloatType;
+}>>>;
+/**
+ * Compute regression metrics for multi-target predictions.
+ *
+ * @param Y_true - True target matrix [n_samples, n_targets]
+ * @param Y_pred - Predicted target matrix [n_samples, n_targets]
+ * @param metrics - Array of metrics to compute
+ * @param config - Aggregation configuration
+ * @returns Array of metric results with per-target or aggregated values
+ */
+export declare const sklearn_compute_metrics_multi: import("@elaraai/east").PlatformDefinition<[ArrayType<ArrayType<FloatType>>, ArrayType<ArrayType<FloatType>>, ArrayType<VariantType<{
+    /** Mean Squared Error - sklearn.metrics.mean_squared_error */
+    mse: NullType;
+    /** Root Mean Squared Error - sqrt(MSE) */
+    rmse: NullType;
+    /** Mean Absolute Error - sklearn.metrics.mean_absolute_error */
+    mae: NullType;
+    /** R² (coefficient of determination) - sklearn.metrics.r2_score */
+    r2: NullType;
+    /** Mean Absolute Percentage Error - sklearn.metrics.mean_absolute_percentage_error */
+    mape: NullType;
+    /** Explained Variance Score - sklearn.metrics.explained_variance_score */
+    explained_variance: NullType;
+    /** Max Error - sklearn.metrics.max_error */
+    max_error: NullType;
+    /** Median Absolute Error - sklearn.metrics.median_absolute_error */
+    median_ae: NullType;
+}>>, StructType<{
+    /** How to aggregate metrics across targets (default: per_target) */
+    aggregation: OptionType<VariantType<{
+        /** Return metric for each target separately (default) */
+        per_target: NullType;
+        /** Average across all targets (uniform weights) */
+        uniform_average: NullType;
+    }>>;
+}>], ArrayType<StructType<{
+    /** Which metric was computed */
+    metric: VariantType<{
+        /** Mean Squared Error - sklearn.metrics.mean_squared_error */
+        mse: NullType;
+        /** Root Mean Squared Error - sqrt(MSE) */
+        rmse: NullType;
+        /** Mean Absolute Error - sklearn.metrics.mean_absolute_error */
+        mae: NullType;
+        /** R² (coefficient of determination) - sklearn.metrics.r2_score */
+        r2: NullType;
+        /** Mean Absolute Percentage Error - sklearn.metrics.mean_absolute_percentage_error */
+        mape: NullType;
+        /** Explained Variance Score - sklearn.metrics.explained_variance_score */
+        explained_variance: NullType;
+        /** Max Error - sklearn.metrics.max_error */
+        max_error: NullType;
+        /** Median Absolute Error - sklearn.metrics.median_absolute_error */
+        median_ae: NullType;
+    }>;
+    /** Metric value(s) */
+    value: VariantType<{
+        /** Aggregated scalar value */
+        scalar: FloatType;
+        /** Per-target values [target_0, target_1, ...] */
+        per_target: ArrayType<FloatType>;
+    }>;
+}>>>;
+/**
+ * Compute classification metrics for single-target predictions.
+ *
+ * @param y_true - True class labels (1D integer array)
+ * @param y_pred - Predicted class labels (1D integer array)
+ * @param metrics - Array of metrics to compute
+ * @param config - Configuration (averaging strategy)
+ * @returns Array of metric results with scalar values
+ */
+export declare const sklearn_compute_classification_metrics: import("@elaraai/east").PlatformDefinition<[ArrayType<IntegerType>, ArrayType<IntegerType>, ArrayType<VariantType<{
+    /** Accuracy - sklearn.metrics.accuracy_score */
+    accuracy: NullType;
+    /** Balanced Accuracy - sklearn.metrics.balanced_accuracy_score */
+    balanced_accuracy: NullType;
+    /** Precision - sklearn.metrics.precision_score */
+    precision: NullType;
+    /** Recall - sklearn.metrics.recall_score */
+    recall: NullType;
+    /** F1 Score - sklearn.metrics.f1_score */
+    f1: NullType;
+    /** Matthews Correlation Coefficient - sklearn.metrics.matthews_corrcoef */
+    matthews_corrcoef: NullType;
+    /** Cohen's Kappa - sklearn.metrics.cohen_kappa_score */
+    cohen_kappa: NullType;
+    /** Jaccard Score - sklearn.metrics.jaccard_score */
+    jaccard: NullType;
+}>>, StructType<{
+    /** Averaging strategy for multi-class (default: macro) */
+    average: OptionType<VariantType<{
+        /** Calculate metrics for each label, return unweighted mean */
+        macro: NullType;
+        /** Calculate metrics globally by counting total TP, FP, FN */
+        micro: NullType;
+        /** Calculate metrics for each label, return weighted mean by support */
+        weighted: NullType;
+        /** Only for binary classification */
+        binary: NullType;
+    }>>;
+}>], ArrayType<StructType<{
+    /** Which metric was computed */
+    metric: VariantType<{
+        /** Accuracy - sklearn.metrics.accuracy_score */
+        accuracy: NullType;
+        /** Balanced Accuracy - sklearn.metrics.balanced_accuracy_score */
+        balanced_accuracy: NullType;
+        /** Precision - sklearn.metrics.precision_score */
+        precision: NullType;
+        /** Recall - sklearn.metrics.recall_score */
+        recall: NullType;
+        /** F1 Score - sklearn.metrics.f1_score */
+        f1: NullType;
+        /** Matthews Correlation Coefficient - sklearn.metrics.matthews_corrcoef */
+        matthews_corrcoef: NullType;
+        /** Cohen's Kappa - sklearn.metrics.cohen_kappa_score */
+        cohen_kappa: NullType;
+        /** Jaccard Score - sklearn.metrics.jaccard_score */
+        jaccard: NullType;
+    }>;
+    /** Scalar metric value */
+    value: FloatType;
+}>>>;
+/**
+ * Compute classification metrics for multi-target predictions.
+ *
+ * @param Y_true - True class labels matrix [n_samples, n_targets]
+ * @param Y_pred - Predicted class labels matrix [n_samples, n_targets]
+ * @param metrics - Array of metrics to compute
+ * @param config - Configuration (averaging, aggregation)
+ * @returns Array of metric results with per-target or aggregated values
+ */
+export declare const sklearn_compute_classification_metrics_multi: import("@elaraai/east").PlatformDefinition<[ArrayType<ArrayType<FloatType>>, ArrayType<ArrayType<FloatType>>, ArrayType<VariantType<{
+    /** Accuracy - sklearn.metrics.accuracy_score */
+    accuracy: NullType;
+    /** Balanced Accuracy - sklearn.metrics.balanced_accuracy_score */
+    balanced_accuracy: NullType;
+    /** Precision - sklearn.metrics.precision_score */
+    precision: NullType;
+    /** Recall - sklearn.metrics.recall_score */
+    recall: NullType;
+    /** F1 Score - sklearn.metrics.f1_score */
+    f1: NullType;
+    /** Matthews Correlation Coefficient - sklearn.metrics.matthews_corrcoef */
+    matthews_corrcoef: NullType;
+    /** Cohen's Kappa - sklearn.metrics.cohen_kappa_score */
+    cohen_kappa: NullType;
+    /** Jaccard Score - sklearn.metrics.jaccard_score */
+    jaccard: NullType;
+}>>, StructType<{
+    /** Averaging strategy for multi-class (default: macro) */
+    average: OptionType<VariantType<{
+        /** Calculate metrics for each label, return unweighted mean */
+        macro: NullType;
+        /** Calculate metrics globally by counting total TP, FP, FN */
+        micro: NullType;
+        /** Calculate metrics for each label, return weighted mean by support */
+        weighted: NullType;
+        /** Only for binary classification */
+        binary: NullType;
+    }>>;
+    /** How to aggregate across targets (default: per_target) */
+    aggregation: OptionType<VariantType<{
+        /** Return metric for each target separately (default) */
+        per_target: NullType;
+        /** Average across all targets (uniform weights) */
+        uniform_average: NullType;
+    }>>;
+}>], ArrayType<StructType<{
+    /** Which metric was computed */
+    metric: VariantType<{
+        /** Accuracy - sklearn.metrics.accuracy_score */
+        accuracy: NullType;
+        /** Balanced Accuracy - sklearn.metrics.balanced_accuracy_score */
+        balanced_accuracy: NullType;
+        /** Precision - sklearn.metrics.precision_score */
+        precision: NullType;
+        /** Recall - sklearn.metrics.recall_score */
+        recall: NullType;
+        /** F1 Score - sklearn.metrics.f1_score */
+        f1: NullType;
+        /** Matthews Correlation Coefficient - sklearn.metrics.matthews_corrcoef */
+        matthews_corrcoef: NullType;
+        /** Cohen's Kappa - sklearn.metrics.cohen_kappa_score */
+        cohen_kappa: NullType;
+        /** Jaccard Score - sklearn.metrics.jaccard_score */
+        jaccard: NullType;
+    }>;
+    /** Metric value(s) */
+    value: VariantType<{
+        /** Aggregated scalar value */
+        scalar: FloatType;
+        /** Per-target values */
+        per_target: ArrayType<FloatType>;
+    }>;
+}>>>;
 /**
  * Type definitions for sklearn functions.
  */
@@ -593,29 +1176,31 @@ export declare const SklearnTypes: {
         /** Test labels */
         y_test: ArrayType<FloatType>;
     }>;
-    /** Regression metrics type */
-    readonly RegressionMetricsType: StructType<{
-        /** Mean Squared Error */
-        mse: FloatType;
-        /** Root Mean Squared Error */
-        rmse: FloatType;
-        /** Mean Absolute Error */
-        mae: FloatType;
-        /** R-squared (coefficient of determination) */
-        r2: FloatType;
-        /** Mean Absolute Percentage Error */
-        mape: FloatType;
+    /** 3-way split configuration type */
+    readonly ThreeWaySplitConfigType: StructType<{
+        /** Proportion of data for validation (default 0.15) */
+        val_size: OptionType<FloatType>;
+        /** Proportion of data for test/holdout (default 0.15) */
+        test_size: OptionType<FloatType>;
+        /** Random seed for reproducibility */
+        random_state: OptionType<IntegerType>;
+        /** Whether to shuffle data before splitting (default true) */
+        shuffle: OptionType<BooleanType>;
     }>;
-    /** Classification metrics type */
-    readonly ClassificationMetricsType: StructType<{
-        /** Accuracy score */
-        accuracy: FloatType;
-        /** Precision (weighted average) */
-        precision: FloatType;
-        /** Recall (weighted average) */
-        recall: FloatType;
-        /** F1 score (weighted average) */
-        f1: FloatType;
+    /** 3-way split result type */
+    readonly ThreeWaySplitResultType: StructType<{
+        /** Training features */
+        X_train: ArrayType<ArrayType<FloatType>>;
+        /** Validation features */
+        X_val: ArrayType<ArrayType<FloatType>>;
+        /** Test/holdout features */
+        X_test: ArrayType<ArrayType<FloatType>>;
+        /** Training targets (matrix) */
+        Y_train: ArrayType<ArrayType<FloatType>>;
+        /** Validation targets (matrix) */
+        Y_val: ArrayType<ArrayType<FloatType>>;
+        /** Test/holdout targets (matrix) */
+        Y_test: ArrayType<ArrayType<FloatType>>;
     }>;
     /** Model blob type for sklearn models */
     readonly ModelBlobType: VariantType<{
@@ -645,8 +1230,6 @@ export declare const SklearnTypes: {
             base_estimator_type: StringType;
         }>;
     }>;
-    /** Multi-target output type */
-    readonly MultiTargetType: ArrayType<ArrayType<FloatType>>;
     /** RegressorChain base estimator config type */
     readonly RegressorChainBaseConfigType: VariantType<{
         /** XGBoost regressor */
@@ -661,6 +1244,7 @@ export declare const SklearnTypes: {
             reg_lambda: OptionType<FloatType>;
             random_state: OptionType<IntegerType>;
             n_jobs: OptionType<IntegerType>;
+            sample_weight: OptionType<ArrayType<FloatType>>;
         }>;
         /** LightGBM regressor */
         lightgbm: StructType<{
@@ -684,19 +1268,19 @@ export declare const SklearnTypes: {
             col_sample: OptionType<FloatType>;
             random_state: OptionType<IntegerType>;
             distribution: OptionType<VariantType<{
-                normal: StructType<{}>;
-                lognormal: StructType<{}>;
+                normal: NullType;
+                lognormal: NullType;
             }>>;
         }>;
         /** Gaussian Process regressor */
         gp: StructType<{
             kernel: OptionType<VariantType<{
-                rbf: StructType<{}>;
-                matern_1_2: StructType<{}>;
-                matern_3_2: StructType<{}>;
-                matern_5_2: StructType<{}>;
-                rational_quadratic: StructType<{}>;
-                dot_product: StructType<{}>;
+                rbf: NullType;
+                matern_1_2: NullType;
+                matern_3_2: NullType;
+                matern_5_2: NullType;
+                rational_quadratic: NullType;
+                dot_product: NullType;
             }>>;
             alpha: OptionType<FloatType>;
             n_restarts_optimizer: OptionType<IntegerType>;
@@ -720,6 +1304,7 @@ export declare const SklearnTypes: {
                 reg_lambda: OptionType<FloatType>;
                 random_state: OptionType<IntegerType>;
                 n_jobs: OptionType<IntegerType>;
+                sample_weight: OptionType<ArrayType<FloatType>>;
             }>;
             /** LightGBM regressor */
             lightgbm: StructType<{
@@ -743,19 +1328,19 @@ export declare const SklearnTypes: {
                 col_sample: OptionType<FloatType>;
                 random_state: OptionType<IntegerType>;
                 distribution: OptionType<VariantType<{
-                    normal: StructType<{}>;
-                    lognormal: StructType<{}>;
+                    normal: NullType;
+                    lognormal: NullType;
                 }>>;
             }>;
             /** Gaussian Process regressor */
             gp: StructType<{
                 kernel: OptionType<VariantType<{
-                    rbf: StructType<{}>;
-                    matern_1_2: StructType<{}>;
-                    matern_3_2: StructType<{}>;
-                    matern_5_2: StructType<{}>;
-                    rational_quadratic: StructType<{}>;
-                    dot_product: StructType<{}>;
+                    rbf: NullType;
+                    matern_1_2: NullType;
+                    matern_3_2: NullType;
+                    matern_5_2: NullType;
+                    rational_quadratic: NullType;
+                    dot_product: NullType;
                 }>>;
                 alpha: OptionType<FloatType>;
                 n_restarts_optimizer: OptionType<IntegerType>;
@@ -768,6 +1353,319 @@ export declare const SklearnTypes: {
         /** Random seed for reproducibility */
         random_state: OptionType<IntegerType>;
     }>;
+    /** Regression metric variant */
+    readonly RegressionMetricType: VariantType<{
+        /** Mean Squared Error - sklearn.metrics.mean_squared_error */
+        mse: NullType;
+        /** Root Mean Squared Error - sqrt(MSE) */
+        rmse: NullType;
+        /** Mean Absolute Error - sklearn.metrics.mean_absolute_error */
+        mae: NullType;
+        /** R² (coefficient of determination) - sklearn.metrics.r2_score */
+        r2: NullType;
+        /** Mean Absolute Percentage Error - sklearn.metrics.mean_absolute_percentage_error */
+        mape: NullType;
+        /** Explained Variance Score - sklearn.metrics.explained_variance_score */
+        explained_variance: NullType;
+        /** Max Error - sklearn.metrics.max_error */
+        max_error: NullType;
+        /** Median Absolute Error - sklearn.metrics.median_absolute_error */
+        median_ae: NullType;
+    }>;
+    /** Single metric result */
+    readonly MetricResultType: StructType<{
+        /** Which metric was computed */
+        metric: VariantType<{
+            /** Mean Squared Error - sklearn.metrics.mean_squared_error */
+            mse: NullType;
+            /** Root Mean Squared Error - sqrt(MSE) */
+            rmse: NullType;
+            /** Mean Absolute Error - sklearn.metrics.mean_absolute_error */
+            mae: NullType;
+            /** R² (coefficient of determination) - sklearn.metrics.r2_score */
+            r2: NullType;
+            /** Mean Absolute Percentage Error - sklearn.metrics.mean_absolute_percentage_error */
+            mape: NullType;
+            /** Explained Variance Score - sklearn.metrics.explained_variance_score */
+            explained_variance: NullType;
+            /** Max Error - sklearn.metrics.max_error */
+            max_error: NullType;
+            /** Median Absolute Error - sklearn.metrics.median_absolute_error */
+            median_ae: NullType;
+        }>;
+        /** Scalar metric value */
+        value: FloatType;
+    }>;
+    /** Multiple metrics result */
+    readonly MetricsResultType: ArrayType<StructType<{
+        /** Which metric was computed */
+        metric: VariantType<{
+            /** Mean Squared Error - sklearn.metrics.mean_squared_error */
+            mse: NullType;
+            /** Root Mean Squared Error - sqrt(MSE) */
+            rmse: NullType;
+            /** Mean Absolute Error - sklearn.metrics.mean_absolute_error */
+            mae: NullType;
+            /** R² (coefficient of determination) - sklearn.metrics.r2_score */
+            r2: NullType;
+            /** Mean Absolute Percentage Error - sklearn.metrics.mean_absolute_percentage_error */
+            mape: NullType;
+            /** Explained Variance Score - sklearn.metrics.explained_variance_score */
+            explained_variance: NullType;
+            /** Max Error - sklearn.metrics.max_error */
+            max_error: NullType;
+            /** Median Absolute Error - sklearn.metrics.median_absolute_error */
+            median_ae: NullType;
+        }>;
+        /** Scalar metric value */
+        value: FloatType;
+    }>>;
+    /** Metric aggregation type */
+    readonly MetricAggregationType: VariantType<{
+        /** Return metric for each target separately (default) */
+        per_target: NullType;
+        /** Average across all targets (uniform weights) */
+        uniform_average: NullType;
+    }>;
+    /** Multi-target metrics config */
+    readonly MultiMetricsConfigType: StructType<{
+        /** How to aggregate metrics across targets (default: per_target) */
+        aggregation: OptionType<VariantType<{
+            /** Return metric for each target separately (default) */
+            per_target: NullType;
+            /** Average across all targets (uniform weights) */
+            uniform_average: NullType;
+        }>>;
+    }>;
+    /** Multi-target metric result */
+    readonly MultiMetricResultType: StructType<{
+        /** Which metric was computed */
+        metric: VariantType<{
+            /** Mean Squared Error - sklearn.metrics.mean_squared_error */
+            mse: NullType;
+            /** Root Mean Squared Error - sqrt(MSE) */
+            rmse: NullType;
+            /** Mean Absolute Error - sklearn.metrics.mean_absolute_error */
+            mae: NullType;
+            /** R² (coefficient of determination) - sklearn.metrics.r2_score */
+            r2: NullType;
+            /** Mean Absolute Percentage Error - sklearn.metrics.mean_absolute_percentage_error */
+            mape: NullType;
+            /** Explained Variance Score - sklearn.metrics.explained_variance_score */
+            explained_variance: NullType;
+            /** Max Error - sklearn.metrics.max_error */
+            max_error: NullType;
+            /** Median Absolute Error - sklearn.metrics.median_absolute_error */
+            median_ae: NullType;
+        }>;
+        /** Metric value(s) */
+        value: VariantType<{
+            /** Aggregated scalar value */
+            scalar: FloatType;
+            /** Per-target values [target_0, target_1, ...] */
+            per_target: ArrayType<FloatType>;
+        }>;
+    }>;
+    /** Multi-target metrics result */
+    readonly MultiMetricsResultType: ArrayType<StructType<{
+        /** Which metric was computed */
+        metric: VariantType<{
+            /** Mean Squared Error - sklearn.metrics.mean_squared_error */
+            mse: NullType;
+            /** Root Mean Squared Error - sqrt(MSE) */
+            rmse: NullType;
+            /** Mean Absolute Error - sklearn.metrics.mean_absolute_error */
+            mae: NullType;
+            /** R² (coefficient of determination) - sklearn.metrics.r2_score */
+            r2: NullType;
+            /** Mean Absolute Percentage Error - sklearn.metrics.mean_absolute_percentage_error */
+            mape: NullType;
+            /** Explained Variance Score - sklearn.metrics.explained_variance_score */
+            explained_variance: NullType;
+            /** Max Error - sklearn.metrics.max_error */
+            max_error: NullType;
+            /** Median Absolute Error - sklearn.metrics.median_absolute_error */
+            median_ae: NullType;
+        }>;
+        /** Metric value(s) */
+        value: VariantType<{
+            /** Aggregated scalar value */
+            scalar: FloatType;
+            /** Per-target values [target_0, target_1, ...] */
+            per_target: ArrayType<FloatType>;
+        }>;
+    }>>;
+    /** Classification metric variant */
+    readonly ClassificationMetricType: VariantType<{
+        /** Accuracy - sklearn.metrics.accuracy_score */
+        accuracy: NullType;
+        /** Balanced Accuracy - sklearn.metrics.balanced_accuracy_score */
+        balanced_accuracy: NullType;
+        /** Precision - sklearn.metrics.precision_score */
+        precision: NullType;
+        /** Recall - sklearn.metrics.recall_score */
+        recall: NullType;
+        /** F1 Score - sklearn.metrics.f1_score */
+        f1: NullType;
+        /** Matthews Correlation Coefficient - sklearn.metrics.matthews_corrcoef */
+        matthews_corrcoef: NullType;
+        /** Cohen's Kappa - sklearn.metrics.cohen_kappa_score */
+        cohen_kappa: NullType;
+        /** Jaccard Score - sklearn.metrics.jaccard_score */
+        jaccard: NullType;
+    }>;
+    /** Classification averaging type */
+    readonly ClassificationAverageType: VariantType<{
+        /** Calculate metrics for each label, return unweighted mean */
+        macro: NullType;
+        /** Calculate metrics globally by counting total TP, FP, FN */
+        micro: NullType;
+        /** Calculate metrics for each label, return weighted mean by support */
+        weighted: NullType;
+        /** Only for binary classification */
+        binary: NullType;
+    }>;
+    /** Classification metrics config */
+    readonly ClassificationMetricsConfigType: StructType<{
+        /** Averaging strategy for multi-class (default: macro) */
+        average: OptionType<VariantType<{
+            /** Calculate metrics for each label, return unweighted mean */
+            macro: NullType;
+            /** Calculate metrics globally by counting total TP, FP, FN */
+            micro: NullType;
+            /** Calculate metrics for each label, return weighted mean by support */
+            weighted: NullType;
+            /** Only for binary classification */
+            binary: NullType;
+        }>>;
+    }>;
+    /** Classification metric result */
+    readonly ClassificationMetricResultType: StructType<{
+        /** Which metric was computed */
+        metric: VariantType<{
+            /** Accuracy - sklearn.metrics.accuracy_score */
+            accuracy: NullType;
+            /** Balanced Accuracy - sklearn.metrics.balanced_accuracy_score */
+            balanced_accuracy: NullType;
+            /** Precision - sklearn.metrics.precision_score */
+            precision: NullType;
+            /** Recall - sklearn.metrics.recall_score */
+            recall: NullType;
+            /** F1 Score - sklearn.metrics.f1_score */
+            f1: NullType;
+            /** Matthews Correlation Coefficient - sklearn.metrics.matthews_corrcoef */
+            matthews_corrcoef: NullType;
+            /** Cohen's Kappa - sklearn.metrics.cohen_kappa_score */
+            cohen_kappa: NullType;
+            /** Jaccard Score - sklearn.metrics.jaccard_score */
+            jaccard: NullType;
+        }>;
+        /** Scalar metric value */
+        value: FloatType;
+    }>;
+    /** Classification metrics result */
+    readonly ClassificationMetricResultsType: ArrayType<StructType<{
+        /** Which metric was computed */
+        metric: VariantType<{
+            /** Accuracy - sklearn.metrics.accuracy_score */
+            accuracy: NullType;
+            /** Balanced Accuracy - sklearn.metrics.balanced_accuracy_score */
+            balanced_accuracy: NullType;
+            /** Precision - sklearn.metrics.precision_score */
+            precision: NullType;
+            /** Recall - sklearn.metrics.recall_score */
+            recall: NullType;
+            /** F1 Score - sklearn.metrics.f1_score */
+            f1: NullType;
+            /** Matthews Correlation Coefficient - sklearn.metrics.matthews_corrcoef */
+            matthews_corrcoef: NullType;
+            /** Cohen's Kappa - sklearn.metrics.cohen_kappa_score */
+            cohen_kappa: NullType;
+            /** Jaccard Score - sklearn.metrics.jaccard_score */
+            jaccard: NullType;
+        }>;
+        /** Scalar metric value */
+        value: FloatType;
+    }>>;
+    /** Multi-target classification config */
+    readonly MultiClassificationConfigType: StructType<{
+        /** Averaging strategy for multi-class (default: macro) */
+        average: OptionType<VariantType<{
+            /** Calculate metrics for each label, return unweighted mean */
+            macro: NullType;
+            /** Calculate metrics globally by counting total TP, FP, FN */
+            micro: NullType;
+            /** Calculate metrics for each label, return weighted mean by support */
+            weighted: NullType;
+            /** Only for binary classification */
+            binary: NullType;
+        }>>;
+        /** How to aggregate across targets (default: per_target) */
+        aggregation: OptionType<VariantType<{
+            /** Return metric for each target separately (default) */
+            per_target: NullType;
+            /** Average across all targets (uniform weights) */
+            uniform_average: NullType;
+        }>>;
+    }>;
+    /** Multi-target classification metric result */
+    readonly MultiClassificationMetricResultType: StructType<{
+        /** Which metric was computed */
+        metric: VariantType<{
+            /** Accuracy - sklearn.metrics.accuracy_score */
+            accuracy: NullType;
+            /** Balanced Accuracy - sklearn.metrics.balanced_accuracy_score */
+            balanced_accuracy: NullType;
+            /** Precision - sklearn.metrics.precision_score */
+            precision: NullType;
+            /** Recall - sklearn.metrics.recall_score */
+            recall: NullType;
+            /** F1 Score - sklearn.metrics.f1_score */
+            f1: NullType;
+            /** Matthews Correlation Coefficient - sklearn.metrics.matthews_corrcoef */
+            matthews_corrcoef: NullType;
+            /** Cohen's Kappa - sklearn.metrics.cohen_kappa_score */
+            cohen_kappa: NullType;
+            /** Jaccard Score - sklearn.metrics.jaccard_score */
+            jaccard: NullType;
+        }>;
+        /** Metric value(s) */
+        value: VariantType<{
+            /** Aggregated scalar value */
+            scalar: FloatType;
+            /** Per-target values */
+            per_target: ArrayType<FloatType>;
+        }>;
+    }>;
+    /** Multi-target classification metrics result */
+    readonly MultiClassificationMetricResultsType: ArrayType<StructType<{
+        /** Which metric was computed */
+        metric: VariantType<{
+            /** Accuracy - sklearn.metrics.accuracy_score */
+            accuracy: NullType;
+            /** Balanced Accuracy - sklearn.metrics.balanced_accuracy_score */
+            balanced_accuracy: NullType;
+            /** Precision - sklearn.metrics.precision_score */
+            precision: NullType;
+            /** Recall - sklearn.metrics.recall_score */
+            recall: NullType;
+            /** F1 Score - sklearn.metrics.f1_score */
+            f1: NullType;
+            /** Matthews Correlation Coefficient - sklearn.metrics.matthews_corrcoef */
+            matthews_corrcoef: NullType;
+            /** Cohen's Kappa - sklearn.metrics.cohen_kappa_score */
+            cohen_kappa: NullType;
+            /** Jaccard Score - sklearn.metrics.jaccard_score */
+            jaccard: NullType;
+        }>;
+        /** Metric value(s) */
+        value: VariantType<{
+            /** Aggregated scalar value */
+            scalar: FloatType;
+            /** Per-target values */
+            per_target: ArrayType<FloatType>;
+        }>;
+    }>>;
 };
 /**
  * Scikit-learn machine learning utilities.
@@ -810,6 +1708,30 @@ export declare const Sklearn: {
         /** Test labels */
         y_test: ArrayType<FloatType>;
     }>>;
+    /** Split arrays into train, validation, and test subsets */
+    readonly trainValTestSplit: import("@elaraai/east").PlatformDefinition<[ArrayType<ArrayType<FloatType>>, ArrayType<ArrayType<FloatType>>, StructType<{
+        /** Proportion of data for validation (default 0.15) */
+        val_size: OptionType<FloatType>;
+        /** Proportion of data for test/holdout (default 0.15) */
+        test_size: OptionType<FloatType>;
+        /** Random seed for reproducibility */
+        random_state: OptionType<IntegerType>;
+        /** Whether to shuffle data before splitting (default true) */
+        shuffle: OptionType<BooleanType>;
+    }>], StructType<{
+        /** Training features */
+        X_train: ArrayType<ArrayType<FloatType>>;
+        /** Validation features */
+        X_val: ArrayType<ArrayType<FloatType>>;
+        /** Test/holdout features */
+        X_test: ArrayType<ArrayType<FloatType>>;
+        /** Training targets (matrix) */
+        Y_train: ArrayType<ArrayType<FloatType>>;
+        /** Validation targets (matrix) */
+        Y_val: ArrayType<ArrayType<FloatType>>;
+        /** Test/holdout targets (matrix) */
+        Y_test: ArrayType<ArrayType<FloatType>>;
+    }>>;
     /** Fit a StandardScaler to data */
     readonly standardScalerFit: import("@elaraai/east").PlatformDefinition<[ArrayType<ArrayType<FloatType>>], VariantType<{
         /** StandardScaler model */
@@ -922,30 +1844,219 @@ export declare const Sklearn: {
             base_estimator_type: StringType;
         }>;
     }>, ArrayType<ArrayType<FloatType>>], ArrayType<ArrayType<FloatType>>>;
-    /** Compute regression metrics */
-    readonly metricsRegression: import("@elaraai/east").PlatformDefinition<[ArrayType<FloatType>, ArrayType<FloatType>], StructType<{
-        /** Mean Squared Error */
-        mse: FloatType;
-        /** Root Mean Squared Error */
-        rmse: FloatType;
-        /** Mean Absolute Error */
-        mae: FloatType;
-        /** R-squared (coefficient of determination) */
-        r2: FloatType;
-        /** Mean Absolute Percentage Error */
-        mape: FloatType;
-    }>>;
-    /** Compute classification metrics */
-    readonly metricsClassification: import("@elaraai/east").PlatformDefinition<[ArrayType<IntegerType>, ArrayType<IntegerType>], StructType<{
-        /** Accuracy score */
-        accuracy: FloatType;
-        /** Precision (weighted average) */
-        precision: FloatType;
-        /** Recall (weighted average) */
-        recall: FloatType;
-        /** F1 score (weighted average) */
-        f1: FloatType;
-    }>>;
+    /** Compute regression metrics (single-target) */
+    readonly computeMetrics: import("@elaraai/east").PlatformDefinition<[ArrayType<FloatType>, ArrayType<FloatType>, ArrayType<VariantType<{
+        /** Mean Squared Error - sklearn.metrics.mean_squared_error */
+        mse: NullType;
+        /** Root Mean Squared Error - sqrt(MSE) */
+        rmse: NullType;
+        /** Mean Absolute Error - sklearn.metrics.mean_absolute_error */
+        mae: NullType;
+        /** R² (coefficient of determination) - sklearn.metrics.r2_score */
+        r2: NullType;
+        /** Mean Absolute Percentage Error - sklearn.metrics.mean_absolute_percentage_error */
+        mape: NullType;
+        /** Explained Variance Score - sklearn.metrics.explained_variance_score */
+        explained_variance: NullType;
+        /** Max Error - sklearn.metrics.max_error */
+        max_error: NullType;
+        /** Median Absolute Error - sklearn.metrics.median_absolute_error */
+        median_ae: NullType;
+    }>>], ArrayType<StructType<{
+        /** Which metric was computed */
+        metric: VariantType<{
+            /** Mean Squared Error - sklearn.metrics.mean_squared_error */
+            mse: NullType;
+            /** Root Mean Squared Error - sqrt(MSE) */
+            rmse: NullType;
+            /** Mean Absolute Error - sklearn.metrics.mean_absolute_error */
+            mae: NullType;
+            /** R² (coefficient of determination) - sklearn.metrics.r2_score */
+            r2: NullType;
+            /** Mean Absolute Percentage Error - sklearn.metrics.mean_absolute_percentage_error */
+            mape: NullType;
+            /** Explained Variance Score - sklearn.metrics.explained_variance_score */
+            explained_variance: NullType;
+            /** Max Error - sklearn.metrics.max_error */
+            max_error: NullType;
+            /** Median Absolute Error - sklearn.metrics.median_absolute_error */
+            median_ae: NullType;
+        }>;
+        /** Scalar metric value */
+        value: FloatType;
+    }>>>;
+    /** Compute regression metrics (multi-target) */
+    readonly computeMetricsMulti: import("@elaraai/east").PlatformDefinition<[ArrayType<ArrayType<FloatType>>, ArrayType<ArrayType<FloatType>>, ArrayType<VariantType<{
+        /** Mean Squared Error - sklearn.metrics.mean_squared_error */
+        mse: NullType;
+        /** Root Mean Squared Error - sqrt(MSE) */
+        rmse: NullType;
+        /** Mean Absolute Error - sklearn.metrics.mean_absolute_error */
+        mae: NullType;
+        /** R² (coefficient of determination) - sklearn.metrics.r2_score */
+        r2: NullType;
+        /** Mean Absolute Percentage Error - sklearn.metrics.mean_absolute_percentage_error */
+        mape: NullType;
+        /** Explained Variance Score - sklearn.metrics.explained_variance_score */
+        explained_variance: NullType;
+        /** Max Error - sklearn.metrics.max_error */
+        max_error: NullType;
+        /** Median Absolute Error - sklearn.metrics.median_absolute_error */
+        median_ae: NullType;
+    }>>, StructType<{
+        /** How to aggregate metrics across targets (default: per_target) */
+        aggregation: OptionType<VariantType<{
+            /** Return metric for each target separately (default) */
+            per_target: NullType;
+            /** Average across all targets (uniform weights) */
+            uniform_average: NullType;
+        }>>;
+    }>], ArrayType<StructType<{
+        /** Which metric was computed */
+        metric: VariantType<{
+            /** Mean Squared Error - sklearn.metrics.mean_squared_error */
+            mse: NullType;
+            /** Root Mean Squared Error - sqrt(MSE) */
+            rmse: NullType;
+            /** Mean Absolute Error - sklearn.metrics.mean_absolute_error */
+            mae: NullType;
+            /** R² (coefficient of determination) - sklearn.metrics.r2_score */
+            r2: NullType;
+            /** Mean Absolute Percentage Error - sklearn.metrics.mean_absolute_percentage_error */
+            mape: NullType;
+            /** Explained Variance Score - sklearn.metrics.explained_variance_score */
+            explained_variance: NullType;
+            /** Max Error - sklearn.metrics.max_error */
+            max_error: NullType;
+            /** Median Absolute Error - sklearn.metrics.median_absolute_error */
+            median_ae: NullType;
+        }>;
+        /** Metric value(s) */
+        value: VariantType<{
+            /** Aggregated scalar value */
+            scalar: FloatType;
+            /** Per-target values [target_0, target_1, ...] */
+            per_target: ArrayType<FloatType>;
+        }>;
+    }>>>;
+    /** Compute classification metrics (single-target) */
+    readonly computeClassificationMetrics: import("@elaraai/east").PlatformDefinition<[ArrayType<IntegerType>, ArrayType<IntegerType>, ArrayType<VariantType<{
+        /** Accuracy - sklearn.metrics.accuracy_score */
+        accuracy: NullType;
+        /** Balanced Accuracy - sklearn.metrics.balanced_accuracy_score */
+        balanced_accuracy: NullType;
+        /** Precision - sklearn.metrics.precision_score */
+        precision: NullType;
+        /** Recall - sklearn.metrics.recall_score */
+        recall: NullType;
+        /** F1 Score - sklearn.metrics.f1_score */
+        f1: NullType;
+        /** Matthews Correlation Coefficient - sklearn.metrics.matthews_corrcoef */
+        matthews_corrcoef: NullType;
+        /** Cohen's Kappa - sklearn.metrics.cohen_kappa_score */
+        cohen_kappa: NullType;
+        /** Jaccard Score - sklearn.metrics.jaccard_score */
+        jaccard: NullType;
+    }>>, StructType<{
+        /** Averaging strategy for multi-class (default: macro) */
+        average: OptionType<VariantType<{
+            /** Calculate metrics for each label, return unweighted mean */
+            macro: NullType;
+            /** Calculate metrics globally by counting total TP, FP, FN */
+            micro: NullType;
+            /** Calculate metrics for each label, return weighted mean by support */
+            weighted: NullType;
+            /** Only for binary classification */
+            binary: NullType;
+        }>>;
+    }>], ArrayType<StructType<{
+        /** Which metric was computed */
+        metric: VariantType<{
+            /** Accuracy - sklearn.metrics.accuracy_score */
+            accuracy: NullType;
+            /** Balanced Accuracy - sklearn.metrics.balanced_accuracy_score */
+            balanced_accuracy: NullType;
+            /** Precision - sklearn.metrics.precision_score */
+            precision: NullType;
+            /** Recall - sklearn.metrics.recall_score */
+            recall: NullType;
+            /** F1 Score - sklearn.metrics.f1_score */
+            f1: NullType;
+            /** Matthews Correlation Coefficient - sklearn.metrics.matthews_corrcoef */
+            matthews_corrcoef: NullType;
+            /** Cohen's Kappa - sklearn.metrics.cohen_kappa_score */
+            cohen_kappa: NullType;
+            /** Jaccard Score - sklearn.metrics.jaccard_score */
+            jaccard: NullType;
+        }>;
+        /** Scalar metric value */
+        value: FloatType;
+    }>>>;
+    /** Compute classification metrics (multi-target) */
+    readonly computeClassificationMetricsMulti: import("@elaraai/east").PlatformDefinition<[ArrayType<ArrayType<FloatType>>, ArrayType<ArrayType<FloatType>>, ArrayType<VariantType<{
+        /** Accuracy - sklearn.metrics.accuracy_score */
+        accuracy: NullType;
+        /** Balanced Accuracy - sklearn.metrics.balanced_accuracy_score */
+        balanced_accuracy: NullType;
+        /** Precision - sklearn.metrics.precision_score */
+        precision: NullType;
+        /** Recall - sklearn.metrics.recall_score */
+        recall: NullType;
+        /** F1 Score - sklearn.metrics.f1_score */
+        f1: NullType;
+        /** Matthews Correlation Coefficient - sklearn.metrics.matthews_corrcoef */
+        matthews_corrcoef: NullType;
+        /** Cohen's Kappa - sklearn.metrics.cohen_kappa_score */
+        cohen_kappa: NullType;
+        /** Jaccard Score - sklearn.metrics.jaccard_score */
+        jaccard: NullType;
+    }>>, StructType<{
+        /** Averaging strategy for multi-class (default: macro) */
+        average: OptionType<VariantType<{
+            /** Calculate metrics for each label, return unweighted mean */
+            macro: NullType;
+            /** Calculate metrics globally by counting total TP, FP, FN */
+            micro: NullType;
+            /** Calculate metrics for each label, return weighted mean by support */
+            weighted: NullType;
+            /** Only for binary classification */
+            binary: NullType;
+        }>>;
+        /** How to aggregate across targets (default: per_target) */
+        aggregation: OptionType<VariantType<{
+            /** Return metric for each target separately (default) */
+            per_target: NullType;
+            /** Average across all targets (uniform weights) */
+            uniform_average: NullType;
+        }>>;
+    }>], ArrayType<StructType<{
+        /** Which metric was computed */
+        metric: VariantType<{
+            /** Accuracy - sklearn.metrics.accuracy_score */
+            accuracy: NullType;
+            /** Balanced Accuracy - sklearn.metrics.balanced_accuracy_score */
+            balanced_accuracy: NullType;
+            /** Precision - sklearn.metrics.precision_score */
+            precision: NullType;
+            /** Recall - sklearn.metrics.recall_score */
+            recall: NullType;
+            /** F1 Score - sklearn.metrics.f1_score */
+            f1: NullType;
+            /** Matthews Correlation Coefficient - sklearn.metrics.matthews_corrcoef */
+            matthews_corrcoef: NullType;
+            /** Cohen's Kappa - sklearn.metrics.cohen_kappa_score */
+            cohen_kappa: NullType;
+            /** Jaccard Score - sklearn.metrics.jaccard_score */
+            jaccard: NullType;
+        }>;
+        /** Metric value(s) */
+        value: VariantType<{
+            /** Aggregated scalar value */
+            scalar: FloatType;
+            /** Per-target values */
+            per_target: ArrayType<FloatType>;
+        }>;
+    }>>>;
     /** Train a RegressorChain for multi-target regression */
     readonly regressorChainTrain: import("@elaraai/east").PlatformDefinition<[ArrayType<ArrayType<FloatType>>, ArrayType<ArrayType<FloatType>>, StructType<{
         /** Base estimator with its configuration */
@@ -962,6 +2073,7 @@ export declare const Sklearn: {
                 reg_lambda: OptionType<FloatType>;
                 random_state: OptionType<IntegerType>;
                 n_jobs: OptionType<IntegerType>;
+                sample_weight: OptionType<ArrayType<FloatType>>;
             }>;
             /** LightGBM regressor */
             lightgbm: StructType<{
@@ -985,19 +2097,19 @@ export declare const Sklearn: {
                 col_sample: OptionType<FloatType>;
                 random_state: OptionType<IntegerType>;
                 distribution: OptionType<VariantType<{
-                    normal: StructType<{}>;
-                    lognormal: StructType<{}>;
+                    normal: NullType;
+                    lognormal: NullType;
                 }>>;
             }>;
             /** Gaussian Process regressor */
             gp: StructType<{
                 kernel: OptionType<VariantType<{
-                    rbf: StructType<{}>;
-                    matern_1_2: StructType<{}>;
-                    matern_3_2: StructType<{}>;
-                    matern_5_2: StructType<{}>;
-                    rational_quadratic: StructType<{}>;
-                    dot_product: StructType<{}>;
+                    rbf: NullType;
+                    matern_1_2: NullType;
+                    matern_3_2: NullType;
+                    matern_5_2: NullType;
+                    rational_quadratic: NullType;
+                    dot_product: NullType;
                 }>>;
                 alpha: OptionType<FloatType>;
                 n_restarts_optimizer: OptionType<IntegerType>;
@@ -1092,29 +2204,31 @@ export declare const Sklearn: {
             /** Test labels */
             y_test: ArrayType<FloatType>;
         }>;
-        /** Regression metrics type */
-        readonly RegressionMetricsType: StructType<{
-            /** Mean Squared Error */
-            mse: FloatType;
-            /** Root Mean Squared Error */
-            rmse: FloatType;
-            /** Mean Absolute Error */
-            mae: FloatType;
-            /** R-squared (coefficient of determination) */
-            r2: FloatType;
-            /** Mean Absolute Percentage Error */
-            mape: FloatType;
-        }>;
-        /** Classification metrics type */
-        readonly ClassificationMetricsType: StructType<{
-            /** Accuracy score */
-            accuracy: FloatType;
-            /** Precision (weighted average) */
-            precision: FloatType;
-            /** Recall (weighted average) */
-            recall: FloatType;
-            /** F1 score (weighted average) */
-            f1: FloatType;
+        /** 3-way split configuration type */
+        readonly ThreeWaySplitConfigType: StructType<{
+            /** Proportion of data for validation (default 0.15) */
+            val_size: OptionType<FloatType>;
+            /** Proportion of data for test/holdout (default 0.15) */
+            test_size: OptionType<FloatType>;
+            /** Random seed for reproducibility */
+            random_state: OptionType<IntegerType>;
+            /** Whether to shuffle data before splitting (default true) */
+            shuffle: OptionType<BooleanType>;
+        }>;
+        /** 3-way split result type */
+        readonly ThreeWaySplitResultType: StructType<{
+            /** Training features */
+            X_train: ArrayType<ArrayType<FloatType>>;
+            /** Validation features */
+            X_val: ArrayType<ArrayType<FloatType>>;
+            /** Test/holdout features */
+            X_test: ArrayType<ArrayType<FloatType>>;
+            /** Training targets (matrix) */
+            Y_train: ArrayType<ArrayType<FloatType>>;
+            /** Validation targets (matrix) */
+            Y_val: ArrayType<ArrayType<FloatType>>;
+            /** Test/holdout targets (matrix) */
+            Y_test: ArrayType<ArrayType<FloatType>>;
         }>;
         /** Model blob type for sklearn models */
         readonly ModelBlobType: VariantType<{
@@ -1144,8 +2258,6 @@ export declare const Sklearn: {
                 base_estimator_type: StringType;
             }>;
         }>;
-        /** Multi-target output type */
-        readonly MultiTargetType: ArrayType<ArrayType<FloatType>>;
         /** RegressorChain base estimator config type */
         readonly RegressorChainBaseConfigType: VariantType<{
             /** XGBoost regressor */
@@ -1160,6 +2272,7 @@ export declare const Sklearn: {
                 reg_lambda: OptionType<FloatType>;
                 random_state: OptionType<IntegerType>;
                 n_jobs: OptionType<IntegerType>;
+                sample_weight: OptionType<ArrayType<FloatType>>;
             }>;
             /** LightGBM regressor */
             lightgbm: StructType<{
@@ -1183,19 +2296,19 @@ export declare const Sklearn: {
                 col_sample: OptionType<FloatType>;
                 random_state: OptionType<IntegerType>;
                 distribution: OptionType<VariantType<{
-                    normal: StructType<{}>;
-                    lognormal: StructType<{}>;
+                    normal: NullType;
+                    lognormal: NullType;
                 }>>;
             }>;
             /** Gaussian Process regressor */
             gp: StructType<{
                 kernel: OptionType<VariantType<{
-                    rbf: StructType<{}>;
-                    matern_1_2: StructType<{}>;
-                    matern_3_2: StructType<{}>;
-                    matern_5_2: StructType<{}>;
-                    rational_quadratic: StructType<{}>;
-                    dot_product: StructType<{}>;
+                    rbf: NullType;
+                    matern_1_2: NullType;
+                    matern_3_2: NullType;
+                    matern_5_2: NullType;
+                    rational_quadratic: NullType;
+                    dot_product: NullType;
                 }>>;
                 alpha: OptionType<FloatType>;
                 n_restarts_optimizer: OptionType<IntegerType>;
@@ -1219,6 +2332,7 @@ export declare const Sklearn: {
                     reg_lambda: OptionType<FloatType>;
                     random_state: OptionType<IntegerType>;
                     n_jobs: OptionType<IntegerType>;
+                    sample_weight: OptionType<ArrayType<FloatType>>;
                 }>;
                 /** LightGBM regressor */
                 lightgbm: StructType<{
@@ -1242,19 +2356,19 @@ export declare const Sklearn: {
                     col_sample: OptionType<FloatType>;
                     random_state: OptionType<IntegerType>;
                     distribution: OptionType<VariantType<{
-                        normal: StructType<{}>;
-                        lognormal: StructType<{}>;
+                        normal: NullType;
+                        lognormal: NullType;
                     }>>;
                 }>;
                 /** Gaussian Process regressor */
                 gp: StructType<{
                     kernel: OptionType<VariantType<{
-                        rbf: StructType<{}>;
-                        matern_1_2: StructType<{}>;
-                        matern_3_2: StructType<{}>;
-                        matern_5_2: StructType<{}>;
-                        rational_quadratic: StructType<{}>;
-                        dot_product: StructType<{}>;
+                        rbf: NullType;
+                        matern_1_2: NullType;
+                        matern_3_2: NullType;
+                        matern_5_2: NullType;
+                        rational_quadratic: NullType;
+                        dot_product: NullType;
                     }>>;
                     alpha: OptionType<FloatType>;
                     n_restarts_optimizer: OptionType<IntegerType>;
@@ -1267,6 +2381,319 @@ export declare const Sklearn: {
             /** Random seed for reproducibility */
             random_state: OptionType<IntegerType>;
         }>;
+        /** Regression metric variant */
+        readonly RegressionMetricType: VariantType<{
+            /** Mean Squared Error - sklearn.metrics.mean_squared_error */
+            mse: NullType;
+            /** Root Mean Squared Error - sqrt(MSE) */
+            rmse: NullType;
+            /** Mean Absolute Error - sklearn.metrics.mean_absolute_error */
+            mae: NullType;
+            /** R² (coefficient of determination) - sklearn.metrics.r2_score */
+            r2: NullType;
+            /** Mean Absolute Percentage Error - sklearn.metrics.mean_absolute_percentage_error */
+            mape: NullType;
+            /** Explained Variance Score - sklearn.metrics.explained_variance_score */
+            explained_variance: NullType;
+            /** Max Error - sklearn.metrics.max_error */
+            max_error: NullType;
+            /** Median Absolute Error - sklearn.metrics.median_absolute_error */
+            median_ae: NullType;
+        }>;
+        /** Single metric result */
+        readonly MetricResultType: StructType<{
+            /** Which metric was computed */
+            metric: VariantType<{
+                /** Mean Squared Error - sklearn.metrics.mean_squared_error */
+                mse: NullType;
+                /** Root Mean Squared Error - sqrt(MSE) */
+                rmse: NullType;
+                /** Mean Absolute Error - sklearn.metrics.mean_absolute_error */
+                mae: NullType;
+                /** R² (coefficient of determination) - sklearn.metrics.r2_score */
+                r2: NullType;
+                /** Mean Absolute Percentage Error - sklearn.metrics.mean_absolute_percentage_error */
+                mape: NullType;
+                /** Explained Variance Score - sklearn.metrics.explained_variance_score */
+                explained_variance: NullType;
+                /** Max Error - sklearn.metrics.max_error */
+                max_error: NullType;
+                /** Median Absolute Error - sklearn.metrics.median_absolute_error */
+                median_ae: NullType;
+            }>;
+            /** Scalar metric value */
+            value: FloatType;
+        }>;
+        /** Multiple metrics result */
+        readonly MetricsResultType: ArrayType<StructType<{
+            /** Which metric was computed */
+            metric: VariantType<{
+                /** Mean Squared Error - sklearn.metrics.mean_squared_error */
+                mse: NullType;
+                /** Root Mean Squared Error - sqrt(MSE) */
+                rmse: NullType;
+                /** Mean Absolute Error - sklearn.metrics.mean_absolute_error */
+                mae: NullType;
+                /** R² (coefficient of determination) - sklearn.metrics.r2_score */
+                r2: NullType;
+                /** Mean Absolute Percentage Error - sklearn.metrics.mean_absolute_percentage_error */
+                mape: NullType;
+                /** Explained Variance Score - sklearn.metrics.explained_variance_score */
+                explained_variance: NullType;
+                /** Max Error - sklearn.metrics.max_error */
+                max_error: NullType;
+                /** Median Absolute Error - sklearn.metrics.median_absolute_error */
+                median_ae: NullType;
+            }>;
+            /** Scalar metric value */
+            value: FloatType;
+        }>>;
+        /** Metric aggregation type */
+        readonly MetricAggregationType: VariantType<{
+            /** Return metric for each target separately (default) */
+            per_target: NullType;
+            /** Average across all targets (uniform weights) */
+            uniform_average: NullType;
+        }>;
+        /** Multi-target metrics config */
+        readonly MultiMetricsConfigType: StructType<{
+            /** How to aggregate metrics across targets (default: per_target) */
+            aggregation: OptionType<VariantType<{
+                /** Return metric for each target separately (default) */
+                per_target: NullType;
+                /** Average across all targets (uniform weights) */
+                uniform_average: NullType;
+            }>>;
+        }>;
+        /** Multi-target metric result */
+        readonly MultiMetricResultType: StructType<{
+            /** Which metric was computed */
+            metric: VariantType<{
+                /** Mean Squared Error - sklearn.metrics.mean_squared_error */
+                mse: NullType;
+                /** Root Mean Squared Error - sqrt(MSE) */
+                rmse: NullType;
+                /** Mean Absolute Error - sklearn.metrics.mean_absolute_error */
+                mae: NullType;
+                /** R² (coefficient of determination) - sklearn.metrics.r2_score */
+                r2: NullType;
+                /** Mean Absolute Percentage Error - sklearn.metrics.mean_absolute_percentage_error */
+                mape: NullType;
+                /** Explained Variance Score - sklearn.metrics.explained_variance_score */
+                explained_variance: NullType;
+                /** Max Error - sklearn.metrics.max_error */
+                max_error: NullType;
+                /** Median Absolute Error - sklearn.metrics.median_absolute_error */
+                median_ae: NullType;
+            }>;
+            /** Metric value(s) */
+            value: VariantType<{
+                /** Aggregated scalar value */
+                scalar: FloatType;
+                /** Per-target values [target_0, target_1, ...] */
+                per_target: ArrayType<FloatType>;
+            }>;
+        }>;
+        /** Multi-target metrics result */
+        readonly MultiMetricsResultType: ArrayType<StructType<{
+            /** Which metric was computed */
+            metric: VariantType<{
+                /** Mean Squared Error - sklearn.metrics.mean_squared_error */
+                mse: NullType;
+                /** Root Mean Squared Error - sqrt(MSE) */
+                rmse: NullType;
+                /** Mean Absolute Error - sklearn.metrics.mean_absolute_error */
+                mae: NullType;
+                /** R² (coefficient of determination) - sklearn.metrics.r2_score */
+                r2: NullType;
+                /** Mean Absolute Percentage Error - sklearn.metrics.mean_absolute_percentage_error */
+                mape: NullType;
+                /** Explained Variance Score - sklearn.metrics.explained_variance_score */
+                explained_variance: NullType;
+                /** Max Error - sklearn.metrics.max_error */
+                max_error: NullType;
+                /** Median Absolute Error - sklearn.metrics.median_absolute_error */
+                median_ae: NullType;
+            }>;
+            /** Metric value(s) */
+            value: VariantType<{
+                /** Aggregated scalar value */
+                scalar: FloatType;
+                /** Per-target values [target_0, target_1, ...] */
+                per_target: ArrayType<FloatType>;
+            }>;
+        }>>;
+        /** Classification metric variant */
+        readonly ClassificationMetricType: VariantType<{
+            /** Accuracy - sklearn.metrics.accuracy_score */
+            accuracy: NullType;
+            /** Balanced Accuracy - sklearn.metrics.balanced_accuracy_score */
+            balanced_accuracy: NullType;
+            /** Precision - sklearn.metrics.precision_score */
+            precision: NullType;
+            /** Recall - sklearn.metrics.recall_score */
+            recall: NullType;
+            /** F1 Score - sklearn.metrics.f1_score */
+            f1: NullType;
+            /** Matthews Correlation Coefficient - sklearn.metrics.matthews_corrcoef */
+            matthews_corrcoef: NullType;
+            /** Cohen's Kappa - sklearn.metrics.cohen_kappa_score */
+            cohen_kappa: NullType;
+            /** Jaccard Score - sklearn.metrics.jaccard_score */
+            jaccard: NullType;
+        }>;
+        /** Classification averaging type */
+        readonly ClassificationAverageType: VariantType<{
+            /** Calculate metrics for each label, return unweighted mean */
+            macro: NullType;
+            /** Calculate metrics globally by counting total TP, FP, FN */
+            micro: NullType;
+            /** Calculate metrics for each label, return weighted mean by support */
+            weighted: NullType;
+            /** Only for binary classification */
+            binary: NullType;
+        }>;
+        /** Classification metrics config */
+        readonly ClassificationMetricsConfigType: StructType<{
+            /** Averaging strategy for multi-class (default: macro) */
+            average: OptionType<VariantType<{
+                /** Calculate metrics for each label, return unweighted mean */
+                macro: NullType;
+                /** Calculate metrics globally by counting total TP, FP, FN */
+                micro: NullType;
+                /** Calculate metrics for each label, return weighted mean by support */
+                weighted: NullType;
+                /** Only for binary classification */
+                binary: NullType;
+            }>>;
+        }>;
+        /** Classification metric result */
+        readonly ClassificationMetricResultType: StructType<{
+            /** Which metric was computed */
+            metric: VariantType<{
+                /** Accuracy - sklearn.metrics.accuracy_score */
+                accuracy: NullType;
+                /** Balanced Accuracy - sklearn.metrics.balanced_accuracy_score */
+                balanced_accuracy: NullType;
+                /** Precision - sklearn.metrics.precision_score */
+                precision: NullType;
+                /** Recall - sklearn.metrics.recall_score */
+                recall: NullType;
+                /** F1 Score - sklearn.metrics.f1_score */
+                f1: NullType;
+                /** Matthews Correlation Coefficient - sklearn.metrics.matthews_corrcoef */
+                matthews_corrcoef: NullType;
+                /** Cohen's Kappa - sklearn.metrics.cohen_kappa_score */
+                cohen_kappa: NullType;
+                /** Jaccard Score - sklearn.metrics.jaccard_score */
+                jaccard: NullType;
+            }>;
+            /** Scalar metric value */
+            value: FloatType;
+        }>;
+        /** Classification metrics result */
+        readonly ClassificationMetricResultsType: ArrayType<StructType<{
+            /** Which metric was computed */
+            metric: VariantType<{
+                /** Accuracy - sklearn.metrics.accuracy_score */
+                accuracy: NullType;
+                /** Balanced Accuracy - sklearn.metrics.balanced_accuracy_score */
+                balanced_accuracy: NullType;
+                /** Precision - sklearn.metrics.precision_score */
+                precision: NullType;
+                /** Recall - sklearn.metrics.recall_score */
+                recall: NullType;
+                /** F1 Score - sklearn.metrics.f1_score */
+                f1: NullType;
+                /** Matthews Correlation Coefficient - sklearn.metrics.matthews_corrcoef */
+                matthews_corrcoef: NullType;
+                /** Cohen's Kappa - sklearn.metrics.cohen_kappa_score */
+                cohen_kappa: NullType;
+                /** Jaccard Score - sklearn.metrics.jaccard_score */
+                jaccard: NullType;
+            }>;
+            /** Scalar metric value */
+            value: FloatType;
+        }>>;
+        /** Multi-target classification config */
+        readonly MultiClassificationConfigType: StructType<{
+            /** Averaging strategy for multi-class (default: macro) */
+            average: OptionType<VariantType<{
+                /** Calculate metrics for each label, return unweighted mean */
+                macro: NullType;
+                /** Calculate metrics globally by counting total TP, FP, FN */
+                micro: NullType;
+                /** Calculate metrics for each label, return weighted mean by support */
+                weighted: NullType;
+                /** Only for binary classification */
+                binary: NullType;
+            }>>;
+            /** How to aggregate across targets (default: per_target) */
+            aggregation: OptionType<VariantType<{
+                /** Return metric for each target separately (default) */
+                per_target: NullType;
+                /** Average across all targets (uniform weights) */
+                uniform_average: NullType;
+            }>>;
+        }>;
+        /** Multi-target classification metric result */
+        readonly MultiClassificationMetricResultType: StructType<{
+            /** Which metric was computed */
+            metric: VariantType<{
+                /** Accuracy - sklearn.metrics.accuracy_score */
+                accuracy: NullType;
+                /** Balanced Accuracy - sklearn.metrics.balanced_accuracy_score */
+                balanced_accuracy: NullType;
+                /** Precision - sklearn.metrics.precision_score */
+                precision: NullType;
+                /** Recall - sklearn.metrics.recall_score */
+                recall: NullType;
+                /** F1 Score - sklearn.metrics.f1_score */
+                f1: NullType;
+                /** Matthews Correlation Coefficient - sklearn.metrics.matthews_corrcoef */
+                matthews_corrcoef: NullType;
+                /** Cohen's Kappa - sklearn.metrics.cohen_kappa_score */
+                cohen_kappa: NullType;
+                /** Jaccard Score - sklearn.metrics.jaccard_score */
+                jaccard: NullType;
+            }>;
+            /** Metric value(s) */
+            value: VariantType<{
+                /** Aggregated scalar value */
+                scalar: FloatType;
+                /** Per-target values */
+                per_target: ArrayType<FloatType>;
+            }>;
+        }>;
+        /** Multi-target classification metrics result */
+        readonly MultiClassificationMetricResultsType: ArrayType<StructType<{
+            /** Which metric was computed */
+            metric: VariantType<{
+                /** Accuracy - sklearn.metrics.accuracy_score */
+                accuracy: NullType;
+                /** Balanced Accuracy - sklearn.metrics.balanced_accuracy_score */
+                balanced_accuracy: NullType;
+                /** Precision - sklearn.metrics.precision_score */
+                precision: NullType;
+                /** Recall - sklearn.metrics.recall_score */
+                recall: NullType;
+                /** F1 Score - sklearn.metrics.f1_score */
+                f1: NullType;
+                /** Matthews Correlation Coefficient - sklearn.metrics.matthews_corrcoef */
+                matthews_corrcoef: NullType;
+                /** Cohen's Kappa - sklearn.metrics.cohen_kappa_score */
+                cohen_kappa: NullType;
+                /** Jaccard Score - sklearn.metrics.jaccard_score */
+                jaccard: NullType;
+            }>;
+            /** Metric value(s) */
+            value: VariantType<{
+                /** Aggregated scalar value */
+                scalar: FloatType;
+                /** Per-target values */
+                per_target: ArrayType<FloatType>;
+            }>;
+        }>>;
     };
 };
 //# sourceMappingURL=sklearn.d.ts.map