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

package/dist/sklearn/sklearn.d.ts

@@ -0,0 +1,1272 @@
+/**
+ * Copyright (c) 2025 Elara AI Pty Ltd
+ * Dual-licensed under AGPL-3.0 and commercial license. See LICENSE for details.
+ */
+/**
+ * Scikit-learn platform functions for East.
+ *
+ * Provides core machine learning utilities: preprocessing, model selection, and metrics.
+ * Uses ONNX for model serialization to enable portable inference.
+ *
+ * @packageDocumentation
+ */
+import { StructType, VariantType, OptionType, IntegerType, BooleanType, FloatType, BlobType, ArrayType, StringType } from "@elaraai/east";
+export { VectorType, MatrixType, LabelVectorType } from "../types.js";
+export { XGBoostConfigType } from "../xgboost/xgboost.js";
+export { LightGBMConfigType } from "../lightgbm/lightgbm.js";
+export { NGBoostConfigType } from "../ngboost/ngboost.js";
+export { GPConfigType } from "../gp/gp.js";
+/**
+ * Configuration for train/test split.
+ */
+export declare const SplitConfigType: StructType<{
+    /** Proportion of data to include in test split (default 0.2) */
+    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.
+ */
+export declare const SplitResultType: StructType<{
+    /** Training features */
+    X_train: ArrayType<ArrayType<FloatType>>;
+    /** Test features */
+    X_test: ArrayType<ArrayType<FloatType>>;
+    /** Training labels */
+    y_train: ArrayType<FloatType>;
+    /** Test labels */
+    y_test: ArrayType<FloatType>;
+}>;
+/**
+ * Regression metrics result.
+ */
+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;
+}>;
+/**
+ * Classification metrics 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;
+}>;
+/**
+ * Model blob type for serialized sklearn models.
+ *
+ * Each model type has its own variant case containing ONNX bytes and metadata.
+ */
+export declare const SklearnModelBlobType: VariantType<{
+    /** StandardScaler model */
+    standard_scaler: StructType<{
+        /** ONNX model bytes */
+        onnx: BlobType;
+        /** Number of input features */
+        n_features: IntegerType;
+    }>;
+    /** MinMaxScaler model */
+    min_max_scaler: StructType<{
+        /** ONNX model bytes */
+        onnx: BlobType;
+        /** Number of input features */
+        n_features: IntegerType;
+    }>;
+    /** RegressorChain model */
+    regressor_chain: StructType<{
+        /** Cloudpickle serialized chain */
+        data: BlobType;
+        /** Number of input features */
+        n_features: IntegerType;
+        /** Number of target outputs */
+        n_targets: IntegerType;
+        /** Base estimator type name */
+        base_estimator_type: StringType;
+    }>;
+}>;
+/**
+ * Base estimator configuration for RegressorChain.
+ * Variant carries both the estimator type AND its configuration.
+ */
+export declare const RegressorChainBaseConfigType: VariantType<{
+    /** XGBoost regressor */
+    xgboost: StructType<{
+        n_estimators: OptionType<IntegerType>;
+        max_depth: OptionType<IntegerType>;
+        learning_rate: OptionType<FloatType>;
+        min_child_weight: OptionType<IntegerType>;
+        subsample: OptionType<FloatType>;
+        colsample_bytree: OptionType<FloatType>;
+        reg_alpha: OptionType<FloatType>;
+        reg_lambda: OptionType<FloatType>;
+        random_state: OptionType<IntegerType>;
+        n_jobs: OptionType<IntegerType>;
+    }>;
+    /** LightGBM regressor */
+    lightgbm: StructType<{
+        n_estimators: OptionType<IntegerType>;
+        max_depth: OptionType<IntegerType>;
+        learning_rate: OptionType<FloatType>;
+        num_leaves: OptionType<IntegerType>;
+        min_child_samples: OptionType<IntegerType>;
+        subsample: OptionType<FloatType>;
+        colsample_bytree: OptionType<FloatType>;
+        reg_alpha: OptionType<FloatType>;
+        reg_lambda: OptionType<FloatType>;
+        random_state: OptionType<IntegerType>;
+        n_jobs: OptionType<IntegerType>;
+    }>;
+    /** NGBoost regressor */
+    ngboost: StructType<{
+        n_estimators: OptionType<IntegerType>;
+        learning_rate: OptionType<FloatType>;
+        minibatch_frac: OptionType<FloatType>;
+        col_sample: OptionType<FloatType>;
+        random_state: OptionType<IntegerType>;
+        distribution: OptionType<VariantType<{
+            normal: StructType<{}>;
+            lognormal: StructType<{}>;
+        }>>;
+    }>;
+    /** 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<{}>;
+        }>>;
+        alpha: OptionType<FloatType>;
+        n_restarts_optimizer: OptionType<IntegerType>;
+        normalize_y: OptionType<BooleanType>;
+        random_state: OptionType<IntegerType>;
+    }>;
+}>;
+/**
+ * Configuration for RegressorChain.
+ */
+export declare const RegressorChainConfigType: StructType<{
+    /** Base estimator with its configuration */
+    base_estimator: VariantType<{
+        /** XGBoost regressor */
+        xgboost: StructType<{
+            n_estimators: OptionType<IntegerType>;
+            max_depth: OptionType<IntegerType>;
+            learning_rate: OptionType<FloatType>;
+            min_child_weight: OptionType<IntegerType>;
+            subsample: OptionType<FloatType>;
+            colsample_bytree: OptionType<FloatType>;
+            reg_alpha: OptionType<FloatType>;
+            reg_lambda: OptionType<FloatType>;
+            random_state: OptionType<IntegerType>;
+            n_jobs: OptionType<IntegerType>;
+        }>;
+        /** LightGBM regressor */
+        lightgbm: StructType<{
+            n_estimators: OptionType<IntegerType>;
+            max_depth: OptionType<IntegerType>;
+            learning_rate: OptionType<FloatType>;
+            num_leaves: OptionType<IntegerType>;
+            min_child_samples: OptionType<IntegerType>;
+            subsample: OptionType<FloatType>;
+            colsample_bytree: OptionType<FloatType>;
+            reg_alpha: OptionType<FloatType>;
+            reg_lambda: OptionType<FloatType>;
+            random_state: OptionType<IntegerType>;
+            n_jobs: OptionType<IntegerType>;
+        }>;
+        /** NGBoost regressor */
+        ngboost: StructType<{
+            n_estimators: OptionType<IntegerType>;
+            learning_rate: OptionType<FloatType>;
+            minibatch_frac: OptionType<FloatType>;
+            col_sample: OptionType<FloatType>;
+            random_state: OptionType<IntegerType>;
+            distribution: OptionType<VariantType<{
+                normal: StructType<{}>;
+                lognormal: StructType<{}>;
+            }>>;
+        }>;
+        /** 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<{}>;
+            }>>;
+            alpha: OptionType<FloatType>;
+            n_restarts_optimizer: OptionType<IntegerType>;
+            normalize_y: OptionType<BooleanType>;
+            random_state: OptionType<IntegerType>;
+        }>;
+    }>;
+    /** Chain order (indices of targets). None = natural order [0,1,2,...] */
+    order: OptionType<ArrayType<IntegerType>>;
+    /** Random seed for reproducibility */
+    random_state: OptionType<IntegerType>;
+}>;
+/**
+ * Split arrays into train and test subsets.
+ *
+ * @param X - Feature matrix
+ * @param y - Target vector
+ * @param config - Split configuration
+ * @returns Split result with X_train, X_test, y_train, y_test
+ */
+export declare const sklearn_train_test_split: import("@elaraai/east").PlatformDefinition<[ArrayType<ArrayType<FloatType>>, ArrayType<FloatType>, StructType<{
+    /** Proportion of data to include in test split (default 0.2) */
+    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>>;
+    /** Test features */
+    X_test: ArrayType<ArrayType<FloatType>>;
+    /** Training labels */
+    y_train: ArrayType<FloatType>;
+    /** Test labels */
+    y_test: ArrayType<FloatType>;
+}>>;
+/**
+ * Fit a StandardScaler to training data.
+ *
+ * Standardizes features by removing the mean and scaling to unit variance.
+ *
+ * @param X - Training feature matrix
+ * @returns Model blob containing fitted scaler
+ */
+export declare const sklearn_standard_scaler_fit: import("@elaraai/east").PlatformDefinition<[ArrayType<ArrayType<FloatType>>], VariantType<{
+    /** StandardScaler model */
+    standard_scaler: StructType<{
+        /** ONNX model bytes */
+        onnx: BlobType;
+        /** Number of input features */
+        n_features: IntegerType;
+    }>;
+    /** MinMaxScaler model */
+    min_max_scaler: StructType<{
+        /** ONNX model bytes */
+        onnx: BlobType;
+        /** Number of input features */
+        n_features: IntegerType;
+    }>;
+    /** RegressorChain model */
+    regressor_chain: StructType<{
+        /** Cloudpickle serialized chain */
+        data: BlobType;
+        /** Number of input features */
+        n_features: IntegerType;
+        /** Number of target outputs */
+        n_targets: IntegerType;
+        /** Base estimator type name */
+        base_estimator_type: StringType;
+    }>;
+}>>;
+/**
+ * Transform data using a fitted StandardScaler.
+ *
+ * @param model - Fitted scaler model blob
+ * @param X - Feature matrix to transform
+ * @returns Transformed feature matrix
+ */
+export declare const sklearn_standard_scaler_transform: import("@elaraai/east").PlatformDefinition<[VariantType<{
+    /** StandardScaler model */
+    standard_scaler: StructType<{
+        /** ONNX model bytes */
+        onnx: BlobType;
+        /** Number of input features */
+        n_features: IntegerType;
+    }>;
+    /** MinMaxScaler model */
+    min_max_scaler: StructType<{
+        /** ONNX model bytes */
+        onnx: BlobType;
+        /** Number of input features */
+        n_features: IntegerType;
+    }>;
+    /** RegressorChain model */
+    regressor_chain: StructType<{
+        /** Cloudpickle serialized chain */
+        data: BlobType;
+        /** Number of input features */
+        n_features: IntegerType;
+        /** Number of target outputs */
+        n_targets: IntegerType;
+        /** Base estimator type name */
+        base_estimator_type: StringType;
+    }>;
+}>, ArrayType<ArrayType<FloatType>>], ArrayType<ArrayType<FloatType>>>;
+/**
+ * Fit a MinMaxScaler to training data.
+ *
+ * Scales features to a given range (default [0, 1]).
+ *
+ * @param X - Training feature matrix
+ * @returns Model blob containing fitted scaler
+ */
+export declare const sklearn_min_max_scaler_fit: import("@elaraai/east").PlatformDefinition<[ArrayType<ArrayType<FloatType>>], VariantType<{
+    /** StandardScaler model */
+    standard_scaler: StructType<{
+        /** ONNX model bytes */
+        onnx: BlobType;
+        /** Number of input features */
+        n_features: IntegerType;
+    }>;
+    /** MinMaxScaler model */
+    min_max_scaler: StructType<{
+        /** ONNX model bytes */
+        onnx: BlobType;
+        /** Number of input features */
+        n_features: IntegerType;
+    }>;
+    /** RegressorChain model */
+    regressor_chain: StructType<{
+        /** Cloudpickle serialized chain */
+        data: BlobType;
+        /** Number of input features */
+        n_features: IntegerType;
+        /** Number of target outputs */
+        n_targets: IntegerType;
+        /** Base estimator type name */
+        base_estimator_type: StringType;
+    }>;
+}>>;
+/**
+ * Transform data using a fitted MinMaxScaler.
+ *
+ * @param model - Fitted scaler model blob
+ * @param X - Feature matrix to transform
+ * @returns Transformed feature matrix
+ */
+export declare const sklearn_min_max_scaler_transform: import("@elaraai/east").PlatformDefinition<[VariantType<{
+    /** StandardScaler model */
+    standard_scaler: StructType<{
+        /** ONNX model bytes */
+        onnx: BlobType;
+        /** Number of input features */
+        n_features: IntegerType;
+    }>;
+    /** MinMaxScaler model */
+    min_max_scaler: StructType<{
+        /** ONNX model bytes */
+        onnx: BlobType;
+        /** Number of input features */
+        n_features: IntegerType;
+    }>;
+    /** RegressorChain model */
+    regressor_chain: StructType<{
+        /** Cloudpickle serialized chain */
+        data: BlobType;
+        /** Number of input features */
+        n_features: IntegerType;
+        /** Number of target outputs */
+        n_targets: IntegerType;
+        /** Base estimator type name */
+        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.
+ *
+ * Each model in the chain uses previous targets as additional features,
+ * enabling modeling of dependencies between targets.
+ *
+ * @param X - Feature matrix
+ * @param Y - Target matrix (rows=samples, cols=targets)
+ * @param config - Chain configuration
+ * @returns Model blob containing fitted chain
+ */
+export declare const sklearn_regressor_chain_train: import("@elaraai/east").PlatformDefinition<[ArrayType<ArrayType<FloatType>>, ArrayType<ArrayType<FloatType>>, StructType<{
+    /** Base estimator with its configuration */
+    base_estimator: VariantType<{
+        /** XGBoost regressor */
+        xgboost: StructType<{
+            n_estimators: OptionType<IntegerType>;
+            max_depth: OptionType<IntegerType>;
+            learning_rate: OptionType<FloatType>;
+            min_child_weight: OptionType<IntegerType>;
+            subsample: OptionType<FloatType>;
+            colsample_bytree: OptionType<FloatType>;
+            reg_alpha: OptionType<FloatType>;
+            reg_lambda: OptionType<FloatType>;
+            random_state: OptionType<IntegerType>;
+            n_jobs: OptionType<IntegerType>;
+        }>;
+        /** LightGBM regressor */
+        lightgbm: StructType<{
+            n_estimators: OptionType<IntegerType>;
+            max_depth: OptionType<IntegerType>;
+            learning_rate: OptionType<FloatType>;
+            num_leaves: OptionType<IntegerType>;
+            min_child_samples: OptionType<IntegerType>;
+            subsample: OptionType<FloatType>;
+            colsample_bytree: OptionType<FloatType>;
+            reg_alpha: OptionType<FloatType>;
+            reg_lambda: OptionType<FloatType>;
+            random_state: OptionType<IntegerType>;
+            n_jobs: OptionType<IntegerType>;
+        }>;
+        /** NGBoost regressor */
+        ngboost: StructType<{
+            n_estimators: OptionType<IntegerType>;
+            learning_rate: OptionType<FloatType>;
+            minibatch_frac: OptionType<FloatType>;
+            col_sample: OptionType<FloatType>;
+            random_state: OptionType<IntegerType>;
+            distribution: OptionType<VariantType<{
+                normal: StructType<{}>;
+                lognormal: StructType<{}>;
+            }>>;
+        }>;
+        /** 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<{}>;
+            }>>;
+            alpha: OptionType<FloatType>;
+            n_restarts_optimizer: OptionType<IntegerType>;
+            normalize_y: OptionType<BooleanType>;
+            random_state: OptionType<IntegerType>;
+        }>;
+    }>;
+    /** Chain order (indices of targets). None = natural order [0,1,2,...] */
+    order: OptionType<ArrayType<IntegerType>>;
+    /** Random seed for reproducibility */
+    random_state: OptionType<IntegerType>;
+}>], VariantType<{
+    /** StandardScaler model */
+    standard_scaler: StructType<{
+        /** ONNX model bytes */
+        onnx: BlobType;
+        /** Number of input features */
+        n_features: IntegerType;
+    }>;
+    /** MinMaxScaler model */
+    min_max_scaler: StructType<{
+        /** ONNX model bytes */
+        onnx: BlobType;
+        /** Number of input features */
+        n_features: IntegerType;
+    }>;
+    /** RegressorChain model */
+    regressor_chain: StructType<{
+        /** Cloudpickle serialized chain */
+        data: BlobType;
+        /** Number of input features */
+        n_features: IntegerType;
+        /** Number of target outputs */
+        n_targets: IntegerType;
+        /** Base estimator type name */
+        base_estimator_type: StringType;
+    }>;
+}>>;
+/**
+ * Predict using a fitted RegressorChain.
+ *
+ * @param model - Fitted chain model blob
+ * @param X - Feature matrix to predict
+ * @returns Predicted target matrix
+ */
+export declare const sklearn_regressor_chain_predict: import("@elaraai/east").PlatformDefinition<[VariantType<{
+    /** StandardScaler model */
+    standard_scaler: StructType<{
+        /** ONNX model bytes */
+        onnx: BlobType;
+        /** Number of input features */
+        n_features: IntegerType;
+    }>;
+    /** MinMaxScaler model */
+    min_max_scaler: StructType<{
+        /** ONNX model bytes */
+        onnx: BlobType;
+        /** Number of input features */
+        n_features: IntegerType;
+    }>;
+    /** RegressorChain model */
+    regressor_chain: StructType<{
+        /** Cloudpickle serialized chain */
+        data: BlobType;
+        /** Number of input features */
+        n_features: IntegerType;
+        /** Number of target outputs */
+        n_targets: IntegerType;
+        /** Base estimator type name */
+        base_estimator_type: StringType;
+    }>;
+}>, ArrayType<ArrayType<FloatType>>], ArrayType<ArrayType<FloatType>>>;
+/**
+ * Type definitions for sklearn functions.
+ */
+export declare const SklearnTypes: {
+    /** Vector type (array of floats) */
+    readonly VectorType: ArrayType<FloatType>;
+    /** Matrix type (2D array of floats) */
+    readonly MatrixType: ArrayType<ArrayType<FloatType>>;
+    /** Label vector type (array of integers) */
+    readonly LabelVectorType: ArrayType<IntegerType>;
+    /** Split configuration type */
+    readonly SplitConfigType: StructType<{
+        /** Proportion of data to include in test split (default 0.2) */
+        test_size: OptionType<FloatType>;
+        /** Random seed for reproducibility */
+        random_state: OptionType<IntegerType>;
+        /** Whether to shuffle data before splitting (default true) */
+        shuffle: OptionType<BooleanType>;
+    }>;
+    /** Split result type */
+    readonly SplitResultType: StructType<{
+        /** Training features */
+        X_train: ArrayType<ArrayType<FloatType>>;
+        /** Test features */
+        X_test: ArrayType<ArrayType<FloatType>>;
+        /** Training labels */
+        y_train: ArrayType<FloatType>;
+        /** 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;
+    }>;
+    /** Model blob type for sklearn models */
+    readonly ModelBlobType: VariantType<{
+        /** StandardScaler model */
+        standard_scaler: StructType<{
+            /** ONNX model bytes */
+            onnx: BlobType;
+            /** Number of input features */
+            n_features: IntegerType;
+        }>;
+        /** MinMaxScaler model */
+        min_max_scaler: StructType<{
+            /** ONNX model bytes */
+            onnx: BlobType;
+            /** Number of input features */
+            n_features: IntegerType;
+        }>;
+        /** RegressorChain model */
+        regressor_chain: StructType<{
+            /** Cloudpickle serialized chain */
+            data: BlobType;
+            /** Number of input features */
+            n_features: IntegerType;
+            /** Number of target outputs */
+            n_targets: IntegerType;
+            /** Base estimator type name */
+            base_estimator_type: StringType;
+        }>;
+    }>;
+    /** Multi-target output type */
+    readonly MultiTargetType: ArrayType<ArrayType<FloatType>>;
+    /** RegressorChain base estimator config type */
+    readonly RegressorChainBaseConfigType: VariantType<{
+        /** XGBoost regressor */
+        xgboost: StructType<{
+            n_estimators: OptionType<IntegerType>;
+            max_depth: OptionType<IntegerType>;
+            learning_rate: OptionType<FloatType>;
+            min_child_weight: OptionType<IntegerType>;
+            subsample: OptionType<FloatType>;
+            colsample_bytree: OptionType<FloatType>;
+            reg_alpha: OptionType<FloatType>;
+            reg_lambda: OptionType<FloatType>;
+            random_state: OptionType<IntegerType>;
+            n_jobs: OptionType<IntegerType>;
+        }>;
+        /** LightGBM regressor */
+        lightgbm: StructType<{
+            n_estimators: OptionType<IntegerType>;
+            max_depth: OptionType<IntegerType>;
+            learning_rate: OptionType<FloatType>;
+            num_leaves: OptionType<IntegerType>;
+            min_child_samples: OptionType<IntegerType>;
+            subsample: OptionType<FloatType>;
+            colsample_bytree: OptionType<FloatType>;
+            reg_alpha: OptionType<FloatType>;
+            reg_lambda: OptionType<FloatType>;
+            random_state: OptionType<IntegerType>;
+            n_jobs: OptionType<IntegerType>;
+        }>;
+        /** NGBoost regressor */
+        ngboost: StructType<{
+            n_estimators: OptionType<IntegerType>;
+            learning_rate: OptionType<FloatType>;
+            minibatch_frac: OptionType<FloatType>;
+            col_sample: OptionType<FloatType>;
+            random_state: OptionType<IntegerType>;
+            distribution: OptionType<VariantType<{
+                normal: StructType<{}>;
+                lognormal: StructType<{}>;
+            }>>;
+        }>;
+        /** 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<{}>;
+            }>>;
+            alpha: OptionType<FloatType>;
+            n_restarts_optimizer: OptionType<IntegerType>;
+            normalize_y: OptionType<BooleanType>;
+            random_state: OptionType<IntegerType>;
+        }>;
+    }>;
+    /** RegressorChain config type */
+    readonly RegressorChainConfigType: StructType<{
+        /** Base estimator with its configuration */
+        base_estimator: VariantType<{
+            /** XGBoost regressor */
+            xgboost: StructType<{
+                n_estimators: OptionType<IntegerType>;
+                max_depth: OptionType<IntegerType>;
+                learning_rate: OptionType<FloatType>;
+                min_child_weight: OptionType<IntegerType>;
+                subsample: OptionType<FloatType>;
+                colsample_bytree: OptionType<FloatType>;
+                reg_alpha: OptionType<FloatType>;
+                reg_lambda: OptionType<FloatType>;
+                random_state: OptionType<IntegerType>;
+                n_jobs: OptionType<IntegerType>;
+            }>;
+            /** LightGBM regressor */
+            lightgbm: StructType<{
+                n_estimators: OptionType<IntegerType>;
+                max_depth: OptionType<IntegerType>;
+                learning_rate: OptionType<FloatType>;
+                num_leaves: OptionType<IntegerType>;
+                min_child_samples: OptionType<IntegerType>;
+                subsample: OptionType<FloatType>;
+                colsample_bytree: OptionType<FloatType>;
+                reg_alpha: OptionType<FloatType>;
+                reg_lambda: OptionType<FloatType>;
+                random_state: OptionType<IntegerType>;
+                n_jobs: OptionType<IntegerType>;
+            }>;
+            /** NGBoost regressor */
+            ngboost: StructType<{
+                n_estimators: OptionType<IntegerType>;
+                learning_rate: OptionType<FloatType>;
+                minibatch_frac: OptionType<FloatType>;
+                col_sample: OptionType<FloatType>;
+                random_state: OptionType<IntegerType>;
+                distribution: OptionType<VariantType<{
+                    normal: StructType<{}>;
+                    lognormal: StructType<{}>;
+                }>>;
+            }>;
+            /** 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<{}>;
+                }>>;
+                alpha: OptionType<FloatType>;
+                n_restarts_optimizer: OptionType<IntegerType>;
+                normalize_y: OptionType<BooleanType>;
+                random_state: OptionType<IntegerType>;
+            }>;
+        }>;
+        /** Chain order (indices of targets). None = natural order [0,1,2,...] */
+        order: OptionType<ArrayType<IntegerType>>;
+        /** Random seed for reproducibility */
+        random_state: OptionType<IntegerType>;
+    }>;
+};
+/**
+ * Scikit-learn machine learning utilities.
+ *
+ * Provides preprocessing, model selection, and metrics for ML workflows.
+ *
+ * @example
+ * ```ts
+ * import { East, variant } from "@elaraai/east";
+ * import { Sklearn } from "@elaraai/east-py-datascience";
+ *
+ * const pipeline = East.function([], Sklearn.Types.SplitResultType, $ => {
+ *     const X = $.let([[1.0, 2.0], [3.0, 4.0], [5.0, 6.0], [7.0, 8.0]]);
+ *     const y = $.let([1.0, 2.0, 3.0, 4.0]);
+ *     const config = $.let({
+ *         test_size: variant('some', 0.25),
+ *         random_state: variant('some', 42n),
+ *         shuffle: variant('some', true),
+ *     });
+ *     return $.return(Sklearn.trainTestSplit(X, y, config));
+ * });
+ * ```
+ */
+export declare const Sklearn: {
+    /** Split arrays into train and test subsets */
+    readonly trainTestSplit: import("@elaraai/east").PlatformDefinition<[ArrayType<ArrayType<FloatType>>, ArrayType<FloatType>, StructType<{
+        /** Proportion of data to include in test split (default 0.2) */
+        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>>;
+        /** Test features */
+        X_test: ArrayType<ArrayType<FloatType>>;
+        /** Training labels */
+        y_train: ArrayType<FloatType>;
+        /** Test labels */
+        y_test: ArrayType<FloatType>;
+    }>>;
+    /** Fit a StandardScaler to data */
+    readonly standardScalerFit: import("@elaraai/east").PlatformDefinition<[ArrayType<ArrayType<FloatType>>], VariantType<{
+        /** StandardScaler model */
+        standard_scaler: StructType<{
+            /** ONNX model bytes */
+            onnx: BlobType;
+            /** Number of input features */
+            n_features: IntegerType;
+        }>;
+        /** MinMaxScaler model */
+        min_max_scaler: StructType<{
+            /** ONNX model bytes */
+            onnx: BlobType;
+            /** Number of input features */
+            n_features: IntegerType;
+        }>;
+        /** RegressorChain model */
+        regressor_chain: StructType<{
+            /** Cloudpickle serialized chain */
+            data: BlobType;
+            /** Number of input features */
+            n_features: IntegerType;
+            /** Number of target outputs */
+            n_targets: IntegerType;
+            /** Base estimator type name */
+            base_estimator_type: StringType;
+        }>;
+    }>>;
+    /** Transform data using fitted StandardScaler */
+    readonly standardScalerTransform: import("@elaraai/east").PlatformDefinition<[VariantType<{
+        /** StandardScaler model */
+        standard_scaler: StructType<{
+            /** ONNX model bytes */
+            onnx: BlobType;
+            /** Number of input features */
+            n_features: IntegerType;
+        }>;
+        /** MinMaxScaler model */
+        min_max_scaler: StructType<{
+            /** ONNX model bytes */
+            onnx: BlobType;
+            /** Number of input features */
+            n_features: IntegerType;
+        }>;
+        /** RegressorChain model */
+        regressor_chain: StructType<{
+            /** Cloudpickle serialized chain */
+            data: BlobType;
+            /** Number of input features */
+            n_features: IntegerType;
+            /** Number of target outputs */
+            n_targets: IntegerType;
+            /** Base estimator type name */
+            base_estimator_type: StringType;
+        }>;
+    }>, ArrayType<ArrayType<FloatType>>], ArrayType<ArrayType<FloatType>>>;
+    /** Fit a MinMaxScaler to data */
+    readonly minMaxScalerFit: import("@elaraai/east").PlatformDefinition<[ArrayType<ArrayType<FloatType>>], VariantType<{
+        /** StandardScaler model */
+        standard_scaler: StructType<{
+            /** ONNX model bytes */
+            onnx: BlobType;
+            /** Number of input features */
+            n_features: IntegerType;
+        }>;
+        /** MinMaxScaler model */
+        min_max_scaler: StructType<{
+            /** ONNX model bytes */
+            onnx: BlobType;
+            /** Number of input features */
+            n_features: IntegerType;
+        }>;
+        /** RegressorChain model */
+        regressor_chain: StructType<{
+            /** Cloudpickle serialized chain */
+            data: BlobType;
+            /** Number of input features */
+            n_features: IntegerType;
+            /** Number of target outputs */
+            n_targets: IntegerType;
+            /** Base estimator type name */
+            base_estimator_type: StringType;
+        }>;
+    }>>;
+    /** Transform data using fitted MinMaxScaler */
+    readonly minMaxScalerTransform: import("@elaraai/east").PlatformDefinition<[VariantType<{
+        /** StandardScaler model */
+        standard_scaler: StructType<{
+            /** ONNX model bytes */
+            onnx: BlobType;
+            /** Number of input features */
+            n_features: IntegerType;
+        }>;
+        /** MinMaxScaler model */
+        min_max_scaler: StructType<{
+            /** ONNX model bytes */
+            onnx: BlobType;
+            /** Number of input features */
+            n_features: IntegerType;
+        }>;
+        /** RegressorChain model */
+        regressor_chain: StructType<{
+            /** Cloudpickle serialized chain */
+            data: BlobType;
+            /** Number of input features */
+            n_features: IntegerType;
+            /** Number of target outputs */
+            n_targets: IntegerType;
+            /** Base estimator type name */
+            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;
+    }>>;
+    /** 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 */
+        base_estimator: VariantType<{
+            /** XGBoost regressor */
+            xgboost: StructType<{
+                n_estimators: OptionType<IntegerType>;
+                max_depth: OptionType<IntegerType>;
+                learning_rate: OptionType<FloatType>;
+                min_child_weight: OptionType<IntegerType>;
+                subsample: OptionType<FloatType>;
+                colsample_bytree: OptionType<FloatType>;
+                reg_alpha: OptionType<FloatType>;
+                reg_lambda: OptionType<FloatType>;
+                random_state: OptionType<IntegerType>;
+                n_jobs: OptionType<IntegerType>;
+            }>;
+            /** LightGBM regressor */
+            lightgbm: StructType<{
+                n_estimators: OptionType<IntegerType>;
+                max_depth: OptionType<IntegerType>;
+                learning_rate: OptionType<FloatType>;
+                num_leaves: OptionType<IntegerType>;
+                min_child_samples: OptionType<IntegerType>;
+                subsample: OptionType<FloatType>;
+                colsample_bytree: OptionType<FloatType>;
+                reg_alpha: OptionType<FloatType>;
+                reg_lambda: OptionType<FloatType>;
+                random_state: OptionType<IntegerType>;
+                n_jobs: OptionType<IntegerType>;
+            }>;
+            /** NGBoost regressor */
+            ngboost: StructType<{
+                n_estimators: OptionType<IntegerType>;
+                learning_rate: OptionType<FloatType>;
+                minibatch_frac: OptionType<FloatType>;
+                col_sample: OptionType<FloatType>;
+                random_state: OptionType<IntegerType>;
+                distribution: OptionType<VariantType<{
+                    normal: StructType<{}>;
+                    lognormal: StructType<{}>;
+                }>>;
+            }>;
+            /** 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<{}>;
+                }>>;
+                alpha: OptionType<FloatType>;
+                n_restarts_optimizer: OptionType<IntegerType>;
+                normalize_y: OptionType<BooleanType>;
+                random_state: OptionType<IntegerType>;
+            }>;
+        }>;
+        /** Chain order (indices of targets). None = natural order [0,1,2,...] */
+        order: OptionType<ArrayType<IntegerType>>;
+        /** Random seed for reproducibility */
+        random_state: OptionType<IntegerType>;
+    }>], VariantType<{
+        /** StandardScaler model */
+        standard_scaler: StructType<{
+            /** ONNX model bytes */
+            onnx: BlobType;
+            /** Number of input features */
+            n_features: IntegerType;
+        }>;
+        /** MinMaxScaler model */
+        min_max_scaler: StructType<{
+            /** ONNX model bytes */
+            onnx: BlobType;
+            /** Number of input features */
+            n_features: IntegerType;
+        }>;
+        /** RegressorChain model */
+        regressor_chain: StructType<{
+            /** Cloudpickle serialized chain */
+            data: BlobType;
+            /** Number of input features */
+            n_features: IntegerType;
+            /** Number of target outputs */
+            n_targets: IntegerType;
+            /** Base estimator type name */
+            base_estimator_type: StringType;
+        }>;
+    }>>;
+    /** Predict using a fitted RegressorChain */
+    readonly regressorChainPredict: import("@elaraai/east").PlatformDefinition<[VariantType<{
+        /** StandardScaler model */
+        standard_scaler: StructType<{
+            /** ONNX model bytes */
+            onnx: BlobType;
+            /** Number of input features */
+            n_features: IntegerType;
+        }>;
+        /** MinMaxScaler model */
+        min_max_scaler: StructType<{
+            /** ONNX model bytes */
+            onnx: BlobType;
+            /** Number of input features */
+            n_features: IntegerType;
+        }>;
+        /** RegressorChain model */
+        regressor_chain: StructType<{
+            /** Cloudpickle serialized chain */
+            data: BlobType;
+            /** Number of input features */
+            n_features: IntegerType;
+            /** Number of target outputs */
+            n_targets: IntegerType;
+            /** Base estimator type name */
+            base_estimator_type: StringType;
+        }>;
+    }>, ArrayType<ArrayType<FloatType>>], ArrayType<ArrayType<FloatType>>>;
+    /** Type definitions */
+    readonly Types: {
+        /** Vector type (array of floats) */
+        readonly VectorType: ArrayType<FloatType>;
+        /** Matrix type (2D array of floats) */
+        readonly MatrixType: ArrayType<ArrayType<FloatType>>;
+        /** Label vector type (array of integers) */
+        readonly LabelVectorType: ArrayType<IntegerType>;
+        /** Split configuration type */
+        readonly SplitConfigType: StructType<{
+            /** Proportion of data to include in test split (default 0.2) */
+            test_size: OptionType<FloatType>;
+            /** Random seed for reproducibility */
+            random_state: OptionType<IntegerType>;
+            /** Whether to shuffle data before splitting (default true) */
+            shuffle: OptionType<BooleanType>;
+        }>;
+        /** Split result type */
+        readonly SplitResultType: StructType<{
+            /** Training features */
+            X_train: ArrayType<ArrayType<FloatType>>;
+            /** Test features */
+            X_test: ArrayType<ArrayType<FloatType>>;
+            /** Training labels */
+            y_train: ArrayType<FloatType>;
+            /** 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;
+        }>;
+        /** Model blob type for sklearn models */
+        readonly ModelBlobType: VariantType<{
+            /** StandardScaler model */
+            standard_scaler: StructType<{
+                /** ONNX model bytes */
+                onnx: BlobType;
+                /** Number of input features */
+                n_features: IntegerType;
+            }>;
+            /** MinMaxScaler model */
+            min_max_scaler: StructType<{
+                /** ONNX model bytes */
+                onnx: BlobType;
+                /** Number of input features */
+                n_features: IntegerType;
+            }>;
+            /** RegressorChain model */
+            regressor_chain: StructType<{
+                /** Cloudpickle serialized chain */
+                data: BlobType;
+                /** Number of input features */
+                n_features: IntegerType;
+                /** Number of target outputs */
+                n_targets: IntegerType;
+                /** Base estimator type name */
+                base_estimator_type: StringType;
+            }>;
+        }>;
+        /** Multi-target output type */
+        readonly MultiTargetType: ArrayType<ArrayType<FloatType>>;
+        /** RegressorChain base estimator config type */
+        readonly RegressorChainBaseConfigType: VariantType<{
+            /** XGBoost regressor */
+            xgboost: StructType<{
+                n_estimators: OptionType<IntegerType>;
+                max_depth: OptionType<IntegerType>;
+                learning_rate: OptionType<FloatType>;
+                min_child_weight: OptionType<IntegerType>;
+                subsample: OptionType<FloatType>;
+                colsample_bytree: OptionType<FloatType>;
+                reg_alpha: OptionType<FloatType>;
+                reg_lambda: OptionType<FloatType>;
+                random_state: OptionType<IntegerType>;
+                n_jobs: OptionType<IntegerType>;
+            }>;
+            /** LightGBM regressor */
+            lightgbm: StructType<{
+                n_estimators: OptionType<IntegerType>;
+                max_depth: OptionType<IntegerType>;
+                learning_rate: OptionType<FloatType>;
+                num_leaves: OptionType<IntegerType>;
+                min_child_samples: OptionType<IntegerType>;
+                subsample: OptionType<FloatType>;
+                colsample_bytree: OptionType<FloatType>;
+                reg_alpha: OptionType<FloatType>;
+                reg_lambda: OptionType<FloatType>;
+                random_state: OptionType<IntegerType>;
+                n_jobs: OptionType<IntegerType>;
+            }>;
+            /** NGBoost regressor */
+            ngboost: StructType<{
+                n_estimators: OptionType<IntegerType>;
+                learning_rate: OptionType<FloatType>;
+                minibatch_frac: OptionType<FloatType>;
+                col_sample: OptionType<FloatType>;
+                random_state: OptionType<IntegerType>;
+                distribution: OptionType<VariantType<{
+                    normal: StructType<{}>;
+                    lognormal: StructType<{}>;
+                }>>;
+            }>;
+            /** 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<{}>;
+                }>>;
+                alpha: OptionType<FloatType>;
+                n_restarts_optimizer: OptionType<IntegerType>;
+                normalize_y: OptionType<BooleanType>;
+                random_state: OptionType<IntegerType>;
+            }>;
+        }>;
+        /** RegressorChain config type */
+        readonly RegressorChainConfigType: StructType<{
+            /** Base estimator with its configuration */
+            base_estimator: VariantType<{
+                /** XGBoost regressor */
+                xgboost: StructType<{
+                    n_estimators: OptionType<IntegerType>;
+                    max_depth: OptionType<IntegerType>;
+                    learning_rate: OptionType<FloatType>;
+                    min_child_weight: OptionType<IntegerType>;
+                    subsample: OptionType<FloatType>;
+                    colsample_bytree: OptionType<FloatType>;
+                    reg_alpha: OptionType<FloatType>;
+                    reg_lambda: OptionType<FloatType>;
+                    random_state: OptionType<IntegerType>;
+                    n_jobs: OptionType<IntegerType>;
+                }>;
+                /** LightGBM regressor */
+                lightgbm: StructType<{
+                    n_estimators: OptionType<IntegerType>;
+                    max_depth: OptionType<IntegerType>;
+                    learning_rate: OptionType<FloatType>;
+                    num_leaves: OptionType<IntegerType>;
+                    min_child_samples: OptionType<IntegerType>;
+                    subsample: OptionType<FloatType>;
+                    colsample_bytree: OptionType<FloatType>;
+                    reg_alpha: OptionType<FloatType>;
+                    reg_lambda: OptionType<FloatType>;
+                    random_state: OptionType<IntegerType>;
+                    n_jobs: OptionType<IntegerType>;
+                }>;
+                /** NGBoost regressor */
+                ngboost: StructType<{
+                    n_estimators: OptionType<IntegerType>;
+                    learning_rate: OptionType<FloatType>;
+                    minibatch_frac: OptionType<FloatType>;
+                    col_sample: OptionType<FloatType>;
+                    random_state: OptionType<IntegerType>;
+                    distribution: OptionType<VariantType<{
+                        normal: StructType<{}>;
+                        lognormal: StructType<{}>;
+                    }>>;
+                }>;
+                /** 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<{}>;
+                    }>>;
+                    alpha: OptionType<FloatType>;
+                    n_restarts_optimizer: OptionType<IntegerType>;
+                    normalize_y: OptionType<BooleanType>;
+                    random_state: OptionType<IntegerType>;
+                }>;
+            }>;
+            /** Chain order (indices of targets). None = natural order [0,1,2,...] */
+            order: OptionType<ArrayType<IntegerType>>;
+            /** Random seed for reproducibility */
+            random_state: OptionType<IntegerType>;
+        }>;
+    };
+};
+//# sourceMappingURL=sklearn.d.ts.map