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

package/dist/xgboost/xgboost.d.ts

@@ -10,32 +10,80 @@
  *
  * @packageDocumentation
  */
-import { StructType, VariantType, OptionType, IntegerType, FloatType, BlobType } from "@elaraai/east";
+import { StructType, VariantType, OptionType, ArrayType, IntegerType, FloatType, BlobType } from "@elaraai/east";
 export { VectorType, MatrixType, LabelVectorType } from "../types.js";
 /**
  * Configuration for XGBoost models.
  */
 export declare const XGBoostConfigType: StructType<{
     /** Number of boosting rounds (default 100) */
-    n_estimators: OptionType<IntegerType>;
+    readonly n_estimators: OptionType<IntegerType>;
     /** Maximum tree depth (default 6) */
-    max_depth: OptionType<IntegerType>;
+    readonly max_depth: OptionType<IntegerType>;
     /** Learning rate / step size shrinkage (default 0.3) */
-    learning_rate: OptionType<FloatType>;
+    readonly learning_rate: OptionType<FloatType>;
     /** Minimum sum of instance weight needed in a child (default 1) */
-    min_child_weight: OptionType<IntegerType>;
+    readonly min_child_weight: OptionType<IntegerType>;
     /** Subsample ratio of training instances (default 1.0) */
-    subsample: OptionType<FloatType>;
+    readonly subsample: OptionType<FloatType>;
     /** Subsample ratio of columns when constructing trees (default 1.0) */
-    colsample_bytree: OptionType<FloatType>;
+    readonly colsample_bytree: OptionType<FloatType>;
     /** L1 regularization term (default 0) */
-    reg_alpha: OptionType<FloatType>;
+    readonly reg_alpha: OptionType<FloatType>;
     /** L2 regularization term (default 1) */
-    reg_lambda: OptionType<FloatType>;
+    readonly reg_lambda: OptionType<FloatType>;
+    /** Minimum loss reduction required to make a further partition (default 0) */
+    readonly gamma: OptionType<FloatType>;
     /** Random seed for reproducibility */
-    random_state: OptionType<IntegerType>;
+    readonly random_state: OptionType<IntegerType>;
     /** Number of parallel threads (default -1 for all cores) */
-    n_jobs: OptionType<IntegerType>;
+    readonly n_jobs: OptionType<IntegerType>;
+    /** Sample weights for training (one per sample, default uniform) */
+    readonly sample_weight: OptionType<ArrayType<FloatType>>;
+    /** Column indices that contain categorical features (0-indexed) */
+    readonly categorical_features: OptionType<ArrayType<IntegerType>>;
+    /** Max categories for one-hot encoding (default 4). Features with more categories use partition-based splits. */
+    readonly max_cat_to_onehot: OptionType<IntegerType>;
+    /** Max categories considered per split for partition-based method (default 64). */
+    readonly max_cat_threshold: OptionType<IntegerType>;
+}>;
+/**
+ * Configuration for XGBoost quantile regression.
+ * Trains separate models for each quantile.
+ */
+export declare const XGBoostQuantileConfigType: StructType<{
+    /** Quantiles to predict (e.g., [0.1, 0.5, 0.9] for 80% interval + median) */
+    readonly quantiles: ArrayType<FloatType>;
+    /** Number of boosting rounds (default 100) */
+    readonly n_estimators: OptionType<IntegerType>;
+    /** Maximum tree depth (default 6) */
+    readonly max_depth: OptionType<IntegerType>;
+    /** Learning rate / step size shrinkage (default 0.3) */
+    readonly learning_rate: OptionType<FloatType>;
+    /** Minimum sum of instance weight needed in a child (default 1) */
+    readonly min_child_weight: OptionType<IntegerType>;
+    /** Subsample ratio of training instances (default 1.0) */
+    readonly subsample: OptionType<FloatType>;
+    /** Subsample ratio of columns when constructing trees (default 1.0) */
+    readonly colsample_bytree: OptionType<FloatType>;
+    /** L1 regularization term (default 0) */
+    readonly reg_alpha: OptionType<FloatType>;
+    /** L2 regularization term (default 1) */
+    readonly reg_lambda: OptionType<FloatType>;
+    /** Minimum loss reduction required to make a further partition (default 0) */
+    readonly gamma: OptionType<FloatType>;
+    /** Random seed for reproducibility */
+    readonly random_state: OptionType<IntegerType>;
+    /** Number of parallel threads (default -1 for all cores) */
+    readonly n_jobs: OptionType<IntegerType>;
+    /** Sample weights for training (one per sample, default uniform) */
+    readonly sample_weight: OptionType<ArrayType<FloatType>>;
+    /** Column indices that contain categorical features (0-indexed) */
+    readonly categorical_features: OptionType<ArrayType<IntegerType>>;
+    /** Max categories for one-hot encoding (default 4). Features with more categories use partition-based splits. */
+    readonly max_cat_to_onehot: OptionType<IntegerType>;
+    /** Max categories considered per split for partition-based method (default 64). */
+    readonly max_cat_threshold: OptionType<IntegerType>;
 }>;
 /**
  * Model blob type for serialized XGBoost models.
@@ -44,22 +92,46 @@ export declare const XGBoostConfigType: StructType<{
  */
 export declare const XGBoostModelBlobType: VariantType<{
     /** XGBoost regressor model */
-    xgboost_regressor: StructType<{
+    readonly xgboost_regressor: StructType<{
         /** Cloudpickle serialized model */
-        data: BlobType;
+        readonly data: BlobType;
         /** Number of input features */
-        n_features: IntegerType;
+        readonly n_features: IntegerType;
+        /** Column indices of categorical features (for prediction) */
+        readonly categorical_features: OptionType<ArrayType<IntegerType>>;
     }>;
     /** XGBoost classifier model */
-    xgboost_classifier: StructType<{
+    readonly xgboost_classifier: StructType<{
         /** Cloudpickle serialized model */
-        data: BlobType;
+        readonly data: BlobType;
         /** Number of input features */
-        n_features: IntegerType;
+        readonly n_features: IntegerType;
         /** Number of classes */
-        n_classes: IntegerType;
+        readonly n_classes: IntegerType;
+        /** Column indices of categorical features (for prediction) */
+        readonly categorical_features: OptionType<ArrayType<IntegerType>>;
+    }>;
+    /** XGBoost quantile regressor (multiple models, one per quantile) */
+    readonly xgboost_quantile: StructType<{
+        /** Cloudpickle serialized dict of {quantile: model} */
+        readonly data: BlobType;
+        /** Quantiles this model predicts */
+        readonly quantiles: ArrayType<FloatType>;
+        /** Number of input features */
+        readonly n_features: IntegerType;
+        /** Column indices of categorical features (for prediction) */
+        readonly categorical_features: OptionType<ArrayType<IntegerType>>;
     }>;
 }>;
+/**
+ * Result from XGBoost quantile prediction.
+ */
+export declare const XGBoostQuantilePredictResultType: StructType<{
+    /** Quantile values that were predicted */
+    readonly quantiles: ArrayType<FloatType>;
+    /** Predictions matrix: (n_samples x n_quantiles) */
+    readonly predictions: ArrayType<ArrayType<FloatType>>;
+}>;
 /**
  * Train an XGBoost regression model.
  *
@@ -68,43 +140,68 @@ export declare const XGBoostModelBlobType: VariantType<{
  * @param config - XGBoost configuration
  * @returns Model blob containing trained regressor
  */
-export declare const xgboost_train_regressor: import("@elaraai/east").PlatformDefinition<[import("@elaraai/east").ArrayType<import("@elaraai/east").ArrayType<FloatType>>, import("@elaraai/east").ArrayType<FloatType>, StructType<{
+export declare const xgboost_train_regressor: import("@elaraai/east").PlatformDefinition<[ArrayType<ArrayType<FloatType>>, ArrayType<FloatType>, StructType<{
     /** Number of boosting rounds (default 100) */
-    n_estimators: OptionType<IntegerType>;
+    readonly n_estimators: OptionType<IntegerType>;
     /** Maximum tree depth (default 6) */
-    max_depth: OptionType<IntegerType>;
+    readonly max_depth: OptionType<IntegerType>;
     /** Learning rate / step size shrinkage (default 0.3) */
-    learning_rate: OptionType<FloatType>;
+    readonly learning_rate: OptionType<FloatType>;
     /** Minimum sum of instance weight needed in a child (default 1) */
-    min_child_weight: OptionType<IntegerType>;
+    readonly min_child_weight: OptionType<IntegerType>;
     /** Subsample ratio of training instances (default 1.0) */
-    subsample: OptionType<FloatType>;
+    readonly subsample: OptionType<FloatType>;
     /** Subsample ratio of columns when constructing trees (default 1.0) */
-    colsample_bytree: OptionType<FloatType>;
+    readonly colsample_bytree: OptionType<FloatType>;
     /** L1 regularization term (default 0) */
-    reg_alpha: OptionType<FloatType>;
+    readonly reg_alpha: OptionType<FloatType>;
     /** L2 regularization term (default 1) */
-    reg_lambda: OptionType<FloatType>;
+    readonly reg_lambda: OptionType<FloatType>;
+    /** Minimum loss reduction required to make a further partition (default 0) */
+    readonly gamma: OptionType<FloatType>;
     /** Random seed for reproducibility */
-    random_state: OptionType<IntegerType>;
+    readonly random_state: OptionType<IntegerType>;
     /** Number of parallel threads (default -1 for all cores) */
-    n_jobs: OptionType<IntegerType>;
+    readonly n_jobs: OptionType<IntegerType>;
+    /** Sample weights for training (one per sample, default uniform) */
+    readonly sample_weight: OptionType<ArrayType<FloatType>>;
+    /** Column indices that contain categorical features (0-indexed) */
+    readonly categorical_features: OptionType<ArrayType<IntegerType>>;
+    /** Max categories for one-hot encoding (default 4). Features with more categories use partition-based splits. */
+    readonly max_cat_to_onehot: OptionType<IntegerType>;
+    /** Max categories considered per split for partition-based method (default 64). */
+    readonly max_cat_threshold: OptionType<IntegerType>;
 }>], VariantType<{
     /** XGBoost regressor model */
-    xgboost_regressor: StructType<{
+    readonly xgboost_regressor: StructType<{
         /** Cloudpickle serialized model */
-        data: BlobType;
+        readonly data: BlobType;
         /** Number of input features */
-        n_features: IntegerType;
+        readonly n_features: IntegerType;
+        /** Column indices of categorical features (for prediction) */
+        readonly categorical_features: OptionType<ArrayType<IntegerType>>;
     }>;
     /** XGBoost classifier model */
-    xgboost_classifier: StructType<{
+    readonly xgboost_classifier: StructType<{
         /** Cloudpickle serialized model */
-        data: BlobType;
+        readonly data: BlobType;
         /** Number of input features */
-        n_features: IntegerType;
+        readonly n_features: IntegerType;
         /** Number of classes */
-        n_classes: IntegerType;
+        readonly n_classes: IntegerType;
+        /** Column indices of categorical features (for prediction) */
+        readonly categorical_features: OptionType<ArrayType<IntegerType>>;
+    }>;
+    /** XGBoost quantile regressor (multiple models, one per quantile) */
+    readonly xgboost_quantile: StructType<{
+        /** Cloudpickle serialized dict of {quantile: model} */
+        readonly data: BlobType;
+        /** Quantiles this model predicts */
+        readonly quantiles: ArrayType<FloatType>;
+        /** Number of input features */
+        readonly n_features: IntegerType;
+        /** Column indices of categorical features (for prediction) */
+        readonly categorical_features: OptionType<ArrayType<IntegerType>>;
     }>;
 }>>;
 /**
@@ -115,43 +212,68 @@ export declare const xgboost_train_regressor: import("@elaraai/east").PlatformDe
  * @param config - XGBoost configuration
  * @returns Model blob containing trained classifier
  */
-export declare const xgboost_train_classifier: import("@elaraai/east").PlatformDefinition<[import("@elaraai/east").ArrayType<import("@elaraai/east").ArrayType<FloatType>>, import("@elaraai/east").ArrayType<IntegerType>, StructType<{
+export declare const xgboost_train_classifier: import("@elaraai/east").PlatformDefinition<[ArrayType<ArrayType<FloatType>>, ArrayType<IntegerType>, StructType<{
     /** Number of boosting rounds (default 100) */
-    n_estimators: OptionType<IntegerType>;
+    readonly n_estimators: OptionType<IntegerType>;
     /** Maximum tree depth (default 6) */
-    max_depth: OptionType<IntegerType>;
+    readonly max_depth: OptionType<IntegerType>;
     /** Learning rate / step size shrinkage (default 0.3) */
-    learning_rate: OptionType<FloatType>;
+    readonly learning_rate: OptionType<FloatType>;
     /** Minimum sum of instance weight needed in a child (default 1) */
-    min_child_weight: OptionType<IntegerType>;
+    readonly min_child_weight: OptionType<IntegerType>;
     /** Subsample ratio of training instances (default 1.0) */
-    subsample: OptionType<FloatType>;
+    readonly subsample: OptionType<FloatType>;
     /** Subsample ratio of columns when constructing trees (default 1.0) */
-    colsample_bytree: OptionType<FloatType>;
+    readonly colsample_bytree: OptionType<FloatType>;
     /** L1 regularization term (default 0) */
-    reg_alpha: OptionType<FloatType>;
+    readonly reg_alpha: OptionType<FloatType>;
     /** L2 regularization term (default 1) */
-    reg_lambda: OptionType<FloatType>;
+    readonly reg_lambda: OptionType<FloatType>;
+    /** Minimum loss reduction required to make a further partition (default 0) */
+    readonly gamma: OptionType<FloatType>;
     /** Random seed for reproducibility */
-    random_state: OptionType<IntegerType>;
+    readonly random_state: OptionType<IntegerType>;
     /** Number of parallel threads (default -1 for all cores) */
-    n_jobs: OptionType<IntegerType>;
+    readonly n_jobs: OptionType<IntegerType>;
+    /** Sample weights for training (one per sample, default uniform) */
+    readonly sample_weight: OptionType<ArrayType<FloatType>>;
+    /** Column indices that contain categorical features (0-indexed) */
+    readonly categorical_features: OptionType<ArrayType<IntegerType>>;
+    /** Max categories for one-hot encoding (default 4). Features with more categories use partition-based splits. */
+    readonly max_cat_to_onehot: OptionType<IntegerType>;
+    /** Max categories considered per split for partition-based method (default 64). */
+    readonly max_cat_threshold: OptionType<IntegerType>;
 }>], VariantType<{
     /** XGBoost regressor model */
-    xgboost_regressor: StructType<{
+    readonly xgboost_regressor: StructType<{
         /** Cloudpickle serialized model */
-        data: BlobType;
+        readonly data: BlobType;
         /** Number of input features */
-        n_features: IntegerType;
+        readonly n_features: IntegerType;
+        /** Column indices of categorical features (for prediction) */
+        readonly categorical_features: OptionType<ArrayType<IntegerType>>;
     }>;
     /** XGBoost classifier model */
-    xgboost_classifier: StructType<{
+    readonly xgboost_classifier: StructType<{
         /** Cloudpickle serialized model */
-        data: BlobType;
+        readonly data: BlobType;
         /** Number of input features */
-        n_features: IntegerType;
+        readonly n_features: IntegerType;
         /** Number of classes */
-        n_classes: IntegerType;
+        readonly n_classes: IntegerType;
+        /** Column indices of categorical features (for prediction) */
+        readonly categorical_features: OptionType<ArrayType<IntegerType>>;
+    }>;
+    /** XGBoost quantile regressor (multiple models, one per quantile) */
+    readonly xgboost_quantile: StructType<{
+        /** Cloudpickle serialized dict of {quantile: model} */
+        readonly data: BlobType;
+        /** Quantiles this model predicts */
+        readonly quantiles: ArrayType<FloatType>;
+        /** Number of input features */
+        readonly n_features: IntegerType;
+        /** Column indices of categorical features (for prediction) */
+        readonly categorical_features: OptionType<ArrayType<IntegerType>>;
     }>;
 }>>;
 /**
@@ -163,22 +285,37 @@ export declare const xgboost_train_classifier: import("@elaraai/east").PlatformD
  */
 export declare const xgboost_predict: import("@elaraai/east").PlatformDefinition<[VariantType<{
     /** XGBoost regressor model */
-    xgboost_regressor: StructType<{
+    readonly xgboost_regressor: StructType<{
         /** Cloudpickle serialized model */
-        data: BlobType;
+        readonly data: BlobType;
         /** Number of input features */
-        n_features: IntegerType;
+        readonly n_features: IntegerType;
+        /** Column indices of categorical features (for prediction) */
+        readonly categorical_features: OptionType<ArrayType<IntegerType>>;
     }>;
     /** XGBoost classifier model */
-    xgboost_classifier: StructType<{
+    readonly xgboost_classifier: StructType<{
         /** Cloudpickle serialized model */
-        data: BlobType;
+        readonly data: BlobType;
         /** Number of input features */
-        n_features: IntegerType;
+        readonly n_features: IntegerType;
         /** Number of classes */
-        n_classes: IntegerType;
+        readonly n_classes: IntegerType;
+        /** Column indices of categorical features (for prediction) */
+        readonly categorical_features: OptionType<ArrayType<IntegerType>>;
+    }>;
+    /** XGBoost quantile regressor (multiple models, one per quantile) */
+    readonly xgboost_quantile: StructType<{
+        /** Cloudpickle serialized dict of {quantile: model} */
+        readonly data: BlobType;
+        /** Quantiles this model predicts */
+        readonly quantiles: ArrayType<FloatType>;
+        /** Number of input features */
+        readonly n_features: IntegerType;
+        /** Column indices of categorical features (for prediction) */
+        readonly categorical_features: OptionType<ArrayType<IntegerType>>;
     }>;
-}>, import("@elaraai/east").ArrayType<import("@elaraai/east").ArrayType<FloatType>>], import("@elaraai/east").ArrayType<FloatType>>;
+}>, ArrayType<ArrayType<FloatType>>], ArrayType<FloatType>>;
 /**
  * Predict class labels with a trained XGBoost classifier.
  *
@@ -188,22 +325,37 @@ export declare const xgboost_predict: import("@elaraai/east").PlatformDefinition
  */
 export declare const xgboost_predict_class: import("@elaraai/east").PlatformDefinition<[VariantType<{
     /** XGBoost regressor model */
-    xgboost_regressor: StructType<{
+    readonly xgboost_regressor: StructType<{
         /** Cloudpickle serialized model */
-        data: BlobType;
+        readonly data: BlobType;
         /** Number of input features */
-        n_features: IntegerType;
+        readonly n_features: IntegerType;
+        /** Column indices of categorical features (for prediction) */
+        readonly categorical_features: OptionType<ArrayType<IntegerType>>;
     }>;
     /** XGBoost classifier model */
-    xgboost_classifier: StructType<{
+    readonly xgboost_classifier: StructType<{
         /** Cloudpickle serialized model */
-        data: BlobType;
+        readonly data: BlobType;
         /** Number of input features */
-        n_features: IntegerType;
+        readonly n_features: IntegerType;
         /** Number of classes */
-        n_classes: IntegerType;
+        readonly n_classes: IntegerType;
+        /** Column indices of categorical features (for prediction) */
+        readonly categorical_features: OptionType<ArrayType<IntegerType>>;
     }>;
-}>, import("@elaraai/east").ArrayType<import("@elaraai/east").ArrayType<FloatType>>], import("@elaraai/east").ArrayType<IntegerType>>;
+    /** XGBoost quantile regressor (multiple models, one per quantile) */
+    readonly xgboost_quantile: StructType<{
+        /** Cloudpickle serialized dict of {quantile: model} */
+        readonly data: BlobType;
+        /** Quantiles this model predicts */
+        readonly quantiles: ArrayType<FloatType>;
+        /** Number of input features */
+        readonly n_features: IntegerType;
+        /** Column indices of categorical features (for prediction) */
+        readonly categorical_features: OptionType<ArrayType<IntegerType>>;
+    }>;
+}>, ArrayType<ArrayType<FloatType>>], ArrayType<IntegerType>>;
 /**
  * Get class probabilities from a trained XGBoost classifier.
  *
@@ -213,72 +365,276 @@ export declare const xgboost_predict_class: import("@elaraai/east").PlatformDefi
  */
 export declare const xgboost_predict_proba: import("@elaraai/east").PlatformDefinition<[VariantType<{
     /** XGBoost regressor model */
-    xgboost_regressor: StructType<{
+    readonly xgboost_regressor: StructType<{
         /** Cloudpickle serialized model */
-        data: BlobType;
+        readonly data: BlobType;
         /** Number of input features */
-        n_features: IntegerType;
+        readonly n_features: IntegerType;
+        /** Column indices of categorical features (for prediction) */
+        readonly categorical_features: OptionType<ArrayType<IntegerType>>;
     }>;
     /** XGBoost classifier model */
-    xgboost_classifier: StructType<{
+    readonly xgboost_classifier: StructType<{
         /** Cloudpickle serialized model */
-        data: BlobType;
+        readonly data: BlobType;
         /** Number of input features */
-        n_features: IntegerType;
+        readonly n_features: IntegerType;
         /** Number of classes */
-        n_classes: IntegerType;
+        readonly n_classes: IntegerType;
+        /** Column indices of categorical features (for prediction) */
+        readonly categorical_features: OptionType<ArrayType<IntegerType>>;
+    }>;
+    /** XGBoost quantile regressor (multiple models, one per quantile) */
+    readonly xgboost_quantile: StructType<{
+        /** Cloudpickle serialized dict of {quantile: model} */
+        readonly data: BlobType;
+        /** Quantiles this model predicts */
+        readonly quantiles: ArrayType<FloatType>;
+        /** Number of input features */
+        readonly n_features: IntegerType;
+        /** Column indices of categorical features (for prediction) */
+        readonly categorical_features: OptionType<ArrayType<IntegerType>>;
     }>;
-}>, import("@elaraai/east").ArrayType<import("@elaraai/east").ArrayType<FloatType>>], import("@elaraai/east").ArrayType<import("@elaraai/east").ArrayType<FloatType>>>;
+}>, ArrayType<ArrayType<FloatType>>], ArrayType<ArrayType<FloatType>>>;
+/**
+ * Train XGBoost quantile regression models.
+ *
+ * Trains one model per quantile using pinball loss (reg:quantileerror).
+ * This provides prediction intervals and uncertainty quantification.
+ *
+ * @param X - Feature matrix
+ * @param y - Target vector
+ * @param config - Quantile regression configuration (includes quantiles array)
+ * @returns Model blob containing trained quantile models
+ */
+export declare const xgboost_train_quantile: import("@elaraai/east").PlatformDefinition<[ArrayType<ArrayType<FloatType>>, ArrayType<FloatType>, StructType<{
+    /** Quantiles to predict (e.g., [0.1, 0.5, 0.9] for 80% interval + median) */
+    readonly quantiles: ArrayType<FloatType>;
+    /** Number of boosting rounds (default 100) */
+    readonly n_estimators: OptionType<IntegerType>;
+    /** Maximum tree depth (default 6) */
+    readonly max_depth: OptionType<IntegerType>;
+    /** Learning rate / step size shrinkage (default 0.3) */
+    readonly learning_rate: OptionType<FloatType>;
+    /** Minimum sum of instance weight needed in a child (default 1) */
+    readonly min_child_weight: OptionType<IntegerType>;
+    /** Subsample ratio of training instances (default 1.0) */
+    readonly subsample: OptionType<FloatType>;
+    /** Subsample ratio of columns when constructing trees (default 1.0) */
+    readonly colsample_bytree: OptionType<FloatType>;
+    /** L1 regularization term (default 0) */
+    readonly reg_alpha: OptionType<FloatType>;
+    /** L2 regularization term (default 1) */
+    readonly reg_lambda: OptionType<FloatType>;
+    /** Minimum loss reduction required to make a further partition (default 0) */
+    readonly gamma: OptionType<FloatType>;
+    /** Random seed for reproducibility */
+    readonly random_state: OptionType<IntegerType>;
+    /** Number of parallel threads (default -1 for all cores) */
+    readonly n_jobs: OptionType<IntegerType>;
+    /** Sample weights for training (one per sample, default uniform) */
+    readonly sample_weight: OptionType<ArrayType<FloatType>>;
+    /** Column indices that contain categorical features (0-indexed) */
+    readonly categorical_features: OptionType<ArrayType<IntegerType>>;
+    /** Max categories for one-hot encoding (default 4). Features with more categories use partition-based splits. */
+    readonly max_cat_to_onehot: OptionType<IntegerType>;
+    /** Max categories considered per split for partition-based method (default 64). */
+    readonly max_cat_threshold: OptionType<IntegerType>;
+}>], VariantType<{
+    /** XGBoost regressor model */
+    readonly xgboost_regressor: StructType<{
+        /** Cloudpickle serialized model */
+        readonly data: BlobType;
+        /** Number of input features */
+        readonly n_features: IntegerType;
+        /** Column indices of categorical features (for prediction) */
+        readonly categorical_features: OptionType<ArrayType<IntegerType>>;
+    }>;
+    /** XGBoost classifier model */
+    readonly xgboost_classifier: StructType<{
+        /** Cloudpickle serialized model */
+        readonly data: BlobType;
+        /** Number of input features */
+        readonly n_features: IntegerType;
+        /** Number of classes */
+        readonly n_classes: IntegerType;
+        /** Column indices of categorical features (for prediction) */
+        readonly categorical_features: OptionType<ArrayType<IntegerType>>;
+    }>;
+    /** XGBoost quantile regressor (multiple models, one per quantile) */
+    readonly xgboost_quantile: StructType<{
+        /** Cloudpickle serialized dict of {quantile: model} */
+        readonly data: BlobType;
+        /** Quantiles this model predicts */
+        readonly quantiles: ArrayType<FloatType>;
+        /** Number of input features */
+        readonly n_features: IntegerType;
+        /** Column indices of categorical features (for prediction) */
+        readonly categorical_features: OptionType<ArrayType<IntegerType>>;
+    }>;
+}>>;
+/**
+ * Predict quantiles with trained XGBoost quantile regressor.
+ *
+ * @param model - Trained quantile model blob
+ * @param X - Feature matrix
+ * @returns Quantiles and predictions matrix (n_samples x n_quantiles)
+ */
+export declare const xgboost_predict_quantile: import("@elaraai/east").PlatformDefinition<[VariantType<{
+    /** XGBoost regressor model */
+    readonly xgboost_regressor: StructType<{
+        /** Cloudpickle serialized model */
+        readonly data: BlobType;
+        /** Number of input features */
+        readonly n_features: IntegerType;
+        /** Column indices of categorical features (for prediction) */
+        readonly categorical_features: OptionType<ArrayType<IntegerType>>;
+    }>;
+    /** XGBoost classifier model */
+    readonly xgboost_classifier: StructType<{
+        /** Cloudpickle serialized model */
+        readonly data: BlobType;
+        /** Number of input features */
+        readonly n_features: IntegerType;
+        /** Number of classes */
+        readonly n_classes: IntegerType;
+        /** Column indices of categorical features (for prediction) */
+        readonly categorical_features: OptionType<ArrayType<IntegerType>>;
+    }>;
+    /** XGBoost quantile regressor (multiple models, one per quantile) */
+    readonly xgboost_quantile: StructType<{
+        /** Cloudpickle serialized dict of {quantile: model} */
+        readonly data: BlobType;
+        /** Quantiles this model predicts */
+        readonly quantiles: ArrayType<FloatType>;
+        /** Number of input features */
+        readonly n_features: IntegerType;
+        /** Column indices of categorical features (for prediction) */
+        readonly categorical_features: OptionType<ArrayType<IntegerType>>;
+    }>;
+}>, ArrayType<ArrayType<FloatType>>], StructType<{
+    /** Quantile values that were predicted */
+    readonly quantiles: ArrayType<FloatType>;
+    /** Predictions matrix: (n_samples x n_quantiles) */
+    readonly predictions: ArrayType<ArrayType<FloatType>>;
+}>>;
 /**
  * Type definitions for XGBoost functions.
  */
 export declare const XGBoostTypes: {
     /** Vector type (array of floats) */
-    readonly VectorType: import("@elaraai/east").ArrayType<FloatType>;
+    readonly VectorType: ArrayType<FloatType>;
     /** Matrix type (2D array of floats) */
-    readonly MatrixType: import("@elaraai/east").ArrayType<import("@elaraai/east").ArrayType<FloatType>>;
+    readonly MatrixType: ArrayType<ArrayType<FloatType>>;
     /** Label vector type (array of integers) */
-    readonly LabelVectorType: import("@elaraai/east").ArrayType<IntegerType>;
+    readonly LabelVectorType: ArrayType<IntegerType>;
     /** XGBoost configuration type */
     readonly XGBoostConfigType: StructType<{
         /** Number of boosting rounds (default 100) */
-        n_estimators: OptionType<IntegerType>;
+        readonly n_estimators: OptionType<IntegerType>;
         /** Maximum tree depth (default 6) */
-        max_depth: OptionType<IntegerType>;
+        readonly max_depth: OptionType<IntegerType>;
         /** Learning rate / step size shrinkage (default 0.3) */
-        learning_rate: OptionType<FloatType>;
+        readonly learning_rate: OptionType<FloatType>;
         /** Minimum sum of instance weight needed in a child (default 1) */
-        min_child_weight: OptionType<IntegerType>;
+        readonly min_child_weight: OptionType<IntegerType>;
         /** Subsample ratio of training instances (default 1.0) */
-        subsample: OptionType<FloatType>;
+        readonly subsample: OptionType<FloatType>;
         /** Subsample ratio of columns when constructing trees (default 1.0) */
-        colsample_bytree: OptionType<FloatType>;
+        readonly colsample_bytree: OptionType<FloatType>;
         /** L1 regularization term (default 0) */
-        reg_alpha: OptionType<FloatType>;
+        readonly reg_alpha: OptionType<FloatType>;
         /** L2 regularization term (default 1) */
-        reg_lambda: OptionType<FloatType>;
+        readonly reg_lambda: OptionType<FloatType>;
+        /** Minimum loss reduction required to make a further partition (default 0) */
+        readonly gamma: OptionType<FloatType>;
         /** Random seed for reproducibility */
-        random_state: OptionType<IntegerType>;
+        readonly random_state: OptionType<IntegerType>;
         /** Number of parallel threads (default -1 for all cores) */
-        n_jobs: OptionType<IntegerType>;
+        readonly n_jobs: OptionType<IntegerType>;
+        /** Sample weights for training (one per sample, default uniform) */
+        readonly sample_weight: OptionType<ArrayType<FloatType>>;
+        /** Column indices that contain categorical features (0-indexed) */
+        readonly categorical_features: OptionType<ArrayType<IntegerType>>;
+        /** Max categories for one-hot encoding (default 4). Features with more categories use partition-based splits. */
+        readonly max_cat_to_onehot: OptionType<IntegerType>;
+        /** Max categories considered per split for partition-based method (default 64). */
+        readonly max_cat_threshold: OptionType<IntegerType>;
+    }>;
+    /** XGBoost quantile configuration type */
+    readonly XGBoostQuantileConfigType: StructType<{
+        /** Quantiles to predict (e.g., [0.1, 0.5, 0.9] for 80% interval + median) */
+        readonly quantiles: ArrayType<FloatType>;
+        /** Number of boosting rounds (default 100) */
+        readonly n_estimators: OptionType<IntegerType>;
+        /** Maximum tree depth (default 6) */
+        readonly max_depth: OptionType<IntegerType>;
+        /** Learning rate / step size shrinkage (default 0.3) */
+        readonly learning_rate: OptionType<FloatType>;
+        /** Minimum sum of instance weight needed in a child (default 1) */
+        readonly min_child_weight: OptionType<IntegerType>;
+        /** Subsample ratio of training instances (default 1.0) */
+        readonly subsample: OptionType<FloatType>;
+        /** Subsample ratio of columns when constructing trees (default 1.0) */
+        readonly colsample_bytree: OptionType<FloatType>;
+        /** L1 regularization term (default 0) */
+        readonly reg_alpha: OptionType<FloatType>;
+        /** L2 regularization term (default 1) */
+        readonly reg_lambda: OptionType<FloatType>;
+        /** Minimum loss reduction required to make a further partition (default 0) */
+        readonly gamma: OptionType<FloatType>;
+        /** Random seed for reproducibility */
+        readonly random_state: OptionType<IntegerType>;
+        /** Number of parallel threads (default -1 for all cores) */
+        readonly n_jobs: OptionType<IntegerType>;
+        /** Sample weights for training (one per sample, default uniform) */
+        readonly sample_weight: OptionType<ArrayType<FloatType>>;
+        /** Column indices that contain categorical features (0-indexed) */
+        readonly categorical_features: OptionType<ArrayType<IntegerType>>;
+        /** Max categories for one-hot encoding (default 4). Features with more categories use partition-based splits. */
+        readonly max_cat_to_onehot: OptionType<IntegerType>;
+        /** Max categories considered per split for partition-based method (default 64). */
+        readonly max_cat_threshold: OptionType<IntegerType>;
+    }>;
+    /** Quantile prediction result type */
+    readonly XGBoostQuantilePredictResultType: StructType<{
+        /** Quantile values that were predicted */
+        readonly quantiles: ArrayType<FloatType>;
+        /** Predictions matrix: (n_samples x n_quantiles) */
+        readonly predictions: ArrayType<ArrayType<FloatType>>;
     }>;
     /** Model blob type for XGBoost models */
     readonly ModelBlobType: VariantType<{
         /** XGBoost regressor model */
-        xgboost_regressor: StructType<{
+        readonly xgboost_regressor: StructType<{
             /** Cloudpickle serialized model */
-            data: BlobType;
+            readonly data: BlobType;
             /** Number of input features */
-            n_features: IntegerType;
+            readonly n_features: IntegerType;
+            /** Column indices of categorical features (for prediction) */
+            readonly categorical_features: OptionType<ArrayType<IntegerType>>;
         }>;
         /** XGBoost classifier model */
-        xgboost_classifier: StructType<{
+        readonly xgboost_classifier: StructType<{
             /** Cloudpickle serialized model */
-            data: BlobType;
+            readonly data: BlobType;
             /** Number of input features */
-            n_features: IntegerType;
+            readonly n_features: IntegerType;
             /** Number of classes */
-            n_classes: IntegerType;
+            readonly n_classes: IntegerType;
+            /** Column indices of categorical features (for prediction) */
+            readonly categorical_features: OptionType<ArrayType<IntegerType>>;
+        }>;
+        /** XGBoost quantile regressor (multiple models, one per quantile) */
+        readonly xgboost_quantile: StructType<{
+            /** Cloudpickle serialized dict of {quantile: model} */
+            readonly data: BlobType;
+            /** Quantiles this model predicts */
+            readonly quantiles: ArrayType<FloatType>;
+            /** Number of input features */
+            readonly n_features: IntegerType;
+            /** Column indices of categorical features (for prediction) */
+            readonly categorical_features: OptionType<ArrayType<IntegerType>>;
         }>;
     }>;
 };
@@ -306,6 +662,7 @@ export declare const XGBoostTypes: {
  *         reg_lambda: variant('none', null),
  *         random_state: variant('some', 42n),
  *         n_jobs: variant('none', null),
+ *         sample_weight: variant('none', null),
  *     });
  *     return $.return(XGBoost.trainRegressor(X, y, config));
  * });
@@ -313,190 +670,458 @@ export declare const XGBoostTypes: {
  */
 export declare const XGBoost: {
     /** Train XGBoost regressor */
-    readonly trainRegressor: import("@elaraai/east").PlatformDefinition<[import("@elaraai/east").ArrayType<import("@elaraai/east").ArrayType<FloatType>>, import("@elaraai/east").ArrayType<FloatType>, StructType<{
+    readonly trainRegressor: import("@elaraai/east").PlatformDefinition<[ArrayType<ArrayType<FloatType>>, ArrayType<FloatType>, StructType<{
         /** Number of boosting rounds (default 100) */
-        n_estimators: OptionType<IntegerType>;
+        readonly n_estimators: OptionType<IntegerType>;
         /** Maximum tree depth (default 6) */
-        max_depth: OptionType<IntegerType>;
+        readonly max_depth: OptionType<IntegerType>;
         /** Learning rate / step size shrinkage (default 0.3) */
-        learning_rate: OptionType<FloatType>;
+        readonly learning_rate: OptionType<FloatType>;
         /** Minimum sum of instance weight needed in a child (default 1) */
-        min_child_weight: OptionType<IntegerType>;
+        readonly min_child_weight: OptionType<IntegerType>;
         /** Subsample ratio of training instances (default 1.0) */
-        subsample: OptionType<FloatType>;
+        readonly subsample: OptionType<FloatType>;
         /** Subsample ratio of columns when constructing trees (default 1.0) */
-        colsample_bytree: OptionType<FloatType>;
+        readonly colsample_bytree: OptionType<FloatType>;
         /** L1 regularization term (default 0) */
-        reg_alpha: OptionType<FloatType>;
+        readonly reg_alpha: OptionType<FloatType>;
         /** L2 regularization term (default 1) */
-        reg_lambda: OptionType<FloatType>;
+        readonly reg_lambda: OptionType<FloatType>;
+        /** Minimum loss reduction required to make a further partition (default 0) */
+        readonly gamma: OptionType<FloatType>;
         /** Random seed for reproducibility */
-        random_state: OptionType<IntegerType>;
+        readonly random_state: OptionType<IntegerType>;
         /** Number of parallel threads (default -1 for all cores) */
-        n_jobs: OptionType<IntegerType>;
+        readonly n_jobs: OptionType<IntegerType>;
+        /** Sample weights for training (one per sample, default uniform) */
+        readonly sample_weight: OptionType<ArrayType<FloatType>>;
+        /** Column indices that contain categorical features (0-indexed) */
+        readonly categorical_features: OptionType<ArrayType<IntegerType>>;
+        /** Max categories for one-hot encoding (default 4). Features with more categories use partition-based splits. */
+        readonly max_cat_to_onehot: OptionType<IntegerType>;
+        /** Max categories considered per split for partition-based method (default 64). */
+        readonly max_cat_threshold: OptionType<IntegerType>;
     }>], VariantType<{
         /** XGBoost regressor model */
-        xgboost_regressor: StructType<{
+        readonly xgboost_regressor: StructType<{
             /** Cloudpickle serialized model */
-            data: BlobType;
+            readonly data: BlobType;
             /** Number of input features */
-            n_features: IntegerType;
+            readonly n_features: IntegerType;
+            /** Column indices of categorical features (for prediction) */
+            readonly categorical_features: OptionType<ArrayType<IntegerType>>;
         }>;
         /** XGBoost classifier model */
-        xgboost_classifier: StructType<{
+        readonly xgboost_classifier: StructType<{
             /** Cloudpickle serialized model */
-            data: BlobType;
+            readonly data: BlobType;
             /** Number of input features */
-            n_features: IntegerType;
+            readonly n_features: IntegerType;
             /** Number of classes */
-            n_classes: IntegerType;
+            readonly n_classes: IntegerType;
+            /** Column indices of categorical features (for prediction) */
+            readonly categorical_features: OptionType<ArrayType<IntegerType>>;
+        }>;
+        /** XGBoost quantile regressor (multiple models, one per quantile) */
+        readonly xgboost_quantile: StructType<{
+            /** Cloudpickle serialized dict of {quantile: model} */
+            readonly data: BlobType;
+            /** Quantiles this model predicts */
+            readonly quantiles: ArrayType<FloatType>;
+            /** Number of input features */
+            readonly n_features: IntegerType;
+            /** Column indices of categorical features (for prediction) */
+            readonly categorical_features: OptionType<ArrayType<IntegerType>>;
         }>;
     }>>;
     /** Train XGBoost classifier */
-    readonly trainClassifier: import("@elaraai/east").PlatformDefinition<[import("@elaraai/east").ArrayType<import("@elaraai/east").ArrayType<FloatType>>, import("@elaraai/east").ArrayType<IntegerType>, StructType<{
+    readonly trainClassifier: import("@elaraai/east").PlatformDefinition<[ArrayType<ArrayType<FloatType>>, ArrayType<IntegerType>, StructType<{
         /** Number of boosting rounds (default 100) */
-        n_estimators: OptionType<IntegerType>;
+        readonly n_estimators: OptionType<IntegerType>;
         /** Maximum tree depth (default 6) */
-        max_depth: OptionType<IntegerType>;
+        readonly max_depth: OptionType<IntegerType>;
         /** Learning rate / step size shrinkage (default 0.3) */
-        learning_rate: OptionType<FloatType>;
+        readonly learning_rate: OptionType<FloatType>;
         /** Minimum sum of instance weight needed in a child (default 1) */
-        min_child_weight: OptionType<IntegerType>;
+        readonly min_child_weight: OptionType<IntegerType>;
         /** Subsample ratio of training instances (default 1.0) */
-        subsample: OptionType<FloatType>;
+        readonly subsample: OptionType<FloatType>;
         /** Subsample ratio of columns when constructing trees (default 1.0) */
-        colsample_bytree: OptionType<FloatType>;
+        readonly colsample_bytree: OptionType<FloatType>;
         /** L1 regularization term (default 0) */
-        reg_alpha: OptionType<FloatType>;
+        readonly reg_alpha: OptionType<FloatType>;
         /** L2 regularization term (default 1) */
-        reg_lambda: OptionType<FloatType>;
+        readonly reg_lambda: OptionType<FloatType>;
+        /** Minimum loss reduction required to make a further partition (default 0) */
+        readonly gamma: OptionType<FloatType>;
         /** Random seed for reproducibility */
-        random_state: OptionType<IntegerType>;
+        readonly random_state: OptionType<IntegerType>;
         /** Number of parallel threads (default -1 for all cores) */
-        n_jobs: OptionType<IntegerType>;
+        readonly n_jobs: OptionType<IntegerType>;
+        /** Sample weights for training (one per sample, default uniform) */
+        readonly sample_weight: OptionType<ArrayType<FloatType>>;
+        /** Column indices that contain categorical features (0-indexed) */
+        readonly categorical_features: OptionType<ArrayType<IntegerType>>;
+        /** Max categories for one-hot encoding (default 4). Features with more categories use partition-based splits. */
+        readonly max_cat_to_onehot: OptionType<IntegerType>;
+        /** Max categories considered per split for partition-based method (default 64). */
+        readonly max_cat_threshold: OptionType<IntegerType>;
     }>], VariantType<{
         /** XGBoost regressor model */
-        xgboost_regressor: StructType<{
+        readonly xgboost_regressor: StructType<{
             /** Cloudpickle serialized model */
-            data: BlobType;
+            readonly data: BlobType;
             /** Number of input features */
-            n_features: IntegerType;
+            readonly n_features: IntegerType;
+            /** Column indices of categorical features (for prediction) */
+            readonly categorical_features: OptionType<ArrayType<IntegerType>>;
         }>;
         /** XGBoost classifier model */
-        xgboost_classifier: StructType<{
+        readonly xgboost_classifier: StructType<{
             /** Cloudpickle serialized model */
-            data: BlobType;
+            readonly data: BlobType;
             /** Number of input features */
-            n_features: IntegerType;
+            readonly n_features: IntegerType;
             /** Number of classes */
-            n_classes: IntegerType;
+            readonly n_classes: IntegerType;
+            /** Column indices of categorical features (for prediction) */
+            readonly categorical_features: OptionType<ArrayType<IntegerType>>;
+        }>;
+        /** XGBoost quantile regressor (multiple models, one per quantile) */
+        readonly xgboost_quantile: StructType<{
+            /** Cloudpickle serialized dict of {quantile: model} */
+            readonly data: BlobType;
+            /** Quantiles this model predicts */
+            readonly quantiles: ArrayType<FloatType>;
+            /** Number of input features */
+            readonly n_features: IntegerType;
+            /** Column indices of categorical features (for prediction) */
+            readonly categorical_features: OptionType<ArrayType<IntegerType>>;
+        }>;
+    }>>;
+    /** Train XGBoost quantile regressor */
+    readonly trainQuantile: import("@elaraai/east").PlatformDefinition<[ArrayType<ArrayType<FloatType>>, ArrayType<FloatType>, StructType<{
+        /** Quantiles to predict (e.g., [0.1, 0.5, 0.9] for 80% interval + median) */
+        readonly quantiles: ArrayType<FloatType>;
+        /** Number of boosting rounds (default 100) */
+        readonly n_estimators: OptionType<IntegerType>;
+        /** Maximum tree depth (default 6) */
+        readonly max_depth: OptionType<IntegerType>;
+        /** Learning rate / step size shrinkage (default 0.3) */
+        readonly learning_rate: OptionType<FloatType>;
+        /** Minimum sum of instance weight needed in a child (default 1) */
+        readonly min_child_weight: OptionType<IntegerType>;
+        /** Subsample ratio of training instances (default 1.0) */
+        readonly subsample: OptionType<FloatType>;
+        /** Subsample ratio of columns when constructing trees (default 1.0) */
+        readonly colsample_bytree: OptionType<FloatType>;
+        /** L1 regularization term (default 0) */
+        readonly reg_alpha: OptionType<FloatType>;
+        /** L2 regularization term (default 1) */
+        readonly reg_lambda: OptionType<FloatType>;
+        /** Minimum loss reduction required to make a further partition (default 0) */
+        readonly gamma: OptionType<FloatType>;
+        /** Random seed for reproducibility */
+        readonly random_state: OptionType<IntegerType>;
+        /** Number of parallel threads (default -1 for all cores) */
+        readonly n_jobs: OptionType<IntegerType>;
+        /** Sample weights for training (one per sample, default uniform) */
+        readonly sample_weight: OptionType<ArrayType<FloatType>>;
+        /** Column indices that contain categorical features (0-indexed) */
+        readonly categorical_features: OptionType<ArrayType<IntegerType>>;
+        /** Max categories for one-hot encoding (default 4). Features with more categories use partition-based splits. */
+        readonly max_cat_to_onehot: OptionType<IntegerType>;
+        /** Max categories considered per split for partition-based method (default 64). */
+        readonly max_cat_threshold: OptionType<IntegerType>;
+    }>], VariantType<{
+        /** XGBoost regressor model */
+        readonly xgboost_regressor: StructType<{
+            /** Cloudpickle serialized model */
+            readonly data: BlobType;
+            /** Number of input features */
+            readonly n_features: IntegerType;
+            /** Column indices of categorical features (for prediction) */
+            readonly categorical_features: OptionType<ArrayType<IntegerType>>;
+        }>;
+        /** XGBoost classifier model */
+        readonly xgboost_classifier: StructType<{
+            /** Cloudpickle serialized model */
+            readonly data: BlobType;
+            /** Number of input features */
+            readonly n_features: IntegerType;
+            /** Number of classes */
+            readonly n_classes: IntegerType;
+            /** Column indices of categorical features (for prediction) */
+            readonly categorical_features: OptionType<ArrayType<IntegerType>>;
+        }>;
+        /** XGBoost quantile regressor (multiple models, one per quantile) */
+        readonly xgboost_quantile: StructType<{
+            /** Cloudpickle serialized dict of {quantile: model} */
+            readonly data: BlobType;
+            /** Quantiles this model predicts */
+            readonly quantiles: ArrayType<FloatType>;
+            /** Number of input features */
+            readonly n_features: IntegerType;
+            /** Column indices of categorical features (for prediction) */
+            readonly categorical_features: OptionType<ArrayType<IntegerType>>;
         }>;
     }>>;
     /** Make predictions with regressor */
     readonly predict: import("@elaraai/east").PlatformDefinition<[VariantType<{
         /** XGBoost regressor model */
-        xgboost_regressor: StructType<{
+        readonly xgboost_regressor: StructType<{
             /** Cloudpickle serialized model */
-            data: BlobType;
+            readonly data: BlobType;
             /** Number of input features */
-            n_features: IntegerType;
+            readonly n_features: IntegerType;
+            /** Column indices of categorical features (for prediction) */
+            readonly categorical_features: OptionType<ArrayType<IntegerType>>;
         }>;
         /** XGBoost classifier model */
-        xgboost_classifier: StructType<{
+        readonly xgboost_classifier: StructType<{
             /** Cloudpickle serialized model */
-            data: BlobType;
+            readonly data: BlobType;
             /** Number of input features */
-            n_features: IntegerType;
+            readonly n_features: IntegerType;
             /** Number of classes */
-            n_classes: IntegerType;
+            readonly n_classes: IntegerType;
+            /** Column indices of categorical features (for prediction) */
+            readonly categorical_features: OptionType<ArrayType<IntegerType>>;
         }>;
-    }>, import("@elaraai/east").ArrayType<import("@elaraai/east").ArrayType<FloatType>>], import("@elaraai/east").ArrayType<FloatType>>;
+        /** XGBoost quantile regressor (multiple models, one per quantile) */
+        readonly xgboost_quantile: StructType<{
+            /** Cloudpickle serialized dict of {quantile: model} */
+            readonly data: BlobType;
+            /** Quantiles this model predicts */
+            readonly quantiles: ArrayType<FloatType>;
+            /** Number of input features */
+            readonly n_features: IntegerType;
+            /** Column indices of categorical features (for prediction) */
+            readonly categorical_features: OptionType<ArrayType<IntegerType>>;
+        }>;
+    }>, ArrayType<ArrayType<FloatType>>], ArrayType<FloatType>>;
     /** Predict class labels with classifier */
     readonly predictClass: import("@elaraai/east").PlatformDefinition<[VariantType<{
         /** XGBoost regressor model */
-        xgboost_regressor: StructType<{
+        readonly xgboost_regressor: StructType<{
             /** Cloudpickle serialized model */
-            data: BlobType;
+            readonly data: BlobType;
             /** Number of input features */
-            n_features: IntegerType;
+            readonly n_features: IntegerType;
+            /** Column indices of categorical features (for prediction) */
+            readonly categorical_features: OptionType<ArrayType<IntegerType>>;
         }>;
         /** XGBoost classifier model */
-        xgboost_classifier: StructType<{
+        readonly xgboost_classifier: StructType<{
             /** Cloudpickle serialized model */
-            data: BlobType;
+            readonly data: BlobType;
             /** Number of input features */
-            n_features: IntegerType;
+            readonly n_features: IntegerType;
             /** Number of classes */
-            n_classes: IntegerType;
+            readonly n_classes: IntegerType;
+            /** Column indices of categorical features (for prediction) */
+            readonly categorical_features: OptionType<ArrayType<IntegerType>>;
+        }>;
+        /** XGBoost quantile regressor (multiple models, one per quantile) */
+        readonly xgboost_quantile: StructType<{
+            /** Cloudpickle serialized dict of {quantile: model} */
+            readonly data: BlobType;
+            /** Quantiles this model predicts */
+            readonly quantiles: ArrayType<FloatType>;
+            /** Number of input features */
+            readonly n_features: IntegerType;
+            /** Column indices of categorical features (for prediction) */
+            readonly categorical_features: OptionType<ArrayType<IntegerType>>;
         }>;
-    }>, import("@elaraai/east").ArrayType<import("@elaraai/east").ArrayType<FloatType>>], import("@elaraai/east").ArrayType<IntegerType>>;
+    }>, ArrayType<ArrayType<FloatType>>], ArrayType<IntegerType>>;
     /** Get class probabilities from classifier */
     readonly predictProba: import("@elaraai/east").PlatformDefinition<[VariantType<{
         /** XGBoost regressor model */
-        xgboost_regressor: StructType<{
+        readonly xgboost_regressor: StructType<{
+            /** Cloudpickle serialized model */
+            readonly data: BlobType;
+            /** Number of input features */
+            readonly n_features: IntegerType;
+            /** Column indices of categorical features (for prediction) */
+            readonly categorical_features: OptionType<ArrayType<IntegerType>>;
+        }>;
+        /** XGBoost classifier model */
+        readonly xgboost_classifier: StructType<{
+            /** Cloudpickle serialized model */
+            readonly data: BlobType;
+            /** Number of input features */
+            readonly n_features: IntegerType;
+            /** Number of classes */
+            readonly n_classes: IntegerType;
+            /** Column indices of categorical features (for prediction) */
+            readonly categorical_features: OptionType<ArrayType<IntegerType>>;
+        }>;
+        /** XGBoost quantile regressor (multiple models, one per quantile) */
+        readonly xgboost_quantile: StructType<{
+            /** Cloudpickle serialized dict of {quantile: model} */
+            readonly data: BlobType;
+            /** Quantiles this model predicts */
+            readonly quantiles: ArrayType<FloatType>;
+            /** Number of input features */
+            readonly n_features: IntegerType;
+            /** Column indices of categorical features (for prediction) */
+            readonly categorical_features: OptionType<ArrayType<IntegerType>>;
+        }>;
+    }>, ArrayType<ArrayType<FloatType>>], ArrayType<ArrayType<FloatType>>>;
+    /** Predict quantiles with quantile regressor */
+    readonly predictQuantile: import("@elaraai/east").PlatformDefinition<[VariantType<{
+        /** XGBoost regressor model */
+        readonly xgboost_regressor: StructType<{
             /** Cloudpickle serialized model */
-            data: BlobType;
+            readonly data: BlobType;
             /** Number of input features */
-            n_features: IntegerType;
+            readonly n_features: IntegerType;
+            /** Column indices of categorical features (for prediction) */
+            readonly categorical_features: OptionType<ArrayType<IntegerType>>;
         }>;
         /** XGBoost classifier model */
-        xgboost_classifier: StructType<{
+        readonly xgboost_classifier: StructType<{
             /** Cloudpickle serialized model */
-            data: BlobType;
+            readonly data: BlobType;
             /** Number of input features */
-            n_features: IntegerType;
+            readonly n_features: IntegerType;
             /** Number of classes */
-            n_classes: IntegerType;
+            readonly n_classes: IntegerType;
+            /** Column indices of categorical features (for prediction) */
+            readonly categorical_features: OptionType<ArrayType<IntegerType>>;
+        }>;
+        /** XGBoost quantile regressor (multiple models, one per quantile) */
+        readonly xgboost_quantile: StructType<{
+            /** Cloudpickle serialized dict of {quantile: model} */
+            readonly data: BlobType;
+            /** Quantiles this model predicts */
+            readonly quantiles: ArrayType<FloatType>;
+            /** Number of input features */
+            readonly n_features: IntegerType;
+            /** Column indices of categorical features (for prediction) */
+            readonly categorical_features: OptionType<ArrayType<IntegerType>>;
         }>;
-    }>, import("@elaraai/east").ArrayType<import("@elaraai/east").ArrayType<FloatType>>], import("@elaraai/east").ArrayType<import("@elaraai/east").ArrayType<FloatType>>>;
+    }>, ArrayType<ArrayType<FloatType>>], StructType<{
+        /** Quantile values that were predicted */
+        readonly quantiles: ArrayType<FloatType>;
+        /** Predictions matrix: (n_samples x n_quantiles) */
+        readonly predictions: ArrayType<ArrayType<FloatType>>;
+    }>>;
     /** Type definitions */
     readonly Types: {
         /** Vector type (array of floats) */
-        readonly VectorType: import("@elaraai/east").ArrayType<FloatType>;
+        readonly VectorType: ArrayType<FloatType>;
         /** Matrix type (2D array of floats) */
-        readonly MatrixType: import("@elaraai/east").ArrayType<import("@elaraai/east").ArrayType<FloatType>>;
+        readonly MatrixType: ArrayType<ArrayType<FloatType>>;
         /** Label vector type (array of integers) */
-        readonly LabelVectorType: import("@elaraai/east").ArrayType<IntegerType>;
+        readonly LabelVectorType: ArrayType<IntegerType>;
         /** XGBoost configuration type */
         readonly XGBoostConfigType: StructType<{
             /** Number of boosting rounds (default 100) */
-            n_estimators: OptionType<IntegerType>;
+            readonly n_estimators: OptionType<IntegerType>;
+            /** Maximum tree depth (default 6) */
+            readonly max_depth: OptionType<IntegerType>;
+            /** Learning rate / step size shrinkage (default 0.3) */
+            readonly learning_rate: OptionType<FloatType>;
+            /** Minimum sum of instance weight needed in a child (default 1) */
+            readonly min_child_weight: OptionType<IntegerType>;
+            /** Subsample ratio of training instances (default 1.0) */
+            readonly subsample: OptionType<FloatType>;
+            /** Subsample ratio of columns when constructing trees (default 1.0) */
+            readonly colsample_bytree: OptionType<FloatType>;
+            /** L1 regularization term (default 0) */
+            readonly reg_alpha: OptionType<FloatType>;
+            /** L2 regularization term (default 1) */
+            readonly reg_lambda: OptionType<FloatType>;
+            /** Minimum loss reduction required to make a further partition (default 0) */
+            readonly gamma: OptionType<FloatType>;
+            /** Random seed for reproducibility */
+            readonly random_state: OptionType<IntegerType>;
+            /** Number of parallel threads (default -1 for all cores) */
+            readonly n_jobs: OptionType<IntegerType>;
+            /** Sample weights for training (one per sample, default uniform) */
+            readonly sample_weight: OptionType<ArrayType<FloatType>>;
+            /** Column indices that contain categorical features (0-indexed) */
+            readonly categorical_features: OptionType<ArrayType<IntegerType>>;
+            /** Max categories for one-hot encoding (default 4). Features with more categories use partition-based splits. */
+            readonly max_cat_to_onehot: OptionType<IntegerType>;
+            /** Max categories considered per split for partition-based method (default 64). */
+            readonly max_cat_threshold: OptionType<IntegerType>;
+        }>;
+        /** XGBoost quantile configuration type */
+        readonly XGBoostQuantileConfigType: StructType<{
+            /** Quantiles to predict (e.g., [0.1, 0.5, 0.9] for 80% interval + median) */
+            readonly quantiles: ArrayType<FloatType>;
+            /** Number of boosting rounds (default 100) */
+            readonly n_estimators: OptionType<IntegerType>;
             /** Maximum tree depth (default 6) */
-            max_depth: OptionType<IntegerType>;
+            readonly max_depth: OptionType<IntegerType>;
             /** Learning rate / step size shrinkage (default 0.3) */
-            learning_rate: OptionType<FloatType>;
+            readonly learning_rate: OptionType<FloatType>;
             /** Minimum sum of instance weight needed in a child (default 1) */
-            min_child_weight: OptionType<IntegerType>;
+            readonly min_child_weight: OptionType<IntegerType>;
             /** Subsample ratio of training instances (default 1.0) */
-            subsample: OptionType<FloatType>;
+            readonly subsample: OptionType<FloatType>;
             /** Subsample ratio of columns when constructing trees (default 1.0) */
-            colsample_bytree: OptionType<FloatType>;
+            readonly colsample_bytree: OptionType<FloatType>;
             /** L1 regularization term (default 0) */
-            reg_alpha: OptionType<FloatType>;
+            readonly reg_alpha: OptionType<FloatType>;
             /** L2 regularization term (default 1) */
-            reg_lambda: OptionType<FloatType>;
+            readonly reg_lambda: OptionType<FloatType>;
+            /** Minimum loss reduction required to make a further partition (default 0) */
+            readonly gamma: OptionType<FloatType>;
             /** Random seed for reproducibility */
-            random_state: OptionType<IntegerType>;
+            readonly random_state: OptionType<IntegerType>;
             /** Number of parallel threads (default -1 for all cores) */
-            n_jobs: OptionType<IntegerType>;
+            readonly n_jobs: OptionType<IntegerType>;
+            /** Sample weights for training (one per sample, default uniform) */
+            readonly sample_weight: OptionType<ArrayType<FloatType>>;
+            /** Column indices that contain categorical features (0-indexed) */
+            readonly categorical_features: OptionType<ArrayType<IntegerType>>;
+            /** Max categories for one-hot encoding (default 4). Features with more categories use partition-based splits. */
+            readonly max_cat_to_onehot: OptionType<IntegerType>;
+            /** Max categories considered per split for partition-based method (default 64). */
+            readonly max_cat_threshold: OptionType<IntegerType>;
+        }>;
+        /** Quantile prediction result type */
+        readonly XGBoostQuantilePredictResultType: StructType<{
+            /** Quantile values that were predicted */
+            readonly quantiles: ArrayType<FloatType>;
+            /** Predictions matrix: (n_samples x n_quantiles) */
+            readonly predictions: ArrayType<ArrayType<FloatType>>;
         }>;
         /** Model blob type for XGBoost models */
         readonly ModelBlobType: VariantType<{
             /** XGBoost regressor model */
-            xgboost_regressor: StructType<{
+            readonly xgboost_regressor: StructType<{
                 /** Cloudpickle serialized model */
-                data: BlobType;
+                readonly data: BlobType;
                 /** Number of input features */
-                n_features: IntegerType;
+                readonly n_features: IntegerType;
+                /** Column indices of categorical features (for prediction) */
+                readonly categorical_features: OptionType<ArrayType<IntegerType>>;
             }>;
             /** XGBoost classifier model */
-            xgboost_classifier: StructType<{
+            readonly xgboost_classifier: StructType<{
                 /** Cloudpickle serialized model */
-                data: BlobType;
+                readonly data: BlobType;
                 /** Number of input features */
-                n_features: IntegerType;
+                readonly n_features: IntegerType;
                 /** Number of classes */
-                n_classes: IntegerType;
+                readonly n_classes: IntegerType;
+                /** Column indices of categorical features (for prediction) */
+                readonly categorical_features: OptionType<ArrayType<IntegerType>>;
+            }>;
+            /** XGBoost quantile regressor (multiple models, one per quantile) */
+            readonly xgboost_quantile: StructType<{
+                /** Cloudpickle serialized dict of {quantile: model} */
+                readonly data: BlobType;
+                /** Quantiles this model predicts */
+                readonly quantiles: ArrayType<FloatType>;
+                /** Number of input features */
+                readonly n_features: IntegerType;
+                /** Column indices of categorical features (for prediction) */
+                readonly categorical_features: OptionType<ArrayType<IntegerType>>;
             }>;
         }>;
     };