@elaraai/east-py-datascience 0.0.2-beta.6 → 0.0.2-beta.61

package/dist/mapie/mapie.d.ts

@@ -0,0 +1,2058 @@
+/**
+ * Copyright (c) 2025 Elara AI Pty Ltd
+ * Dual-licensed under AGPL-3.0 and commercial license. See LICENSE for details.
+ */
+/**
+ * MAPIE conformal prediction intervals for East.
+ *
+ * Provides prediction intervals with coverage guarantees using
+ * conformal prediction methods (MAPIE 1.2.0 API).
+ *
+ * @packageDocumentation
+ */
+import { StructType, VariantType, OptionType, ArrayType, IntegerType, FloatType, BlobType, NullType } from "@elaraai/east";
+export { VectorType, MatrixType, LabelVectorType } from "../types.js";
+export { XGBoostConfigType } from "../xgboost/xgboost.js";
+export { LightGBMConfigType } from "../lightgbm/lightgbm.js";
+/**
+ * Conformal prediction method for regression.
+ */
+export declare const ConformalMethodType: VariantType<{
+    /** Split conformal - requires separate calibration set */
+    readonly split: NullType;
+    /** Cross conformal - uses CV for calibration (combines train + calib) */
+    readonly cross: NullType;
+}>;
+/**
+ * Base model type for MAPIE regression.
+ * Uses full XGBoost/LightGBM config types for complete parameter support.
+ */
+export declare const BaseModelType: VariantType<{
+    /** XGBoost regressor as base model */
+    readonly xgboost: StructType<{
+        readonly n_estimators: OptionType<IntegerType>;
+        readonly max_depth: OptionType<IntegerType>;
+        readonly learning_rate: OptionType<FloatType>;
+        readonly min_child_weight: OptionType<IntegerType>;
+        readonly subsample: OptionType<FloatType>;
+        readonly colsample_bytree: OptionType<FloatType>;
+        readonly reg_alpha: OptionType<FloatType>;
+        readonly reg_lambda: OptionType<FloatType>;
+        readonly gamma: OptionType<FloatType>;
+        readonly random_state: OptionType<IntegerType>;
+        readonly n_jobs: OptionType<IntegerType>;
+        readonly sample_weight: OptionType<ArrayType<FloatType>>;
+        readonly categorical_features: OptionType<ArrayType<IntegerType>>;
+        readonly max_cat_to_onehot: OptionType<IntegerType>;
+        readonly max_cat_threshold: OptionType<IntegerType>;
+    }>;
+    /** LightGBM regressor as base model */
+    readonly lightgbm: StructType<{
+        readonly n_estimators: OptionType<IntegerType>;
+        readonly max_depth: OptionType<IntegerType>;
+        readonly learning_rate: OptionType<FloatType>;
+        readonly num_leaves: OptionType<IntegerType>;
+        readonly min_child_samples: OptionType<IntegerType>;
+        readonly subsample: OptionType<FloatType>;
+        readonly colsample_bytree: OptionType<FloatType>;
+        readonly reg_alpha: OptionType<FloatType>;
+        readonly reg_lambda: OptionType<FloatType>;
+        readonly random_state: OptionType<IntegerType>;
+        readonly n_jobs: OptionType<IntegerType>;
+    }>;
+}>;
+/**
+ * Configuration for MAPIE conformal prediction.
+ */
+export declare const MAPIEConfigType: StructType<{
+    /** Base model configuration */
+    readonly base_model: VariantType<{
+        /** XGBoost regressor as base model */
+        readonly xgboost: StructType<{
+            readonly n_estimators: OptionType<IntegerType>;
+            readonly max_depth: OptionType<IntegerType>;
+            readonly learning_rate: OptionType<FloatType>;
+            readonly min_child_weight: OptionType<IntegerType>;
+            readonly subsample: OptionType<FloatType>;
+            readonly colsample_bytree: OptionType<FloatType>;
+            readonly reg_alpha: OptionType<FloatType>;
+            readonly reg_lambda: OptionType<FloatType>;
+            readonly gamma: OptionType<FloatType>;
+            readonly random_state: OptionType<IntegerType>;
+            readonly n_jobs: OptionType<IntegerType>;
+            readonly sample_weight: OptionType<ArrayType<FloatType>>;
+            readonly categorical_features: OptionType<ArrayType<IntegerType>>;
+            readonly max_cat_to_onehot: OptionType<IntegerType>;
+            readonly max_cat_threshold: OptionType<IntegerType>;
+        }>;
+        /** LightGBM regressor as base model */
+        readonly lightgbm: StructType<{
+            readonly n_estimators: OptionType<IntegerType>;
+            readonly max_depth: OptionType<IntegerType>;
+            readonly learning_rate: OptionType<FloatType>;
+            readonly num_leaves: OptionType<IntegerType>;
+            readonly min_child_samples: OptionType<IntegerType>;
+            readonly subsample: OptionType<FloatType>;
+            readonly colsample_bytree: OptionType<FloatType>;
+            readonly reg_alpha: OptionType<FloatType>;
+            readonly reg_lambda: OptionType<FloatType>;
+            readonly random_state: OptionType<IntegerType>;
+            readonly n_jobs: OptionType<IntegerType>;
+        }>;
+    }>;
+    /** Conformal method (default: split) */
+    readonly method: OptionType<VariantType<{
+        /** Split conformal - requires separate calibration set */
+        readonly split: NullType;
+        /** Cross conformal - uses CV for calibration (combines train + calib) */
+        readonly cross: NullType;
+    }>>;
+    /** Confidence level: coverage probability (default 0.9 = 90% intervals) */
+    readonly confidence_level: OptionType<FloatType>;
+    /** Number of CV folds for cross method (default 5) */
+    readonly cv_folds: OptionType<IntegerType>;
+    /** Random seed for reproducibility */
+    readonly random_state: OptionType<IntegerType>;
+    /** Conformity score consistency check tolerance (default 1e-04) */
+    readonly conformity_eps: OptionType<FloatType>;
+}>;
+/**
+ * Configuration for CQR (Conformalized Quantile Regression).
+ * Requires a base model that supports quantile regression (XGBoost).
+ */
+export declare const MAPIECQRConfigType: StructType<{
+    /** XGBoost config for the base quantile model */
+    readonly xgboost_config: StructType<{
+        readonly n_estimators: OptionType<IntegerType>;
+        readonly max_depth: OptionType<IntegerType>;
+        readonly learning_rate: OptionType<FloatType>;
+        readonly min_child_weight: OptionType<IntegerType>;
+        readonly subsample: OptionType<FloatType>;
+        readonly colsample_bytree: OptionType<FloatType>;
+        readonly reg_alpha: OptionType<FloatType>;
+        readonly reg_lambda: OptionType<FloatType>;
+        readonly gamma: OptionType<FloatType>;
+        readonly random_state: OptionType<IntegerType>;
+        readonly n_jobs: OptionType<IntegerType>;
+        readonly sample_weight: OptionType<ArrayType<FloatType>>;
+        readonly categorical_features: OptionType<ArrayType<IntegerType>>;
+        readonly max_cat_to_onehot: OptionType<IntegerType>;
+        readonly max_cat_threshold: OptionType<IntegerType>;
+    }>;
+    /** Confidence level: coverage probability (default 0.9 = 90% intervals) */
+    readonly confidence_level: OptionType<FloatType>;
+    /** Random seed for reproducibility */
+    readonly random_state: OptionType<IntegerType>;
+}>;
+/**
+ * Classification conformal method (conformity score).
+ */
+export declare const ClassificationMethodType: VariantType<{
+    /** Least Ambiguous set-valued Classifier - smallest sets */
+    readonly lac: NullType;
+    /** Adaptive Prediction Sets - adapts to probabilities */
+    readonly aps: NullType;
+}>;
+/**
+ * Base classifier type for MAPIE classification.
+ * Uses full XGBoost/LightGBM config types for complete parameter support.
+ */
+export declare const BaseClassifierType: VariantType<{
+    /** XGBoost classifier as base model */
+    readonly xgboost: StructType<{
+        readonly n_estimators: OptionType<IntegerType>;
+        readonly max_depth: OptionType<IntegerType>;
+        readonly learning_rate: OptionType<FloatType>;
+        readonly min_child_weight: OptionType<IntegerType>;
+        readonly subsample: OptionType<FloatType>;
+        readonly colsample_bytree: OptionType<FloatType>;
+        readonly reg_alpha: OptionType<FloatType>;
+        readonly reg_lambda: OptionType<FloatType>;
+        readonly gamma: OptionType<FloatType>;
+        readonly random_state: OptionType<IntegerType>;
+        readonly n_jobs: OptionType<IntegerType>;
+        readonly sample_weight: OptionType<ArrayType<FloatType>>;
+        readonly categorical_features: OptionType<ArrayType<IntegerType>>;
+        readonly max_cat_to_onehot: OptionType<IntegerType>;
+        readonly max_cat_threshold: OptionType<IntegerType>;
+    }>;
+    /** LightGBM classifier as base model */
+    readonly lightgbm: StructType<{
+        readonly n_estimators: OptionType<IntegerType>;
+        readonly max_depth: OptionType<IntegerType>;
+        readonly learning_rate: OptionType<FloatType>;
+        readonly num_leaves: OptionType<IntegerType>;
+        readonly min_child_samples: OptionType<IntegerType>;
+        readonly subsample: OptionType<FloatType>;
+        readonly colsample_bytree: OptionType<FloatType>;
+        readonly reg_alpha: OptionType<FloatType>;
+        readonly reg_lambda: OptionType<FloatType>;
+        readonly random_state: OptionType<IntegerType>;
+        readonly n_jobs: OptionType<IntegerType>;
+    }>;
+}>;
+/**
+ * Configuration for MAPIE conformal classification.
+ */
+export declare const MAPIEClassifierConfigType: StructType<{
+    /** Base classifier configuration */
+    readonly base_model: VariantType<{
+        /** XGBoost classifier as base model */
+        readonly xgboost: StructType<{
+            readonly n_estimators: OptionType<IntegerType>;
+            readonly max_depth: OptionType<IntegerType>;
+            readonly learning_rate: OptionType<FloatType>;
+            readonly min_child_weight: OptionType<IntegerType>;
+            readonly subsample: OptionType<FloatType>;
+            readonly colsample_bytree: OptionType<FloatType>;
+            readonly reg_alpha: OptionType<FloatType>;
+            readonly reg_lambda: OptionType<FloatType>;
+            readonly gamma: OptionType<FloatType>;
+            readonly random_state: OptionType<IntegerType>;
+            readonly n_jobs: OptionType<IntegerType>;
+            readonly sample_weight: OptionType<ArrayType<FloatType>>;
+            readonly categorical_features: OptionType<ArrayType<IntegerType>>;
+            readonly max_cat_to_onehot: OptionType<IntegerType>;
+            readonly max_cat_threshold: OptionType<IntegerType>;
+        }>;
+        /** LightGBM classifier as base model */
+        readonly lightgbm: StructType<{
+            readonly n_estimators: OptionType<IntegerType>;
+            readonly max_depth: OptionType<IntegerType>;
+            readonly learning_rate: OptionType<FloatType>;
+            readonly num_leaves: OptionType<IntegerType>;
+            readonly min_child_samples: OptionType<IntegerType>;
+            readonly subsample: OptionType<FloatType>;
+            readonly colsample_bytree: OptionType<FloatType>;
+            readonly reg_alpha: OptionType<FloatType>;
+            readonly reg_lambda: OptionType<FloatType>;
+            readonly random_state: OptionType<IntegerType>;
+            readonly n_jobs: OptionType<IntegerType>;
+        }>;
+    }>;
+    /** Classification conformity score method (default: lac) */
+    readonly method: OptionType<VariantType<{
+        /** Least Ambiguous set-valued Classifier - smallest sets */
+        readonly lac: NullType;
+        /** Adaptive Prediction Sets - adapts to probabilities */
+        readonly aps: NullType;
+    }>>;
+    /** Confidence level: coverage probability (default 0.9 = 90% coverage) */
+    readonly confidence_level: OptionType<FloatType>;
+    /** Random seed for reproducibility */
+    readonly random_state: OptionType<IntegerType>;
+}>;
+/**
+ * Tagged model data - variant tag indicates base model type, value is the serialized blob.
+ * This pattern encodes the model type in the variant tag rather than a separate field.
+ */
+export declare const MAPIEBaseModelDataType: VariantType<{
+    /** XGBoost-based model (cloudpickle serialized) */
+    readonly xgboost: BlobType;
+    /** LightGBM-based model (cloudpickle serialized) */
+    readonly lightgbm: BlobType;
+    /** Histogram-based model (sklearn HistGradientBoosting, used by CQR) */
+    readonly histogram: BlobType;
+}>;
+/**
+ * Model blob for MAPIE conformal regressor.
+ */
+export declare const MAPIERegressorBlobType: VariantType<{
+    /** MAPIE regressor with split conformal */
+    readonly mapie_split: StructType<{
+        /** Serialized model - variant tag indicates base model type (xgboost/lightgbm) */
+        readonly data: VariantType<{
+            /** XGBoost-based model (cloudpickle serialized) */
+            readonly xgboost: BlobType;
+            /** LightGBM-based model (cloudpickle serialized) */
+            readonly lightgbm: BlobType;
+            /** Histogram-based model (sklearn HistGradientBoosting, used by CQR) */
+            readonly histogram: BlobType;
+        }>;
+        /** Number of input features */
+        readonly n_features: IntegerType;
+        /** Confidence level used during calibration */
+        readonly confidence_level: FloatType;
+    }>;
+    /** MAPIE regressor with cross conformal */
+    readonly mapie_cross: StructType<{
+        /** Serialized model - variant tag indicates base model type (xgboost/lightgbm) */
+        readonly data: VariantType<{
+            /** XGBoost-based model (cloudpickle serialized) */
+            readonly xgboost: BlobType;
+            /** LightGBM-based model (cloudpickle serialized) */
+            readonly lightgbm: BlobType;
+            /** Histogram-based model (sklearn HistGradientBoosting, used by CQR) */
+            readonly histogram: BlobType;
+        }>;
+        /** Number of input features */
+        readonly n_features: IntegerType;
+        /** Confidence level used during calibration */
+        readonly confidence_level: FloatType;
+    }>;
+    /** MAPIE CQR regressor (uses HistGradientBoosting internally) */
+    readonly mapie_cqr: StructType<{
+        /** Serialized model - variant tag indicates base model type */
+        readonly data: VariantType<{
+            /** XGBoost-based model (cloudpickle serialized) */
+            readonly xgboost: BlobType;
+            /** LightGBM-based model (cloudpickle serialized) */
+            readonly lightgbm: BlobType;
+            /** Histogram-based model (sklearn HistGradientBoosting, used by CQR) */
+            readonly histogram: BlobType;
+        }>;
+        /** Number of input features */
+        readonly n_features: IntegerType;
+        /** Confidence level used during calibration */
+        readonly confidence_level: FloatType;
+    }>;
+}>;
+/**
+ * Model blob for MAPIE conformal classifier.
+ * Uses single-case variant for consistency with MAPIERegressorBlobType and AnyModelBlobType.
+ */
+export declare const MAPIEClassifierBlobType: VariantType<{
+    /** MAPIE classifier with split conformal */
+    readonly mapie_classifier: StructType<{
+        /** Serialized model - variant tag indicates base model type (xgboost/lightgbm) */
+        readonly data: VariantType<{
+            /** XGBoost-based model (cloudpickle serialized) */
+            readonly xgboost: BlobType;
+            /** LightGBM-based model (cloudpickle serialized) */
+            readonly lightgbm: BlobType;
+            /** Histogram-based model (sklearn HistGradientBoosting, used by CQR) */
+            readonly histogram: BlobType;
+        }>;
+        /** Number of input features */
+        readonly n_features: IntegerType;
+        /** Number of classes */
+        readonly n_classes: IntegerType;
+        /** Class labels */
+        readonly classes: ArrayType<IntegerType>;
+        /** Confidence level used during calibration */
+        readonly confidence_level: FloatType;
+    }>;
+}>;
+/**
+ * Uncertainty predictor blob type.
+ * Wraps MAPIE model to predict uncertainty measure (interval width or set size).
+ * Compatible with SHAP's KernelExplainer for explaining uncertainty.
+ */
+export declare const UncertaintyPredictorType: VariantType<{
+    /** Predicts interval width (upper - lower) from MAPIE regressor */
+    readonly mapie_interval_width: StructType<{
+        readonly data: BlobType;
+        readonly n_features: IntegerType;
+    }>;
+    /** Predicts prediction set size from MAPIE classifier */
+    readonly mapie_set_size: StructType<{
+        readonly data: BlobType;
+        readonly n_features: IntegerType;
+    }>;
+}>;
+/**
+ * Prediction interval result (regression).
+ */
+export declare const IntervalResultType: StructType<{
+    /** Lower bound of prediction interval */
+    readonly lower: ArrayType<FloatType>;
+    /** Point prediction (median/mean) */
+    readonly pred: ArrayType<FloatType>;
+    /** Upper bound of prediction interval */
+    readonly upper: ArrayType<FloatType>;
+}>;
+/**
+ * Prediction set result (classification).
+ * For each sample, contains the set of classes included in the prediction set.
+ */
+export declare const PredictionSetResultType: StructType<{
+    /** Predicted class (argmax of probabilities) */
+    readonly pred: ArrayType<IntegerType>;
+    /** Prediction set membership matrix (n_samples x n_classes, 1 if class in set) */
+    readonly sets: ArrayType<ArrayType<IntegerType>>;
+    /** Class probabilities (n_samples x n_classes) */
+    readonly probabilities: ArrayType<ArrayType<FloatType>>;
+    /** Size of each prediction set */
+    readonly set_sizes: ArrayType<IntegerType>;
+}>;
+/**
+ * Train a MAPIE conformal regressor.
+ *
+ * For split conformal, uses X_calib/y_calib for calibration.
+ * For cross conformal, combines train and calib data, uses CV for calibration.
+ *
+ * @param X_train - Training feature matrix
+ * @param y_train - Training target vector
+ * @param X_calib - Calibration feature matrix
+ * @param y_calib - Calibration target vector
+ * @param config - MAPIE configuration
+ * @returns Model blob containing calibrated MAPIE regressor
+ */
+export declare const mapie_train_conformal_regressor: import("@elaraai/east").PlatformDefinition<[ArrayType<ArrayType<FloatType>>, ArrayType<FloatType>, ArrayType<ArrayType<FloatType>>, ArrayType<FloatType>, StructType<{
+    /** Base model configuration */
+    readonly base_model: VariantType<{
+        /** XGBoost regressor as base model */
+        readonly xgboost: StructType<{
+            readonly n_estimators: OptionType<IntegerType>;
+            readonly max_depth: OptionType<IntegerType>;
+            readonly learning_rate: OptionType<FloatType>;
+            readonly min_child_weight: OptionType<IntegerType>;
+            readonly subsample: OptionType<FloatType>;
+            readonly colsample_bytree: OptionType<FloatType>;
+            readonly reg_alpha: OptionType<FloatType>;
+            readonly reg_lambda: OptionType<FloatType>;
+            readonly gamma: OptionType<FloatType>;
+            readonly random_state: OptionType<IntegerType>;
+            readonly n_jobs: OptionType<IntegerType>;
+            readonly sample_weight: OptionType<ArrayType<FloatType>>;
+            readonly categorical_features: OptionType<ArrayType<IntegerType>>;
+            readonly max_cat_to_onehot: OptionType<IntegerType>;
+            readonly max_cat_threshold: OptionType<IntegerType>;
+        }>;
+        /** LightGBM regressor as base model */
+        readonly lightgbm: StructType<{
+            readonly n_estimators: OptionType<IntegerType>;
+            readonly max_depth: OptionType<IntegerType>;
+            readonly learning_rate: OptionType<FloatType>;
+            readonly num_leaves: OptionType<IntegerType>;
+            readonly min_child_samples: OptionType<IntegerType>;
+            readonly subsample: OptionType<FloatType>;
+            readonly colsample_bytree: OptionType<FloatType>;
+            readonly reg_alpha: OptionType<FloatType>;
+            readonly reg_lambda: OptionType<FloatType>;
+            readonly random_state: OptionType<IntegerType>;
+            readonly n_jobs: OptionType<IntegerType>;
+        }>;
+    }>;
+    /** Conformal method (default: split) */
+    readonly method: OptionType<VariantType<{
+        /** Split conformal - requires separate calibration set */
+        readonly split: NullType;
+        /** Cross conformal - uses CV for calibration (combines train + calib) */
+        readonly cross: NullType;
+    }>>;
+    /** Confidence level: coverage probability (default 0.9 = 90% intervals) */
+    readonly confidence_level: OptionType<FloatType>;
+    /** Number of CV folds for cross method (default 5) */
+    readonly cv_folds: OptionType<IntegerType>;
+    /** Random seed for reproducibility */
+    readonly random_state: OptionType<IntegerType>;
+    /** Conformity score consistency check tolerance (default 1e-04) */
+    readonly conformity_eps: OptionType<FloatType>;
+}>], VariantType<{
+    /** MAPIE regressor with split conformal */
+    readonly mapie_split: StructType<{
+        /** Serialized model - variant tag indicates base model type (xgboost/lightgbm) */
+        readonly data: VariantType<{
+            /** XGBoost-based model (cloudpickle serialized) */
+            readonly xgboost: BlobType;
+            /** LightGBM-based model (cloudpickle serialized) */
+            readonly lightgbm: BlobType;
+            /** Histogram-based model (sklearn HistGradientBoosting, used by CQR) */
+            readonly histogram: BlobType;
+        }>;
+        /** Number of input features */
+        readonly n_features: IntegerType;
+        /** Confidence level used during calibration */
+        readonly confidence_level: FloatType;
+    }>;
+    /** MAPIE regressor with cross conformal */
+    readonly mapie_cross: StructType<{
+        /** Serialized model - variant tag indicates base model type (xgboost/lightgbm) */
+        readonly data: VariantType<{
+            /** XGBoost-based model (cloudpickle serialized) */
+            readonly xgboost: BlobType;
+            /** LightGBM-based model (cloudpickle serialized) */
+            readonly lightgbm: BlobType;
+            /** Histogram-based model (sklearn HistGradientBoosting, used by CQR) */
+            readonly histogram: BlobType;
+        }>;
+        /** Number of input features */
+        readonly n_features: IntegerType;
+        /** Confidence level used during calibration */
+        readonly confidence_level: FloatType;
+    }>;
+    /** MAPIE CQR regressor (uses HistGradientBoosting internally) */
+    readonly mapie_cqr: StructType<{
+        /** Serialized model - variant tag indicates base model type */
+        readonly data: VariantType<{
+            /** XGBoost-based model (cloudpickle serialized) */
+            readonly xgboost: BlobType;
+            /** LightGBM-based model (cloudpickle serialized) */
+            readonly lightgbm: BlobType;
+            /** Histogram-based model (sklearn HistGradientBoosting, used by CQR) */
+            readonly histogram: BlobType;
+        }>;
+        /** Number of input features */
+        readonly n_features: IntegerType;
+        /** Confidence level used during calibration */
+        readonly confidence_level: FloatType;
+    }>;
+}>>;
+/**
+ * Train a MAPIE CQR (Conformalized Quantile Regression) model.
+ *
+ * CQR combines quantile regression with conformal prediction for
+ * adaptive intervals that are wider where uncertainty is higher.
+ *
+ * @param X_train - Training feature matrix
+ * @param y_train - Training target vector
+ * @param X_calib - Calibration feature matrix
+ * @param y_calib - Calibration target vector
+ * @param config - CQR configuration
+ * @returns Model blob containing calibrated CQR model
+ */
+export declare const mapie_train_cqr: import("@elaraai/east").PlatformDefinition<[ArrayType<ArrayType<FloatType>>, ArrayType<FloatType>, ArrayType<ArrayType<FloatType>>, ArrayType<FloatType>, StructType<{
+    /** XGBoost config for the base quantile model */
+    readonly xgboost_config: StructType<{
+        readonly n_estimators: OptionType<IntegerType>;
+        readonly max_depth: OptionType<IntegerType>;
+        readonly learning_rate: OptionType<FloatType>;
+        readonly min_child_weight: OptionType<IntegerType>;
+        readonly subsample: OptionType<FloatType>;
+        readonly colsample_bytree: OptionType<FloatType>;
+        readonly reg_alpha: OptionType<FloatType>;
+        readonly reg_lambda: OptionType<FloatType>;
+        readonly gamma: OptionType<FloatType>;
+        readonly random_state: OptionType<IntegerType>;
+        readonly n_jobs: OptionType<IntegerType>;
+        readonly sample_weight: OptionType<ArrayType<FloatType>>;
+        readonly categorical_features: OptionType<ArrayType<IntegerType>>;
+        readonly max_cat_to_onehot: OptionType<IntegerType>;
+        readonly max_cat_threshold: OptionType<IntegerType>;
+    }>;
+    /** Confidence level: coverage probability (default 0.9 = 90% intervals) */
+    readonly confidence_level: OptionType<FloatType>;
+    /** Random seed for reproducibility */
+    readonly random_state: OptionType<IntegerType>;
+}>], VariantType<{
+    /** MAPIE regressor with split conformal */
+    readonly mapie_split: StructType<{
+        /** Serialized model - variant tag indicates base model type (xgboost/lightgbm) */
+        readonly data: VariantType<{
+            /** XGBoost-based model (cloudpickle serialized) */
+            readonly xgboost: BlobType;
+            /** LightGBM-based model (cloudpickle serialized) */
+            readonly lightgbm: BlobType;
+            /** Histogram-based model (sklearn HistGradientBoosting, used by CQR) */
+            readonly histogram: BlobType;
+        }>;
+        /** Number of input features */
+        readonly n_features: IntegerType;
+        /** Confidence level used during calibration */
+        readonly confidence_level: FloatType;
+    }>;
+    /** MAPIE regressor with cross conformal */
+    readonly mapie_cross: StructType<{
+        /** Serialized model - variant tag indicates base model type (xgboost/lightgbm) */
+        readonly data: VariantType<{
+            /** XGBoost-based model (cloudpickle serialized) */
+            readonly xgboost: BlobType;
+            /** LightGBM-based model (cloudpickle serialized) */
+            readonly lightgbm: BlobType;
+            /** Histogram-based model (sklearn HistGradientBoosting, used by CQR) */
+            readonly histogram: BlobType;
+        }>;
+        /** Number of input features */
+        readonly n_features: IntegerType;
+        /** Confidence level used during calibration */
+        readonly confidence_level: FloatType;
+    }>;
+    /** MAPIE CQR regressor (uses HistGradientBoosting internally) */
+    readonly mapie_cqr: StructType<{
+        /** Serialized model - variant tag indicates base model type */
+        readonly data: VariantType<{
+            /** XGBoost-based model (cloudpickle serialized) */
+            readonly xgboost: BlobType;
+            /** LightGBM-based model (cloudpickle serialized) */
+            readonly lightgbm: BlobType;
+            /** Histogram-based model (sklearn HistGradientBoosting, used by CQR) */
+            readonly histogram: BlobType;
+        }>;
+        /** Number of input features */
+        readonly n_features: IntegerType;
+        /** Confidence level used during calibration */
+        readonly confidence_level: FloatType;
+    }>;
+}>>;
+/**
+ * Predict with intervals using a MAPIE regressor.
+ *
+ * Returns intervals at the confidence level specified during training.
+ *
+ * @param model - Trained MAPIE regressor blob
+ * @param X - Feature matrix to predict
+ * @returns Prediction intervals (lower, pred, upper)
+ */
+export declare const mapie_predict_interval: import("@elaraai/east").PlatformDefinition<[VariantType<{
+    /** MAPIE regressor with split conformal */
+    readonly mapie_split: StructType<{
+        /** Serialized model - variant tag indicates base model type (xgboost/lightgbm) */
+        readonly data: VariantType<{
+            /** XGBoost-based model (cloudpickle serialized) */
+            readonly xgboost: BlobType;
+            /** LightGBM-based model (cloudpickle serialized) */
+            readonly lightgbm: BlobType;
+            /** Histogram-based model (sklearn HistGradientBoosting, used by CQR) */
+            readonly histogram: BlobType;
+        }>;
+        /** Number of input features */
+        readonly n_features: IntegerType;
+        /** Confidence level used during calibration */
+        readonly confidence_level: FloatType;
+    }>;
+    /** MAPIE regressor with cross conformal */
+    readonly mapie_cross: StructType<{
+        /** Serialized model - variant tag indicates base model type (xgboost/lightgbm) */
+        readonly data: VariantType<{
+            /** XGBoost-based model (cloudpickle serialized) */
+            readonly xgboost: BlobType;
+            /** LightGBM-based model (cloudpickle serialized) */
+            readonly lightgbm: BlobType;
+            /** Histogram-based model (sklearn HistGradientBoosting, used by CQR) */
+            readonly histogram: BlobType;
+        }>;
+        /** Number of input features */
+        readonly n_features: IntegerType;
+        /** Confidence level used during calibration */
+        readonly confidence_level: FloatType;
+    }>;
+    /** MAPIE CQR regressor (uses HistGradientBoosting internally) */
+    readonly mapie_cqr: StructType<{
+        /** Serialized model - variant tag indicates base model type */
+        readonly data: VariantType<{
+            /** XGBoost-based model (cloudpickle serialized) */
+            readonly xgboost: BlobType;
+            /** LightGBM-based model (cloudpickle serialized) */
+            readonly lightgbm: BlobType;
+            /** Histogram-based model (sklearn HistGradientBoosting, used by CQR) */
+            readonly histogram: BlobType;
+        }>;
+        /** Number of input features */
+        readonly n_features: IntegerType;
+        /** Confidence level used during calibration */
+        readonly confidence_level: FloatType;
+    }>;
+}>, ArrayType<ArrayType<FloatType>>], StructType<{
+    /** Lower bound of prediction interval */
+    readonly lower: ArrayType<FloatType>;
+    /** Point prediction (median/mean) */
+    readonly pred: ArrayType<FloatType>;
+    /** Upper bound of prediction interval */
+    readonly upper: ArrayType<FloatType>;
+}>>;
+/**
+ * Train a MAPIE conformal classifier.
+ *
+ * Uses split conformal prediction with calibration set for classification.
+ *
+ * @param X_train - Training feature matrix
+ * @param y_train - Training labels (integers)
+ * @param X_calib - Calibration feature matrix
+ * @param y_calib - Calibration labels
+ * @param config - Classifier configuration
+ * @returns Model blob containing calibrated MAPIE classifier
+ */
+export declare const mapie_train_conformal_classifier: import("@elaraai/east").PlatformDefinition<[ArrayType<ArrayType<FloatType>>, ArrayType<IntegerType>, ArrayType<ArrayType<FloatType>>, ArrayType<IntegerType>, StructType<{
+    /** Base classifier configuration */
+    readonly base_model: VariantType<{
+        /** XGBoost classifier as base model */
+        readonly xgboost: StructType<{
+            readonly n_estimators: OptionType<IntegerType>;
+            readonly max_depth: OptionType<IntegerType>;
+            readonly learning_rate: OptionType<FloatType>;
+            readonly min_child_weight: OptionType<IntegerType>;
+            readonly subsample: OptionType<FloatType>;
+            readonly colsample_bytree: OptionType<FloatType>;
+            readonly reg_alpha: OptionType<FloatType>;
+            readonly reg_lambda: OptionType<FloatType>;
+            readonly gamma: OptionType<FloatType>;
+            readonly random_state: OptionType<IntegerType>;
+            readonly n_jobs: OptionType<IntegerType>;
+            readonly sample_weight: OptionType<ArrayType<FloatType>>;
+            readonly categorical_features: OptionType<ArrayType<IntegerType>>;
+            readonly max_cat_to_onehot: OptionType<IntegerType>;
+            readonly max_cat_threshold: OptionType<IntegerType>;
+        }>;
+        /** LightGBM classifier as base model */
+        readonly lightgbm: StructType<{
+            readonly n_estimators: OptionType<IntegerType>;
+            readonly max_depth: OptionType<IntegerType>;
+            readonly learning_rate: OptionType<FloatType>;
+            readonly num_leaves: OptionType<IntegerType>;
+            readonly min_child_samples: OptionType<IntegerType>;
+            readonly subsample: OptionType<FloatType>;
+            readonly colsample_bytree: OptionType<FloatType>;
+            readonly reg_alpha: OptionType<FloatType>;
+            readonly reg_lambda: OptionType<FloatType>;
+            readonly random_state: OptionType<IntegerType>;
+            readonly n_jobs: OptionType<IntegerType>;
+        }>;
+    }>;
+    /** Classification conformity score method (default: lac) */
+    readonly method: OptionType<VariantType<{
+        /** Least Ambiguous set-valued Classifier - smallest sets */
+        readonly lac: NullType;
+        /** Adaptive Prediction Sets - adapts to probabilities */
+        readonly aps: NullType;
+    }>>;
+    /** Confidence level: coverage probability (default 0.9 = 90% coverage) */
+    readonly confidence_level: OptionType<FloatType>;
+    /** Random seed for reproducibility */
+    readonly random_state: OptionType<IntegerType>;
+}>], VariantType<{
+    /** MAPIE classifier with split conformal */
+    readonly mapie_classifier: StructType<{
+        /** Serialized model - variant tag indicates base model type (xgboost/lightgbm) */
+        readonly data: VariantType<{
+            /** XGBoost-based model (cloudpickle serialized) */
+            readonly xgboost: BlobType;
+            /** LightGBM-based model (cloudpickle serialized) */
+            readonly lightgbm: BlobType;
+            /** Histogram-based model (sklearn HistGradientBoosting, used by CQR) */
+            readonly histogram: BlobType;
+        }>;
+        /** Number of input features */
+        readonly n_features: IntegerType;
+        /** Number of classes */
+        readonly n_classes: IntegerType;
+        /** Class labels */
+        readonly classes: ArrayType<IntegerType>;
+        /** Confidence level used during calibration */
+        readonly confidence_level: FloatType;
+    }>;
+}>>;
+/**
+ * Predict with prediction sets using a MAPIE classifier.
+ *
+ * Returns prediction sets at the confidence level specified during training.
+ *
+ * @param model - Trained MAPIE classifier blob
+ * @param X - Feature matrix to predict
+ * @returns Prediction sets (pred, sets, probabilities, set_sizes)
+ */
+export declare const mapie_predict_set: import("@elaraai/east").PlatformDefinition<[VariantType<{
+    /** MAPIE classifier with split conformal */
+    readonly mapie_classifier: StructType<{
+        /** Serialized model - variant tag indicates base model type (xgboost/lightgbm) */
+        readonly data: VariantType<{
+            /** XGBoost-based model (cloudpickle serialized) */
+            readonly xgboost: BlobType;
+            /** LightGBM-based model (cloudpickle serialized) */
+            readonly lightgbm: BlobType;
+            /** Histogram-based model (sklearn HistGradientBoosting, used by CQR) */
+            readonly histogram: BlobType;
+        }>;
+        /** Number of input features */
+        readonly n_features: IntegerType;
+        /** Number of classes */
+        readonly n_classes: IntegerType;
+        /** Class labels */
+        readonly classes: ArrayType<IntegerType>;
+        /** Confidence level used during calibration */
+        readonly confidence_level: FloatType;
+    }>;
+}>, ArrayType<ArrayType<FloatType>>], StructType<{
+    /** Predicted class (argmax of probabilities) */
+    readonly pred: ArrayType<IntegerType>;
+    /** Prediction set membership matrix (n_samples x n_classes, 1 if class in set) */
+    readonly sets: ArrayType<ArrayType<IntegerType>>;
+    /** Class probabilities (n_samples x n_classes) */
+    readonly probabilities: ArrayType<ArrayType<FloatType>>;
+    /** Size of each prediction set */
+    readonly set_sizes: ArrayType<IntegerType>;
+}>>;
+/**
+ * Create an uncertainty predictor from a MAPIE regressor.
+ *
+ * Returns a model that predicts interval width (upper - lower) instead of
+ * point predictions. Use with SHAP KernelExplainer to explain what drives
+ * prediction uncertainty.
+ *
+ * @param model - MAPIE regressor blob
+ * @returns Uncertainty predictor blob for use with SHAP KernelExplainer
+ */
+export declare const mapie_uncertainty_predictor_regressor: import("@elaraai/east").PlatformDefinition<[VariantType<{
+    /** MAPIE regressor with split conformal */
+    readonly mapie_split: StructType<{
+        /** Serialized model - variant tag indicates base model type (xgboost/lightgbm) */
+        readonly data: VariantType<{
+            /** XGBoost-based model (cloudpickle serialized) */
+            readonly xgboost: BlobType;
+            /** LightGBM-based model (cloudpickle serialized) */
+            readonly lightgbm: BlobType;
+            /** Histogram-based model (sklearn HistGradientBoosting, used by CQR) */
+            readonly histogram: BlobType;
+        }>;
+        /** Number of input features */
+        readonly n_features: IntegerType;
+        /** Confidence level used during calibration */
+        readonly confidence_level: FloatType;
+    }>;
+    /** MAPIE regressor with cross conformal */
+    readonly mapie_cross: StructType<{
+        /** Serialized model - variant tag indicates base model type (xgboost/lightgbm) */
+        readonly data: VariantType<{
+            /** XGBoost-based model (cloudpickle serialized) */
+            readonly xgboost: BlobType;
+            /** LightGBM-based model (cloudpickle serialized) */
+            readonly lightgbm: BlobType;
+            /** Histogram-based model (sklearn HistGradientBoosting, used by CQR) */
+            readonly histogram: BlobType;
+        }>;
+        /** Number of input features */
+        readonly n_features: IntegerType;
+        /** Confidence level used during calibration */
+        readonly confidence_level: FloatType;
+    }>;
+    /** MAPIE CQR regressor (uses HistGradientBoosting internally) */
+    readonly mapie_cqr: StructType<{
+        /** Serialized model - variant tag indicates base model type */
+        readonly data: VariantType<{
+            /** XGBoost-based model (cloudpickle serialized) */
+            readonly xgboost: BlobType;
+            /** LightGBM-based model (cloudpickle serialized) */
+            readonly lightgbm: BlobType;
+            /** Histogram-based model (sklearn HistGradientBoosting, used by CQR) */
+            readonly histogram: BlobType;
+        }>;
+        /** Number of input features */
+        readonly n_features: IntegerType;
+        /** Confidence level used during calibration */
+        readonly confidence_level: FloatType;
+    }>;
+}>], VariantType<{
+    /** Predicts interval width (upper - lower) from MAPIE regressor */
+    readonly mapie_interval_width: StructType<{
+        readonly data: BlobType;
+        readonly n_features: IntegerType;
+    }>;
+    /** Predicts prediction set size from MAPIE classifier */
+    readonly mapie_set_size: StructType<{
+        readonly data: BlobType;
+        readonly n_features: IntegerType;
+    }>;
+}>>;
+/**
+ * Create an uncertainty predictor from a MAPIE classifier.
+ *
+ * Returns a model that predicts prediction set size instead of class labels.
+ * Use with SHAP KernelExplainer to explain what drives prediction uncertainty.
+ *
+ * @param model - MAPIE classifier blob
+ * @returns Uncertainty predictor blob for use with SHAP KernelExplainer
+ */
+export declare const mapie_uncertainty_predictor_classifier: import("@elaraai/east").PlatformDefinition<[VariantType<{
+    /** MAPIE classifier with split conformal */
+    readonly mapie_classifier: StructType<{
+        /** Serialized model - variant tag indicates base model type (xgboost/lightgbm) */
+        readonly data: VariantType<{
+            /** XGBoost-based model (cloudpickle serialized) */
+            readonly xgboost: BlobType;
+            /** LightGBM-based model (cloudpickle serialized) */
+            readonly lightgbm: BlobType;
+            /** Histogram-based model (sklearn HistGradientBoosting, used by CQR) */
+            readonly histogram: BlobType;
+        }>;
+        /** Number of input features */
+        readonly n_features: IntegerType;
+        /** Number of classes */
+        readonly n_classes: IntegerType;
+        /** Class labels */
+        readonly classes: ArrayType<IntegerType>;
+        /** Confidence level used during calibration */
+        readonly confidence_level: FloatType;
+    }>;
+}>], VariantType<{
+    /** Predicts interval width (upper - lower) from MAPIE regressor */
+    readonly mapie_interval_width: StructType<{
+        readonly data: BlobType;
+        readonly n_features: IntegerType;
+    }>;
+    /** Predicts prediction set size from MAPIE classifier */
+    readonly mapie_set_size: StructType<{
+        readonly data: BlobType;
+        readonly n_features: IntegerType;
+    }>;
+}>>;
+/**
+ * Type definitions for MAPIE functions.
+ */
+export declare const MAPIETypes: {
+    readonly ConformalMethodType: VariantType<{
+        /** Split conformal - requires separate calibration set */
+        readonly split: NullType;
+        /** Cross conformal - uses CV for calibration (combines train + calib) */
+        readonly cross: NullType;
+    }>;
+    readonly XGBoostConfigType: StructType<{
+        readonly n_estimators: OptionType<IntegerType>;
+        readonly max_depth: OptionType<IntegerType>;
+        readonly learning_rate: OptionType<FloatType>;
+        readonly min_child_weight: OptionType<IntegerType>;
+        readonly subsample: OptionType<FloatType>;
+        readonly colsample_bytree: OptionType<FloatType>;
+        readonly reg_alpha: OptionType<FloatType>;
+        readonly reg_lambda: OptionType<FloatType>;
+        readonly gamma: OptionType<FloatType>;
+        readonly random_state: OptionType<IntegerType>;
+        readonly n_jobs: OptionType<IntegerType>;
+        readonly sample_weight: OptionType<ArrayType<FloatType>>;
+        readonly categorical_features: OptionType<ArrayType<IntegerType>>;
+        readonly max_cat_to_onehot: OptionType<IntegerType>;
+        readonly max_cat_threshold: OptionType<IntegerType>;
+    }>;
+    readonly LightGBMConfigType: StructType<{
+        readonly n_estimators: OptionType<IntegerType>;
+        readonly max_depth: OptionType<IntegerType>;
+        readonly learning_rate: OptionType<FloatType>;
+        readonly num_leaves: OptionType<IntegerType>;
+        readonly min_child_samples: OptionType<IntegerType>;
+        readonly subsample: OptionType<FloatType>;
+        readonly colsample_bytree: OptionType<FloatType>;
+        readonly reg_alpha: OptionType<FloatType>;
+        readonly reg_lambda: OptionType<FloatType>;
+        readonly random_state: OptionType<IntegerType>;
+        readonly n_jobs: OptionType<IntegerType>;
+    }>;
+    readonly BaseModelType: VariantType<{
+        /** XGBoost regressor as base model */
+        readonly xgboost: StructType<{
+            readonly n_estimators: OptionType<IntegerType>;
+            readonly max_depth: OptionType<IntegerType>;
+            readonly learning_rate: OptionType<FloatType>;
+            readonly min_child_weight: OptionType<IntegerType>;
+            readonly subsample: OptionType<FloatType>;
+            readonly colsample_bytree: OptionType<FloatType>;
+            readonly reg_alpha: OptionType<FloatType>;
+            readonly reg_lambda: OptionType<FloatType>;
+            readonly gamma: OptionType<FloatType>;
+            readonly random_state: OptionType<IntegerType>;
+            readonly n_jobs: OptionType<IntegerType>;
+            readonly sample_weight: OptionType<ArrayType<FloatType>>;
+            readonly categorical_features: OptionType<ArrayType<IntegerType>>;
+            readonly max_cat_to_onehot: OptionType<IntegerType>;
+            readonly max_cat_threshold: OptionType<IntegerType>;
+        }>;
+        /** LightGBM regressor as base model */
+        readonly lightgbm: StructType<{
+            readonly n_estimators: OptionType<IntegerType>;
+            readonly max_depth: OptionType<IntegerType>;
+            readonly learning_rate: OptionType<FloatType>;
+            readonly num_leaves: OptionType<IntegerType>;
+            readonly min_child_samples: OptionType<IntegerType>;
+            readonly subsample: OptionType<FloatType>;
+            readonly colsample_bytree: OptionType<FloatType>;
+            readonly reg_alpha: OptionType<FloatType>;
+            readonly reg_lambda: OptionType<FloatType>;
+            readonly random_state: OptionType<IntegerType>;
+            readonly n_jobs: OptionType<IntegerType>;
+        }>;
+    }>;
+    readonly MAPIEConfigType: StructType<{
+        /** Base model configuration */
+        readonly base_model: VariantType<{
+            /** XGBoost regressor as base model */
+            readonly xgboost: StructType<{
+                readonly n_estimators: OptionType<IntegerType>;
+                readonly max_depth: OptionType<IntegerType>;
+                readonly learning_rate: OptionType<FloatType>;
+                readonly min_child_weight: OptionType<IntegerType>;
+                readonly subsample: OptionType<FloatType>;
+                readonly colsample_bytree: OptionType<FloatType>;
+                readonly reg_alpha: OptionType<FloatType>;
+                readonly reg_lambda: OptionType<FloatType>;
+                readonly gamma: OptionType<FloatType>;
+                readonly random_state: OptionType<IntegerType>;
+                readonly n_jobs: OptionType<IntegerType>;
+                readonly sample_weight: OptionType<ArrayType<FloatType>>;
+                readonly categorical_features: OptionType<ArrayType<IntegerType>>;
+                readonly max_cat_to_onehot: OptionType<IntegerType>;
+                readonly max_cat_threshold: OptionType<IntegerType>;
+            }>;
+            /** LightGBM regressor as base model */
+            readonly lightgbm: StructType<{
+                readonly n_estimators: OptionType<IntegerType>;
+                readonly max_depth: OptionType<IntegerType>;
+                readonly learning_rate: OptionType<FloatType>;
+                readonly num_leaves: OptionType<IntegerType>;
+                readonly min_child_samples: OptionType<IntegerType>;
+                readonly subsample: OptionType<FloatType>;
+                readonly colsample_bytree: OptionType<FloatType>;
+                readonly reg_alpha: OptionType<FloatType>;
+                readonly reg_lambda: OptionType<FloatType>;
+                readonly random_state: OptionType<IntegerType>;
+                readonly n_jobs: OptionType<IntegerType>;
+            }>;
+        }>;
+        /** Conformal method (default: split) */
+        readonly method: OptionType<VariantType<{
+            /** Split conformal - requires separate calibration set */
+            readonly split: NullType;
+            /** Cross conformal - uses CV for calibration (combines train + calib) */
+            readonly cross: NullType;
+        }>>;
+        /** Confidence level: coverage probability (default 0.9 = 90% intervals) */
+        readonly confidence_level: OptionType<FloatType>;
+        /** Number of CV folds for cross method (default 5) */
+        readonly cv_folds: OptionType<IntegerType>;
+        /** Random seed for reproducibility */
+        readonly random_state: OptionType<IntegerType>;
+        /** Conformity score consistency check tolerance (default 1e-04) */
+        readonly conformity_eps: OptionType<FloatType>;
+    }>;
+    readonly MAPIECQRConfigType: StructType<{
+        /** XGBoost config for the base quantile model */
+        readonly xgboost_config: StructType<{
+            readonly n_estimators: OptionType<IntegerType>;
+            readonly max_depth: OptionType<IntegerType>;
+            readonly learning_rate: OptionType<FloatType>;
+            readonly min_child_weight: OptionType<IntegerType>;
+            readonly subsample: OptionType<FloatType>;
+            readonly colsample_bytree: OptionType<FloatType>;
+            readonly reg_alpha: OptionType<FloatType>;
+            readonly reg_lambda: OptionType<FloatType>;
+            readonly gamma: OptionType<FloatType>;
+            readonly random_state: OptionType<IntegerType>;
+            readonly n_jobs: OptionType<IntegerType>;
+            readonly sample_weight: OptionType<ArrayType<FloatType>>;
+            readonly categorical_features: OptionType<ArrayType<IntegerType>>;
+            readonly max_cat_to_onehot: OptionType<IntegerType>;
+            readonly max_cat_threshold: OptionType<IntegerType>;
+        }>;
+        /** Confidence level: coverage probability (default 0.9 = 90% intervals) */
+        readonly confidence_level: OptionType<FloatType>;
+        /** Random seed for reproducibility */
+        readonly random_state: OptionType<IntegerType>;
+    }>;
+    readonly ClassificationMethodType: VariantType<{
+        /** Least Ambiguous set-valued Classifier - smallest sets */
+        readonly lac: NullType;
+        /** Adaptive Prediction Sets - adapts to probabilities */
+        readonly aps: NullType;
+    }>;
+    readonly BaseClassifierType: VariantType<{
+        /** XGBoost classifier as base model */
+        readonly xgboost: StructType<{
+            readonly n_estimators: OptionType<IntegerType>;
+            readonly max_depth: OptionType<IntegerType>;
+            readonly learning_rate: OptionType<FloatType>;
+            readonly min_child_weight: OptionType<IntegerType>;
+            readonly subsample: OptionType<FloatType>;
+            readonly colsample_bytree: OptionType<FloatType>;
+            readonly reg_alpha: OptionType<FloatType>;
+            readonly reg_lambda: OptionType<FloatType>;
+            readonly gamma: OptionType<FloatType>;
+            readonly random_state: OptionType<IntegerType>;
+            readonly n_jobs: OptionType<IntegerType>;
+            readonly sample_weight: OptionType<ArrayType<FloatType>>;
+            readonly categorical_features: OptionType<ArrayType<IntegerType>>;
+            readonly max_cat_to_onehot: OptionType<IntegerType>;
+            readonly max_cat_threshold: OptionType<IntegerType>;
+        }>;
+        /** LightGBM classifier as base model */
+        readonly lightgbm: StructType<{
+            readonly n_estimators: OptionType<IntegerType>;
+            readonly max_depth: OptionType<IntegerType>;
+            readonly learning_rate: OptionType<FloatType>;
+            readonly num_leaves: OptionType<IntegerType>;
+            readonly min_child_samples: OptionType<IntegerType>;
+            readonly subsample: OptionType<FloatType>;
+            readonly colsample_bytree: OptionType<FloatType>;
+            readonly reg_alpha: OptionType<FloatType>;
+            readonly reg_lambda: OptionType<FloatType>;
+            readonly random_state: OptionType<IntegerType>;
+            readonly n_jobs: OptionType<IntegerType>;
+        }>;
+    }>;
+    readonly MAPIEClassifierConfigType: StructType<{
+        /** Base classifier configuration */
+        readonly base_model: VariantType<{
+            /** XGBoost classifier as base model */
+            readonly xgboost: StructType<{
+                readonly n_estimators: OptionType<IntegerType>;
+                readonly max_depth: OptionType<IntegerType>;
+                readonly learning_rate: OptionType<FloatType>;
+                readonly min_child_weight: OptionType<IntegerType>;
+                readonly subsample: OptionType<FloatType>;
+                readonly colsample_bytree: OptionType<FloatType>;
+                readonly reg_alpha: OptionType<FloatType>;
+                readonly reg_lambda: OptionType<FloatType>;
+                readonly gamma: OptionType<FloatType>;
+                readonly random_state: OptionType<IntegerType>;
+                readonly n_jobs: OptionType<IntegerType>;
+                readonly sample_weight: OptionType<ArrayType<FloatType>>;
+                readonly categorical_features: OptionType<ArrayType<IntegerType>>;
+                readonly max_cat_to_onehot: OptionType<IntegerType>;
+                readonly max_cat_threshold: OptionType<IntegerType>;
+            }>;
+            /** LightGBM classifier as base model */
+            readonly lightgbm: StructType<{
+                readonly n_estimators: OptionType<IntegerType>;
+                readonly max_depth: OptionType<IntegerType>;
+                readonly learning_rate: OptionType<FloatType>;
+                readonly num_leaves: OptionType<IntegerType>;
+                readonly min_child_samples: OptionType<IntegerType>;
+                readonly subsample: OptionType<FloatType>;
+                readonly colsample_bytree: OptionType<FloatType>;
+                readonly reg_alpha: OptionType<FloatType>;
+                readonly reg_lambda: OptionType<FloatType>;
+                readonly random_state: OptionType<IntegerType>;
+                readonly n_jobs: OptionType<IntegerType>;
+            }>;
+        }>;
+        /** Classification conformity score method (default: lac) */
+        readonly method: OptionType<VariantType<{
+            /** Least Ambiguous set-valued Classifier - smallest sets */
+            readonly lac: NullType;
+            /** Adaptive Prediction Sets - adapts to probabilities */
+            readonly aps: NullType;
+        }>>;
+        /** Confidence level: coverage probability (default 0.9 = 90% coverage) */
+        readonly confidence_level: OptionType<FloatType>;
+        /** Random seed for reproducibility */
+        readonly random_state: OptionType<IntegerType>;
+    }>;
+    readonly MAPIEBaseModelDataType: VariantType<{
+        /** XGBoost-based model (cloudpickle serialized) */
+        readonly xgboost: BlobType;
+        /** LightGBM-based model (cloudpickle serialized) */
+        readonly lightgbm: BlobType;
+        /** Histogram-based model (sklearn HistGradientBoosting, used by CQR) */
+        readonly histogram: BlobType;
+    }>;
+    readonly MAPIERegressorBlobType: VariantType<{
+        /** MAPIE regressor with split conformal */
+        readonly mapie_split: StructType<{
+            /** Serialized model - variant tag indicates base model type (xgboost/lightgbm) */
+            readonly data: VariantType<{
+                /** XGBoost-based model (cloudpickle serialized) */
+                readonly xgboost: BlobType;
+                /** LightGBM-based model (cloudpickle serialized) */
+                readonly lightgbm: BlobType;
+                /** Histogram-based model (sklearn HistGradientBoosting, used by CQR) */
+                readonly histogram: BlobType;
+            }>;
+            /** Number of input features */
+            readonly n_features: IntegerType;
+            /** Confidence level used during calibration */
+            readonly confidence_level: FloatType;
+        }>;
+        /** MAPIE regressor with cross conformal */
+        readonly mapie_cross: StructType<{
+            /** Serialized model - variant tag indicates base model type (xgboost/lightgbm) */
+            readonly data: VariantType<{
+                /** XGBoost-based model (cloudpickle serialized) */
+                readonly xgboost: BlobType;
+                /** LightGBM-based model (cloudpickle serialized) */
+                readonly lightgbm: BlobType;
+                /** Histogram-based model (sklearn HistGradientBoosting, used by CQR) */
+                readonly histogram: BlobType;
+            }>;
+            /** Number of input features */
+            readonly n_features: IntegerType;
+            /** Confidence level used during calibration */
+            readonly confidence_level: FloatType;
+        }>;
+        /** MAPIE CQR regressor (uses HistGradientBoosting internally) */
+        readonly mapie_cqr: StructType<{
+            /** Serialized model - variant tag indicates base model type */
+            readonly data: VariantType<{
+                /** XGBoost-based model (cloudpickle serialized) */
+                readonly xgboost: BlobType;
+                /** LightGBM-based model (cloudpickle serialized) */
+                readonly lightgbm: BlobType;
+                /** Histogram-based model (sklearn HistGradientBoosting, used by CQR) */
+                readonly histogram: BlobType;
+            }>;
+            /** Number of input features */
+            readonly n_features: IntegerType;
+            /** Confidence level used during calibration */
+            readonly confidence_level: FloatType;
+        }>;
+    }>;
+    readonly MAPIEClassifierBlobType: VariantType<{
+        /** MAPIE classifier with split conformal */
+        readonly mapie_classifier: StructType<{
+            /** Serialized model - variant tag indicates base model type (xgboost/lightgbm) */
+            readonly data: VariantType<{
+                /** XGBoost-based model (cloudpickle serialized) */
+                readonly xgboost: BlobType;
+                /** LightGBM-based model (cloudpickle serialized) */
+                readonly lightgbm: BlobType;
+                /** Histogram-based model (sklearn HistGradientBoosting, used by CQR) */
+                readonly histogram: BlobType;
+            }>;
+            /** Number of input features */
+            readonly n_features: IntegerType;
+            /** Number of classes */
+            readonly n_classes: IntegerType;
+            /** Class labels */
+            readonly classes: ArrayType<IntegerType>;
+            /** Confidence level used during calibration */
+            readonly confidence_level: FloatType;
+        }>;
+    }>;
+    readonly UncertaintyPredictorType: VariantType<{
+        /** Predicts interval width (upper - lower) from MAPIE regressor */
+        readonly mapie_interval_width: StructType<{
+            readonly data: BlobType;
+            readonly n_features: IntegerType;
+        }>;
+        /** Predicts prediction set size from MAPIE classifier */
+        readonly mapie_set_size: StructType<{
+            readonly data: BlobType;
+            readonly n_features: IntegerType;
+        }>;
+    }>;
+    readonly IntervalResultType: StructType<{
+        /** Lower bound of prediction interval */
+        readonly lower: ArrayType<FloatType>;
+        /** Point prediction (median/mean) */
+        readonly pred: ArrayType<FloatType>;
+        /** Upper bound of prediction interval */
+        readonly upper: ArrayType<FloatType>;
+    }>;
+    readonly PredictionSetResultType: StructType<{
+        /** Predicted class (argmax of probabilities) */
+        readonly pred: ArrayType<IntegerType>;
+        /** Prediction set membership matrix (n_samples x n_classes, 1 if class in set) */
+        readonly sets: ArrayType<ArrayType<IntegerType>>;
+        /** Class probabilities (n_samples x n_classes) */
+        readonly probabilities: ArrayType<ArrayType<FloatType>>;
+        /** Size of each prediction set */
+        readonly set_sizes: ArrayType<IntegerType>;
+    }>;
+    readonly VectorType: ArrayType<FloatType>;
+    readonly MatrixType: ArrayType<ArrayType<FloatType>>;
+    readonly LabelVectorType: ArrayType<IntegerType>;
+};
+/**
+ * MAPIE conformal prediction.
+ *
+ * Provides prediction intervals with coverage guarantees using
+ * conformal prediction methods (MAPIE 1.2.0 API).
+ *
+ * @example
+ * ```ts
+ * import { East, variant } from "@elaraai/east";
+ * import { MAPIE } from "@elaraai/east-py-datascience";
+ *
+ * const train = East.function([], MAPIE.Types.MAPIERegressorBlobType, $ => {
+ *     const X_train = $.let([[1.0], [2.0], [3.0], [4.0], [5.0]]);
+ *     const y_train = $.let([1.5, 2.5, 3.5, 4.5, 5.5]);
+ *     const X_calib = $.let([[2.5], [4.5]]);
+ *     const y_calib = $.let([3.0, 5.0]);
+ *     const config = $.let({
+ *         base_model: variant('xgboost', {
+ *             n_estimators: variant('some', 50n),
+ *             max_depth: variant('some', 3n),
+ *             learning_rate: variant('some', 0.1),
+ *             min_child_weight: variant('none', null),
+ *             subsample: variant('none', null),
+ *             colsample_bytree: variant('none', null),
+ *             reg_alpha: variant('none', null),
+ *             reg_lambda: variant('none', null),
+ *             gamma: variant('none', null),
+ *             random_state: variant('some', 42n),
+ *             n_jobs: variant('none', null),
+ *             sample_weight: variant('none', null),
+ *             categorical_features: variant('none', null),
+ *             max_cat_to_onehot: variant('none', null),
+ *             max_cat_threshold: variant('none', null),
+ *         }),
+ *         method: variant('some', variant('split', null)),
+ *         confidence_level: variant('some', 0.9),
+ *         cv_folds: variant('none', null),
+ *         random_state: variant('some', 42n),
+ *         conformity_eps: variant('none', null),
+ *     });
+ *     return $.return(MAPIE.trainConformalRegressor(X_train, y_train, X_calib, y_calib, config));
+ * });
+ * ```
+ */
+export declare const MAPIE: {
+    /** Train MAPIE conformal regressor */
+    readonly trainConformalRegressor: import("@elaraai/east").PlatformDefinition<[ArrayType<ArrayType<FloatType>>, ArrayType<FloatType>, ArrayType<ArrayType<FloatType>>, ArrayType<FloatType>, StructType<{
+        /** Base model configuration */
+        readonly base_model: VariantType<{
+            /** XGBoost regressor as base model */
+            readonly xgboost: StructType<{
+                readonly n_estimators: OptionType<IntegerType>;
+                readonly max_depth: OptionType<IntegerType>;
+                readonly learning_rate: OptionType<FloatType>;
+                readonly min_child_weight: OptionType<IntegerType>;
+                readonly subsample: OptionType<FloatType>;
+                readonly colsample_bytree: OptionType<FloatType>;
+                readonly reg_alpha: OptionType<FloatType>;
+                readonly reg_lambda: OptionType<FloatType>;
+                readonly gamma: OptionType<FloatType>;
+                readonly random_state: OptionType<IntegerType>;
+                readonly n_jobs: OptionType<IntegerType>;
+                readonly sample_weight: OptionType<ArrayType<FloatType>>;
+                readonly categorical_features: OptionType<ArrayType<IntegerType>>;
+                readonly max_cat_to_onehot: OptionType<IntegerType>;
+                readonly max_cat_threshold: OptionType<IntegerType>;
+            }>;
+            /** LightGBM regressor as base model */
+            readonly lightgbm: StructType<{
+                readonly n_estimators: OptionType<IntegerType>;
+                readonly max_depth: OptionType<IntegerType>;
+                readonly learning_rate: OptionType<FloatType>;
+                readonly num_leaves: OptionType<IntegerType>;
+                readonly min_child_samples: OptionType<IntegerType>;
+                readonly subsample: OptionType<FloatType>;
+                readonly colsample_bytree: OptionType<FloatType>;
+                readonly reg_alpha: OptionType<FloatType>;
+                readonly reg_lambda: OptionType<FloatType>;
+                readonly random_state: OptionType<IntegerType>;
+                readonly n_jobs: OptionType<IntegerType>;
+            }>;
+        }>;
+        /** Conformal method (default: split) */
+        readonly method: OptionType<VariantType<{
+            /** Split conformal - requires separate calibration set */
+            readonly split: NullType;
+            /** Cross conformal - uses CV for calibration (combines train + calib) */
+            readonly cross: NullType;
+        }>>;
+        /** Confidence level: coverage probability (default 0.9 = 90% intervals) */
+        readonly confidence_level: OptionType<FloatType>;
+        /** Number of CV folds for cross method (default 5) */
+        readonly cv_folds: OptionType<IntegerType>;
+        /** Random seed for reproducibility */
+        readonly random_state: OptionType<IntegerType>;
+        /** Conformity score consistency check tolerance (default 1e-04) */
+        readonly conformity_eps: OptionType<FloatType>;
+    }>], VariantType<{
+        /** MAPIE regressor with split conformal */
+        readonly mapie_split: StructType<{
+            /** Serialized model - variant tag indicates base model type (xgboost/lightgbm) */
+            readonly data: VariantType<{
+                /** XGBoost-based model (cloudpickle serialized) */
+                readonly xgboost: BlobType;
+                /** LightGBM-based model (cloudpickle serialized) */
+                readonly lightgbm: BlobType;
+                /** Histogram-based model (sklearn HistGradientBoosting, used by CQR) */
+                readonly histogram: BlobType;
+            }>;
+            /** Number of input features */
+            readonly n_features: IntegerType;
+            /** Confidence level used during calibration */
+            readonly confidence_level: FloatType;
+        }>;
+        /** MAPIE regressor with cross conformal */
+        readonly mapie_cross: StructType<{
+            /** Serialized model - variant tag indicates base model type (xgboost/lightgbm) */
+            readonly data: VariantType<{
+                /** XGBoost-based model (cloudpickle serialized) */
+                readonly xgboost: BlobType;
+                /** LightGBM-based model (cloudpickle serialized) */
+                readonly lightgbm: BlobType;
+                /** Histogram-based model (sklearn HistGradientBoosting, used by CQR) */
+                readonly histogram: BlobType;
+            }>;
+            /** Number of input features */
+            readonly n_features: IntegerType;
+            /** Confidence level used during calibration */
+            readonly confidence_level: FloatType;
+        }>;
+        /** MAPIE CQR regressor (uses HistGradientBoosting internally) */
+        readonly mapie_cqr: StructType<{
+            /** Serialized model - variant tag indicates base model type */
+            readonly data: VariantType<{
+                /** XGBoost-based model (cloudpickle serialized) */
+                readonly xgboost: BlobType;
+                /** LightGBM-based model (cloudpickle serialized) */
+                readonly lightgbm: BlobType;
+                /** Histogram-based model (sklearn HistGradientBoosting, used by CQR) */
+                readonly histogram: BlobType;
+            }>;
+            /** Number of input features */
+            readonly n_features: IntegerType;
+            /** Confidence level used during calibration */
+            readonly confidence_level: FloatType;
+        }>;
+    }>>;
+    /** Train MAPIE CQR (Conformalized Quantile Regression) */
+    readonly trainCQR: import("@elaraai/east").PlatformDefinition<[ArrayType<ArrayType<FloatType>>, ArrayType<FloatType>, ArrayType<ArrayType<FloatType>>, ArrayType<FloatType>, StructType<{
+        /** XGBoost config for the base quantile model */
+        readonly xgboost_config: StructType<{
+            readonly n_estimators: OptionType<IntegerType>;
+            readonly max_depth: OptionType<IntegerType>;
+            readonly learning_rate: OptionType<FloatType>;
+            readonly min_child_weight: OptionType<IntegerType>;
+            readonly subsample: OptionType<FloatType>;
+            readonly colsample_bytree: OptionType<FloatType>;
+            readonly reg_alpha: OptionType<FloatType>;
+            readonly reg_lambda: OptionType<FloatType>;
+            readonly gamma: OptionType<FloatType>;
+            readonly random_state: OptionType<IntegerType>;
+            readonly n_jobs: OptionType<IntegerType>;
+            readonly sample_weight: OptionType<ArrayType<FloatType>>;
+            readonly categorical_features: OptionType<ArrayType<IntegerType>>;
+            readonly max_cat_to_onehot: OptionType<IntegerType>;
+            readonly max_cat_threshold: OptionType<IntegerType>;
+        }>;
+        /** Confidence level: coverage probability (default 0.9 = 90% intervals) */
+        readonly confidence_level: OptionType<FloatType>;
+        /** Random seed for reproducibility */
+        readonly random_state: OptionType<IntegerType>;
+    }>], VariantType<{
+        /** MAPIE regressor with split conformal */
+        readonly mapie_split: StructType<{
+            /** Serialized model - variant tag indicates base model type (xgboost/lightgbm) */
+            readonly data: VariantType<{
+                /** XGBoost-based model (cloudpickle serialized) */
+                readonly xgboost: BlobType;
+                /** LightGBM-based model (cloudpickle serialized) */
+                readonly lightgbm: BlobType;
+                /** Histogram-based model (sklearn HistGradientBoosting, used by CQR) */
+                readonly histogram: BlobType;
+            }>;
+            /** Number of input features */
+            readonly n_features: IntegerType;
+            /** Confidence level used during calibration */
+            readonly confidence_level: FloatType;
+        }>;
+        /** MAPIE regressor with cross conformal */
+        readonly mapie_cross: StructType<{
+            /** Serialized model - variant tag indicates base model type (xgboost/lightgbm) */
+            readonly data: VariantType<{
+                /** XGBoost-based model (cloudpickle serialized) */
+                readonly xgboost: BlobType;
+                /** LightGBM-based model (cloudpickle serialized) */
+                readonly lightgbm: BlobType;
+                /** Histogram-based model (sklearn HistGradientBoosting, used by CQR) */
+                readonly histogram: BlobType;
+            }>;
+            /** Number of input features */
+            readonly n_features: IntegerType;
+            /** Confidence level used during calibration */
+            readonly confidence_level: FloatType;
+        }>;
+        /** MAPIE CQR regressor (uses HistGradientBoosting internally) */
+        readonly mapie_cqr: StructType<{
+            /** Serialized model - variant tag indicates base model type */
+            readonly data: VariantType<{
+                /** XGBoost-based model (cloudpickle serialized) */
+                readonly xgboost: BlobType;
+                /** LightGBM-based model (cloudpickle serialized) */
+                readonly lightgbm: BlobType;
+                /** Histogram-based model (sklearn HistGradientBoosting, used by CQR) */
+                readonly histogram: BlobType;
+            }>;
+            /** Number of input features */
+            readonly n_features: IntegerType;
+            /** Confidence level used during calibration */
+            readonly confidence_level: FloatType;
+        }>;
+    }>>;
+    /** Predict with intervals */
+    readonly predictInterval: import("@elaraai/east").PlatformDefinition<[VariantType<{
+        /** MAPIE regressor with split conformal */
+        readonly mapie_split: StructType<{
+            /** Serialized model - variant tag indicates base model type (xgboost/lightgbm) */
+            readonly data: VariantType<{
+                /** XGBoost-based model (cloudpickle serialized) */
+                readonly xgboost: BlobType;
+                /** LightGBM-based model (cloudpickle serialized) */
+                readonly lightgbm: BlobType;
+                /** Histogram-based model (sklearn HistGradientBoosting, used by CQR) */
+                readonly histogram: BlobType;
+            }>;
+            /** Number of input features */
+            readonly n_features: IntegerType;
+            /** Confidence level used during calibration */
+            readonly confidence_level: FloatType;
+        }>;
+        /** MAPIE regressor with cross conformal */
+        readonly mapie_cross: StructType<{
+            /** Serialized model - variant tag indicates base model type (xgboost/lightgbm) */
+            readonly data: VariantType<{
+                /** XGBoost-based model (cloudpickle serialized) */
+                readonly xgboost: BlobType;
+                /** LightGBM-based model (cloudpickle serialized) */
+                readonly lightgbm: BlobType;
+                /** Histogram-based model (sklearn HistGradientBoosting, used by CQR) */
+                readonly histogram: BlobType;
+            }>;
+            /** Number of input features */
+            readonly n_features: IntegerType;
+            /** Confidence level used during calibration */
+            readonly confidence_level: FloatType;
+        }>;
+        /** MAPIE CQR regressor (uses HistGradientBoosting internally) */
+        readonly mapie_cqr: StructType<{
+            /** Serialized model - variant tag indicates base model type */
+            readonly data: VariantType<{
+                /** XGBoost-based model (cloudpickle serialized) */
+                readonly xgboost: BlobType;
+                /** LightGBM-based model (cloudpickle serialized) */
+                readonly lightgbm: BlobType;
+                /** Histogram-based model (sklearn HistGradientBoosting, used by CQR) */
+                readonly histogram: BlobType;
+            }>;
+            /** Number of input features */
+            readonly n_features: IntegerType;
+            /** Confidence level used during calibration */
+            readonly confidence_level: FloatType;
+        }>;
+    }>, ArrayType<ArrayType<FloatType>>], StructType<{
+        /** Lower bound of prediction interval */
+        readonly lower: ArrayType<FloatType>;
+        /** Point prediction (median/mean) */
+        readonly pred: ArrayType<FloatType>;
+        /** Upper bound of prediction interval */
+        readonly upper: ArrayType<FloatType>;
+    }>>;
+    /** Train MAPIE conformal classifier */
+    readonly trainConformalClassifier: import("@elaraai/east").PlatformDefinition<[ArrayType<ArrayType<FloatType>>, ArrayType<IntegerType>, ArrayType<ArrayType<FloatType>>, ArrayType<IntegerType>, StructType<{
+        /** Base classifier configuration */
+        readonly base_model: VariantType<{
+            /** XGBoost classifier as base model */
+            readonly xgboost: StructType<{
+                readonly n_estimators: OptionType<IntegerType>;
+                readonly max_depth: OptionType<IntegerType>;
+                readonly learning_rate: OptionType<FloatType>;
+                readonly min_child_weight: OptionType<IntegerType>;
+                readonly subsample: OptionType<FloatType>;
+                readonly colsample_bytree: OptionType<FloatType>;
+                readonly reg_alpha: OptionType<FloatType>;
+                readonly reg_lambda: OptionType<FloatType>;
+                readonly gamma: OptionType<FloatType>;
+                readonly random_state: OptionType<IntegerType>;
+                readonly n_jobs: OptionType<IntegerType>;
+                readonly sample_weight: OptionType<ArrayType<FloatType>>;
+                readonly categorical_features: OptionType<ArrayType<IntegerType>>;
+                readonly max_cat_to_onehot: OptionType<IntegerType>;
+                readonly max_cat_threshold: OptionType<IntegerType>;
+            }>;
+            /** LightGBM classifier as base model */
+            readonly lightgbm: StructType<{
+                readonly n_estimators: OptionType<IntegerType>;
+                readonly max_depth: OptionType<IntegerType>;
+                readonly learning_rate: OptionType<FloatType>;
+                readonly num_leaves: OptionType<IntegerType>;
+                readonly min_child_samples: OptionType<IntegerType>;
+                readonly subsample: OptionType<FloatType>;
+                readonly colsample_bytree: OptionType<FloatType>;
+                readonly reg_alpha: OptionType<FloatType>;
+                readonly reg_lambda: OptionType<FloatType>;
+                readonly random_state: OptionType<IntegerType>;
+                readonly n_jobs: OptionType<IntegerType>;
+            }>;
+        }>;
+        /** Classification conformity score method (default: lac) */
+        readonly method: OptionType<VariantType<{
+            /** Least Ambiguous set-valued Classifier - smallest sets */
+            readonly lac: NullType;
+            /** Adaptive Prediction Sets - adapts to probabilities */
+            readonly aps: NullType;
+        }>>;
+        /** Confidence level: coverage probability (default 0.9 = 90% coverage) */
+        readonly confidence_level: OptionType<FloatType>;
+        /** Random seed for reproducibility */
+        readonly random_state: OptionType<IntegerType>;
+    }>], VariantType<{
+        /** MAPIE classifier with split conformal */
+        readonly mapie_classifier: StructType<{
+            /** Serialized model - variant tag indicates base model type (xgboost/lightgbm) */
+            readonly data: VariantType<{
+                /** XGBoost-based model (cloudpickle serialized) */
+                readonly xgboost: BlobType;
+                /** LightGBM-based model (cloudpickle serialized) */
+                readonly lightgbm: BlobType;
+                /** Histogram-based model (sklearn HistGradientBoosting, used by CQR) */
+                readonly histogram: BlobType;
+            }>;
+            /** Number of input features */
+            readonly n_features: IntegerType;
+            /** Number of classes */
+            readonly n_classes: IntegerType;
+            /** Class labels */
+            readonly classes: ArrayType<IntegerType>;
+            /** Confidence level used during calibration */
+            readonly confidence_level: FloatType;
+        }>;
+    }>>;
+    /** Predict with prediction sets */
+    readonly predictSet: import("@elaraai/east").PlatformDefinition<[VariantType<{
+        /** MAPIE classifier with split conformal */
+        readonly mapie_classifier: StructType<{
+            /** Serialized model - variant tag indicates base model type (xgboost/lightgbm) */
+            readonly data: VariantType<{
+                /** XGBoost-based model (cloudpickle serialized) */
+                readonly xgboost: BlobType;
+                /** LightGBM-based model (cloudpickle serialized) */
+                readonly lightgbm: BlobType;
+                /** Histogram-based model (sklearn HistGradientBoosting, used by CQR) */
+                readonly histogram: BlobType;
+            }>;
+            /** Number of input features */
+            readonly n_features: IntegerType;
+            /** Number of classes */
+            readonly n_classes: IntegerType;
+            /** Class labels */
+            readonly classes: ArrayType<IntegerType>;
+            /** Confidence level used during calibration */
+            readonly confidence_level: FloatType;
+        }>;
+    }>, ArrayType<ArrayType<FloatType>>], StructType<{
+        /** Predicted class (argmax of probabilities) */
+        readonly pred: ArrayType<IntegerType>;
+        /** Prediction set membership matrix (n_samples x n_classes, 1 if class in set) */
+        readonly sets: ArrayType<ArrayType<IntegerType>>;
+        /** Class probabilities (n_samples x n_classes) */
+        readonly probabilities: ArrayType<ArrayType<FloatType>>;
+        /** Size of each prediction set */
+        readonly set_sizes: ArrayType<IntegerType>;
+    }>>;
+    /** Create uncertainty predictor from MAPIE regressor for SHAP */
+    readonly uncertaintyPredictorRegressor: import("@elaraai/east").PlatformDefinition<[VariantType<{
+        /** MAPIE regressor with split conformal */
+        readonly mapie_split: StructType<{
+            /** Serialized model - variant tag indicates base model type (xgboost/lightgbm) */
+            readonly data: VariantType<{
+                /** XGBoost-based model (cloudpickle serialized) */
+                readonly xgboost: BlobType;
+                /** LightGBM-based model (cloudpickle serialized) */
+                readonly lightgbm: BlobType;
+                /** Histogram-based model (sklearn HistGradientBoosting, used by CQR) */
+                readonly histogram: BlobType;
+            }>;
+            /** Number of input features */
+            readonly n_features: IntegerType;
+            /** Confidence level used during calibration */
+            readonly confidence_level: FloatType;
+        }>;
+        /** MAPIE regressor with cross conformal */
+        readonly mapie_cross: StructType<{
+            /** Serialized model - variant tag indicates base model type (xgboost/lightgbm) */
+            readonly data: VariantType<{
+                /** XGBoost-based model (cloudpickle serialized) */
+                readonly xgboost: BlobType;
+                /** LightGBM-based model (cloudpickle serialized) */
+                readonly lightgbm: BlobType;
+                /** Histogram-based model (sklearn HistGradientBoosting, used by CQR) */
+                readonly histogram: BlobType;
+            }>;
+            /** Number of input features */
+            readonly n_features: IntegerType;
+            /** Confidence level used during calibration */
+            readonly confidence_level: FloatType;
+        }>;
+        /** MAPIE CQR regressor (uses HistGradientBoosting internally) */
+        readonly mapie_cqr: StructType<{
+            /** Serialized model - variant tag indicates base model type */
+            readonly data: VariantType<{
+                /** XGBoost-based model (cloudpickle serialized) */
+                readonly xgboost: BlobType;
+                /** LightGBM-based model (cloudpickle serialized) */
+                readonly lightgbm: BlobType;
+                /** Histogram-based model (sklearn HistGradientBoosting, used by CQR) */
+                readonly histogram: BlobType;
+            }>;
+            /** Number of input features */
+            readonly n_features: IntegerType;
+            /** Confidence level used during calibration */
+            readonly confidence_level: FloatType;
+        }>;
+    }>], VariantType<{
+        /** Predicts interval width (upper - lower) from MAPIE regressor */
+        readonly mapie_interval_width: StructType<{
+            readonly data: BlobType;
+            readonly n_features: IntegerType;
+        }>;
+        /** Predicts prediction set size from MAPIE classifier */
+        readonly mapie_set_size: StructType<{
+            readonly data: BlobType;
+            readonly n_features: IntegerType;
+        }>;
+    }>>;
+    /** Create uncertainty predictor from MAPIE classifier for SHAP */
+    readonly uncertaintyPredictorClassifier: import("@elaraai/east").PlatformDefinition<[VariantType<{
+        /** MAPIE classifier with split conformal */
+        readonly mapie_classifier: StructType<{
+            /** Serialized model - variant tag indicates base model type (xgboost/lightgbm) */
+            readonly data: VariantType<{
+                /** XGBoost-based model (cloudpickle serialized) */
+                readonly xgboost: BlobType;
+                /** LightGBM-based model (cloudpickle serialized) */
+                readonly lightgbm: BlobType;
+                /** Histogram-based model (sklearn HistGradientBoosting, used by CQR) */
+                readonly histogram: BlobType;
+            }>;
+            /** Number of input features */
+            readonly n_features: IntegerType;
+            /** Number of classes */
+            readonly n_classes: IntegerType;
+            /** Class labels */
+            readonly classes: ArrayType<IntegerType>;
+            /** Confidence level used during calibration */
+            readonly confidence_level: FloatType;
+        }>;
+    }>], VariantType<{
+        /** Predicts interval width (upper - lower) from MAPIE regressor */
+        readonly mapie_interval_width: StructType<{
+            readonly data: BlobType;
+            readonly n_features: IntegerType;
+        }>;
+        /** Predicts prediction set size from MAPIE classifier */
+        readonly mapie_set_size: StructType<{
+            readonly data: BlobType;
+            readonly n_features: IntegerType;
+        }>;
+    }>>;
+    /** Type definitions */
+    readonly Types: {
+        readonly ConformalMethodType: VariantType<{
+            /** Split conformal - requires separate calibration set */
+            readonly split: NullType;
+            /** Cross conformal - uses CV for calibration (combines train + calib) */
+            readonly cross: NullType;
+        }>;
+        readonly XGBoostConfigType: StructType<{
+            readonly n_estimators: OptionType<IntegerType>;
+            readonly max_depth: OptionType<IntegerType>;
+            readonly learning_rate: OptionType<FloatType>;
+            readonly min_child_weight: OptionType<IntegerType>;
+            readonly subsample: OptionType<FloatType>;
+            readonly colsample_bytree: OptionType<FloatType>;
+            readonly reg_alpha: OptionType<FloatType>;
+            readonly reg_lambda: OptionType<FloatType>;
+            readonly gamma: OptionType<FloatType>;
+            readonly random_state: OptionType<IntegerType>;
+            readonly n_jobs: OptionType<IntegerType>;
+            readonly sample_weight: OptionType<ArrayType<FloatType>>;
+            readonly categorical_features: OptionType<ArrayType<IntegerType>>;
+            readonly max_cat_to_onehot: OptionType<IntegerType>;
+            readonly max_cat_threshold: OptionType<IntegerType>;
+        }>;
+        readonly LightGBMConfigType: StructType<{
+            readonly n_estimators: OptionType<IntegerType>;
+            readonly max_depth: OptionType<IntegerType>;
+            readonly learning_rate: OptionType<FloatType>;
+            readonly num_leaves: OptionType<IntegerType>;
+            readonly min_child_samples: OptionType<IntegerType>;
+            readonly subsample: OptionType<FloatType>;
+            readonly colsample_bytree: OptionType<FloatType>;
+            readonly reg_alpha: OptionType<FloatType>;
+            readonly reg_lambda: OptionType<FloatType>;
+            readonly random_state: OptionType<IntegerType>;
+            readonly n_jobs: OptionType<IntegerType>;
+        }>;
+        readonly BaseModelType: VariantType<{
+            /** XGBoost regressor as base model */
+            readonly xgboost: StructType<{
+                readonly n_estimators: OptionType<IntegerType>;
+                readonly max_depth: OptionType<IntegerType>;
+                readonly learning_rate: OptionType<FloatType>;
+                readonly min_child_weight: OptionType<IntegerType>;
+                readonly subsample: OptionType<FloatType>;
+                readonly colsample_bytree: OptionType<FloatType>;
+                readonly reg_alpha: OptionType<FloatType>;
+                readonly reg_lambda: OptionType<FloatType>;
+                readonly gamma: OptionType<FloatType>;
+                readonly random_state: OptionType<IntegerType>;
+                readonly n_jobs: OptionType<IntegerType>;
+                readonly sample_weight: OptionType<ArrayType<FloatType>>;
+                readonly categorical_features: OptionType<ArrayType<IntegerType>>;
+                readonly max_cat_to_onehot: OptionType<IntegerType>;
+                readonly max_cat_threshold: OptionType<IntegerType>;
+            }>;
+            /** LightGBM regressor as base model */
+            readonly lightgbm: StructType<{
+                readonly n_estimators: OptionType<IntegerType>;
+                readonly max_depth: OptionType<IntegerType>;
+                readonly learning_rate: OptionType<FloatType>;
+                readonly num_leaves: OptionType<IntegerType>;
+                readonly min_child_samples: OptionType<IntegerType>;
+                readonly subsample: OptionType<FloatType>;
+                readonly colsample_bytree: OptionType<FloatType>;
+                readonly reg_alpha: OptionType<FloatType>;
+                readonly reg_lambda: OptionType<FloatType>;
+                readonly random_state: OptionType<IntegerType>;
+                readonly n_jobs: OptionType<IntegerType>;
+            }>;
+        }>;
+        readonly MAPIEConfigType: StructType<{
+            /** Base model configuration */
+            readonly base_model: VariantType<{
+                /** XGBoost regressor as base model */
+                readonly xgboost: StructType<{
+                    readonly n_estimators: OptionType<IntegerType>;
+                    readonly max_depth: OptionType<IntegerType>;
+                    readonly learning_rate: OptionType<FloatType>;
+                    readonly min_child_weight: OptionType<IntegerType>;
+                    readonly subsample: OptionType<FloatType>;
+                    readonly colsample_bytree: OptionType<FloatType>;
+                    readonly reg_alpha: OptionType<FloatType>;
+                    readonly reg_lambda: OptionType<FloatType>;
+                    readonly gamma: OptionType<FloatType>;
+                    readonly random_state: OptionType<IntegerType>;
+                    readonly n_jobs: OptionType<IntegerType>;
+                    readonly sample_weight: OptionType<ArrayType<FloatType>>;
+                    readonly categorical_features: OptionType<ArrayType<IntegerType>>;
+                    readonly max_cat_to_onehot: OptionType<IntegerType>;
+                    readonly max_cat_threshold: OptionType<IntegerType>;
+                }>;
+                /** LightGBM regressor as base model */
+                readonly lightgbm: StructType<{
+                    readonly n_estimators: OptionType<IntegerType>;
+                    readonly max_depth: OptionType<IntegerType>;
+                    readonly learning_rate: OptionType<FloatType>;
+                    readonly num_leaves: OptionType<IntegerType>;
+                    readonly min_child_samples: OptionType<IntegerType>;
+                    readonly subsample: OptionType<FloatType>;
+                    readonly colsample_bytree: OptionType<FloatType>;
+                    readonly reg_alpha: OptionType<FloatType>;
+                    readonly reg_lambda: OptionType<FloatType>;
+                    readonly random_state: OptionType<IntegerType>;
+                    readonly n_jobs: OptionType<IntegerType>;
+                }>;
+            }>;
+            /** Conformal method (default: split) */
+            readonly method: OptionType<VariantType<{
+                /** Split conformal - requires separate calibration set */
+                readonly split: NullType;
+                /** Cross conformal - uses CV for calibration (combines train + calib) */
+                readonly cross: NullType;
+            }>>;
+            /** Confidence level: coverage probability (default 0.9 = 90% intervals) */
+            readonly confidence_level: OptionType<FloatType>;
+            /** Number of CV folds for cross method (default 5) */
+            readonly cv_folds: OptionType<IntegerType>;
+            /** Random seed for reproducibility */
+            readonly random_state: OptionType<IntegerType>;
+            /** Conformity score consistency check tolerance (default 1e-04) */
+            readonly conformity_eps: OptionType<FloatType>;
+        }>;
+        readonly MAPIECQRConfigType: StructType<{
+            /** XGBoost config for the base quantile model */
+            readonly xgboost_config: StructType<{
+                readonly n_estimators: OptionType<IntegerType>;
+                readonly max_depth: OptionType<IntegerType>;
+                readonly learning_rate: OptionType<FloatType>;
+                readonly min_child_weight: OptionType<IntegerType>;
+                readonly subsample: OptionType<FloatType>;
+                readonly colsample_bytree: OptionType<FloatType>;
+                readonly reg_alpha: OptionType<FloatType>;
+                readonly reg_lambda: OptionType<FloatType>;
+                readonly gamma: OptionType<FloatType>;
+                readonly random_state: OptionType<IntegerType>;
+                readonly n_jobs: OptionType<IntegerType>;
+                readonly sample_weight: OptionType<ArrayType<FloatType>>;
+                readonly categorical_features: OptionType<ArrayType<IntegerType>>;
+                readonly max_cat_to_onehot: OptionType<IntegerType>;
+                readonly max_cat_threshold: OptionType<IntegerType>;
+            }>;
+            /** Confidence level: coverage probability (default 0.9 = 90% intervals) */
+            readonly confidence_level: OptionType<FloatType>;
+            /** Random seed for reproducibility */
+            readonly random_state: OptionType<IntegerType>;
+        }>;
+        readonly ClassificationMethodType: VariantType<{
+            /** Least Ambiguous set-valued Classifier - smallest sets */
+            readonly lac: NullType;
+            /** Adaptive Prediction Sets - adapts to probabilities */
+            readonly aps: NullType;
+        }>;
+        readonly BaseClassifierType: VariantType<{
+            /** XGBoost classifier as base model */
+            readonly xgboost: StructType<{
+                readonly n_estimators: OptionType<IntegerType>;
+                readonly max_depth: OptionType<IntegerType>;
+                readonly learning_rate: OptionType<FloatType>;
+                readonly min_child_weight: OptionType<IntegerType>;
+                readonly subsample: OptionType<FloatType>;
+                readonly colsample_bytree: OptionType<FloatType>;
+                readonly reg_alpha: OptionType<FloatType>;
+                readonly reg_lambda: OptionType<FloatType>;
+                readonly gamma: OptionType<FloatType>;
+                readonly random_state: OptionType<IntegerType>;
+                readonly n_jobs: OptionType<IntegerType>;
+                readonly sample_weight: OptionType<ArrayType<FloatType>>;
+                readonly categorical_features: OptionType<ArrayType<IntegerType>>;
+                readonly max_cat_to_onehot: OptionType<IntegerType>;
+                readonly max_cat_threshold: OptionType<IntegerType>;
+            }>;
+            /** LightGBM classifier as base model */
+            readonly lightgbm: StructType<{
+                readonly n_estimators: OptionType<IntegerType>;
+                readonly max_depth: OptionType<IntegerType>;
+                readonly learning_rate: OptionType<FloatType>;
+                readonly num_leaves: OptionType<IntegerType>;
+                readonly min_child_samples: OptionType<IntegerType>;
+                readonly subsample: OptionType<FloatType>;
+                readonly colsample_bytree: OptionType<FloatType>;
+                readonly reg_alpha: OptionType<FloatType>;
+                readonly reg_lambda: OptionType<FloatType>;
+                readonly random_state: OptionType<IntegerType>;
+                readonly n_jobs: OptionType<IntegerType>;
+            }>;
+        }>;
+        readonly MAPIEClassifierConfigType: StructType<{
+            /** Base classifier configuration */
+            readonly base_model: VariantType<{
+                /** XGBoost classifier as base model */
+                readonly xgboost: StructType<{
+                    readonly n_estimators: OptionType<IntegerType>;
+                    readonly max_depth: OptionType<IntegerType>;
+                    readonly learning_rate: OptionType<FloatType>;
+                    readonly min_child_weight: OptionType<IntegerType>;
+                    readonly subsample: OptionType<FloatType>;
+                    readonly colsample_bytree: OptionType<FloatType>;
+                    readonly reg_alpha: OptionType<FloatType>;
+                    readonly reg_lambda: OptionType<FloatType>;
+                    readonly gamma: OptionType<FloatType>;
+                    readonly random_state: OptionType<IntegerType>;
+                    readonly n_jobs: OptionType<IntegerType>;
+                    readonly sample_weight: OptionType<ArrayType<FloatType>>;
+                    readonly categorical_features: OptionType<ArrayType<IntegerType>>;
+                    readonly max_cat_to_onehot: OptionType<IntegerType>;
+                    readonly max_cat_threshold: OptionType<IntegerType>;
+                }>;
+                /** LightGBM classifier as base model */
+                readonly lightgbm: StructType<{
+                    readonly n_estimators: OptionType<IntegerType>;
+                    readonly max_depth: OptionType<IntegerType>;
+                    readonly learning_rate: OptionType<FloatType>;
+                    readonly num_leaves: OptionType<IntegerType>;
+                    readonly min_child_samples: OptionType<IntegerType>;
+                    readonly subsample: OptionType<FloatType>;
+                    readonly colsample_bytree: OptionType<FloatType>;
+                    readonly reg_alpha: OptionType<FloatType>;
+                    readonly reg_lambda: OptionType<FloatType>;
+                    readonly random_state: OptionType<IntegerType>;
+                    readonly n_jobs: OptionType<IntegerType>;
+                }>;
+            }>;
+            /** Classification conformity score method (default: lac) */
+            readonly method: OptionType<VariantType<{
+                /** Least Ambiguous set-valued Classifier - smallest sets */
+                readonly lac: NullType;
+                /** Adaptive Prediction Sets - adapts to probabilities */
+                readonly aps: NullType;
+            }>>;
+            /** Confidence level: coverage probability (default 0.9 = 90% coverage) */
+            readonly confidence_level: OptionType<FloatType>;
+            /** Random seed for reproducibility */
+            readonly random_state: OptionType<IntegerType>;
+        }>;
+        readonly MAPIEBaseModelDataType: VariantType<{
+            /** XGBoost-based model (cloudpickle serialized) */
+            readonly xgboost: BlobType;
+            /** LightGBM-based model (cloudpickle serialized) */
+            readonly lightgbm: BlobType;
+            /** Histogram-based model (sklearn HistGradientBoosting, used by CQR) */
+            readonly histogram: BlobType;
+        }>;
+        readonly MAPIERegressorBlobType: VariantType<{
+            /** MAPIE regressor with split conformal */
+            readonly mapie_split: StructType<{
+                /** Serialized model - variant tag indicates base model type (xgboost/lightgbm) */
+                readonly data: VariantType<{
+                    /** XGBoost-based model (cloudpickle serialized) */
+                    readonly xgboost: BlobType;
+                    /** LightGBM-based model (cloudpickle serialized) */
+                    readonly lightgbm: BlobType;
+                    /** Histogram-based model (sklearn HistGradientBoosting, used by CQR) */
+                    readonly histogram: BlobType;
+                }>;
+                /** Number of input features */
+                readonly n_features: IntegerType;
+                /** Confidence level used during calibration */
+                readonly confidence_level: FloatType;
+            }>;
+            /** MAPIE regressor with cross conformal */
+            readonly mapie_cross: StructType<{
+                /** Serialized model - variant tag indicates base model type (xgboost/lightgbm) */
+                readonly data: VariantType<{
+                    /** XGBoost-based model (cloudpickle serialized) */
+                    readonly xgboost: BlobType;
+                    /** LightGBM-based model (cloudpickle serialized) */
+                    readonly lightgbm: BlobType;
+                    /** Histogram-based model (sklearn HistGradientBoosting, used by CQR) */
+                    readonly histogram: BlobType;
+                }>;
+                /** Number of input features */
+                readonly n_features: IntegerType;
+                /** Confidence level used during calibration */
+                readonly confidence_level: FloatType;
+            }>;
+            /** MAPIE CQR regressor (uses HistGradientBoosting internally) */
+            readonly mapie_cqr: StructType<{
+                /** Serialized model - variant tag indicates base model type */
+                readonly data: VariantType<{
+                    /** XGBoost-based model (cloudpickle serialized) */
+                    readonly xgboost: BlobType;
+                    /** LightGBM-based model (cloudpickle serialized) */
+                    readonly lightgbm: BlobType;
+                    /** Histogram-based model (sklearn HistGradientBoosting, used by CQR) */
+                    readonly histogram: BlobType;
+                }>;
+                /** Number of input features */
+                readonly n_features: IntegerType;
+                /** Confidence level used during calibration */
+                readonly confidence_level: FloatType;
+            }>;
+        }>;
+        readonly MAPIEClassifierBlobType: VariantType<{
+            /** MAPIE classifier with split conformal */
+            readonly mapie_classifier: StructType<{
+                /** Serialized model - variant tag indicates base model type (xgboost/lightgbm) */
+                readonly data: VariantType<{
+                    /** XGBoost-based model (cloudpickle serialized) */
+                    readonly xgboost: BlobType;
+                    /** LightGBM-based model (cloudpickle serialized) */
+                    readonly lightgbm: BlobType;
+                    /** Histogram-based model (sklearn HistGradientBoosting, used by CQR) */
+                    readonly histogram: BlobType;
+                }>;
+                /** Number of input features */
+                readonly n_features: IntegerType;
+                /** Number of classes */
+                readonly n_classes: IntegerType;
+                /** Class labels */
+                readonly classes: ArrayType<IntegerType>;
+                /** Confidence level used during calibration */
+                readonly confidence_level: FloatType;
+            }>;
+        }>;
+        readonly UncertaintyPredictorType: VariantType<{
+            /** Predicts interval width (upper - lower) from MAPIE regressor */
+            readonly mapie_interval_width: StructType<{
+                readonly data: BlobType;
+                readonly n_features: IntegerType;
+            }>;
+            /** Predicts prediction set size from MAPIE classifier */
+            readonly mapie_set_size: StructType<{
+                readonly data: BlobType;
+                readonly n_features: IntegerType;
+            }>;
+        }>;
+        readonly IntervalResultType: StructType<{
+            /** Lower bound of prediction interval */
+            readonly lower: ArrayType<FloatType>;
+            /** Point prediction (median/mean) */
+            readonly pred: ArrayType<FloatType>;
+            /** Upper bound of prediction interval */
+            readonly upper: ArrayType<FloatType>;
+        }>;
+        readonly PredictionSetResultType: StructType<{
+            /** Predicted class (argmax of probabilities) */
+            readonly pred: ArrayType<IntegerType>;
+            /** Prediction set membership matrix (n_samples x n_classes, 1 if class in set) */
+            readonly sets: ArrayType<ArrayType<IntegerType>>;
+            /** Class probabilities (n_samples x n_classes) */
+            readonly probabilities: ArrayType<ArrayType<FloatType>>;
+            /** Size of each prediction set */
+            readonly set_sizes: ArrayType<IntegerType>;
+        }>;
+        readonly VectorType: ArrayType<FloatType>;
+        readonly MatrixType: ArrayType<ArrayType<FloatType>>;
+        readonly LabelVectorType: ArrayType<IntegerType>;
+    };
+};
+//# sourceMappingURL=mapie.d.ts.map