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

package/dist/xgboost/xgboost.d.ts

@@ -36,6 +36,38 @@ export declare const XGBoostConfigType: StructType<{
     random_state: OptionType<IntegerType>;
     /** Number of parallel threads (default -1 for all cores) */
     n_jobs: OptionType<IntegerType>;
+    /** Sample weights for training (one per sample, default uniform) */
+    sample_weight: OptionType<import("@elaraai/east").ArrayType<FloatType>>;
+}>;
+/**
+ * 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) */
+    quantiles: import("@elaraai/east").ArrayType<FloatType>;
+    /** Number of boosting rounds (default 100) */
+    n_estimators: OptionType<IntegerType>;
+    /** Maximum tree depth (default 6) */
+    max_depth: OptionType<IntegerType>;
+    /** Learning rate / step size shrinkage (default 0.3) */
+    learning_rate: OptionType<FloatType>;
+    /** Minimum sum of instance weight needed in a child (default 1) */
+    min_child_weight: OptionType<IntegerType>;
+    /** Subsample ratio of training instances (default 1.0) */
+    subsample: OptionType<FloatType>;
+    /** Subsample ratio of columns when constructing trees (default 1.0) */
+    colsample_bytree: OptionType<FloatType>;
+    /** L1 regularization term (default 0) */
+    reg_alpha: OptionType<FloatType>;
+    /** L2 regularization term (default 1) */
+    reg_lambda: OptionType<FloatType>;
+    /** Random seed for reproducibility */
+    random_state: OptionType<IntegerType>;
+    /** Number of parallel threads (default -1 for all cores) */
+    n_jobs: OptionType<IntegerType>;
+    /** Sample weights for training (one per sample, default uniform) */
+    sample_weight: OptionType<import("@elaraai/east").ArrayType<FloatType>>;
 }>;
 /**
  * Model blob type for serialized XGBoost models.
@@ -59,6 +91,24 @@ export declare const XGBoostModelBlobType: VariantType<{
         /** Number of classes */
         n_classes: IntegerType;
     }>;
+    /** XGBoost quantile regressor (multiple models, one per quantile) */
+    xgboost_quantile: StructType<{
+        /** Cloudpickle serialized dict of {quantile: model} */
+        data: BlobType;
+        /** Quantiles this model predicts */
+        quantiles: import("@elaraai/east").ArrayType<FloatType>;
+        /** Number of input features */
+        n_features: IntegerType;
+    }>;
+}>;
+/**
+ * Result from XGBoost quantile prediction.
+ */
+export declare const XGBoostQuantilePredictResultType: StructType<{
+    /** Quantile values that were predicted */
+    quantiles: import("@elaraai/east").ArrayType<FloatType>;
+    /** Predictions matrix: (n_samples x n_quantiles) */
+    predictions: import("@elaraai/east").ArrayType<import("@elaraai/east").ArrayType<FloatType>>;
 }>;
 /**
  * Train an XGBoost regression model.
@@ -89,6 +139,8 @@ export declare const xgboost_train_regressor: import("@elaraai/east").PlatformDe
     random_state: OptionType<IntegerType>;
     /** Number of parallel threads (default -1 for all cores) */
     n_jobs: OptionType<IntegerType>;
+    /** Sample weights for training (one per sample, default uniform) */
+    sample_weight: OptionType<import("@elaraai/east").ArrayType<FloatType>>;
 }>], VariantType<{
     /** XGBoost regressor model */
     xgboost_regressor: StructType<{
@@ -106,6 +158,15 @@ export declare const xgboost_train_regressor: import("@elaraai/east").PlatformDe
         /** Number of classes */
         n_classes: IntegerType;
     }>;
+    /** XGBoost quantile regressor (multiple models, one per quantile) */
+    xgboost_quantile: StructType<{
+        /** Cloudpickle serialized dict of {quantile: model} */
+        data: BlobType;
+        /** Quantiles this model predicts */
+        quantiles: import("@elaraai/east").ArrayType<FloatType>;
+        /** Number of input features */
+        n_features: IntegerType;
+    }>;
 }>>;
 /**
  * Train an XGBoost classification model.
@@ -136,6 +197,8 @@ export declare const xgboost_train_classifier: import("@elaraai/east").PlatformD
     random_state: OptionType<IntegerType>;
     /** Number of parallel threads (default -1 for all cores) */
     n_jobs: OptionType<IntegerType>;
+    /** Sample weights for training (one per sample, default uniform) */
+    sample_weight: OptionType<import("@elaraai/east").ArrayType<FloatType>>;
 }>], VariantType<{
     /** XGBoost regressor model */
     xgboost_regressor: StructType<{
@@ -153,6 +216,15 @@ export declare const xgboost_train_classifier: import("@elaraai/east").PlatformD
         /** Number of classes */
         n_classes: IntegerType;
     }>;
+    /** XGBoost quantile regressor (multiple models, one per quantile) */
+    xgboost_quantile: StructType<{
+        /** Cloudpickle serialized dict of {quantile: model} */
+        data: BlobType;
+        /** Quantiles this model predicts */
+        quantiles: import("@elaraai/east").ArrayType<FloatType>;
+        /** Number of input features */
+        n_features: IntegerType;
+    }>;
 }>>;
 /**
  * Make predictions with a trained XGBoost regressor.
@@ -178,6 +250,15 @@ export declare const xgboost_predict: import("@elaraai/east").PlatformDefinition
         /** Number of classes */
         n_classes: IntegerType;
     }>;
+    /** XGBoost quantile regressor (multiple models, one per quantile) */
+    xgboost_quantile: StructType<{
+        /** Cloudpickle serialized dict of {quantile: model} */
+        data: BlobType;
+        /** Quantiles this model predicts */
+        quantiles: import("@elaraai/east").ArrayType<FloatType>;
+        /** Number of input features */
+        n_features: IntegerType;
+    }>;
 }>, import("@elaraai/east").ArrayType<import("@elaraai/east").ArrayType<FloatType>>], import("@elaraai/east").ArrayType<FloatType>>;
 /**
  * Predict class labels with a trained XGBoost classifier.
@@ -203,6 +284,15 @@ export declare const xgboost_predict_class: import("@elaraai/east").PlatformDefi
         /** Number of classes */
         n_classes: IntegerType;
     }>;
+    /** XGBoost quantile regressor (multiple models, one per quantile) */
+    xgboost_quantile: StructType<{
+        /** Cloudpickle serialized dict of {quantile: model} */
+        data: BlobType;
+        /** Quantiles this model predicts */
+        quantiles: import("@elaraai/east").ArrayType<FloatType>;
+        /** Number of input features */
+        n_features: IntegerType;
+    }>;
 }>, import("@elaraai/east").ArrayType<import("@elaraai/east").ArrayType<FloatType>>], import("@elaraai/east").ArrayType<IntegerType>>;
 /**
  * Get class probabilities from a trained XGBoost classifier.
@@ -228,7 +318,118 @@ export declare const xgboost_predict_proba: import("@elaraai/east").PlatformDefi
         /** Number of classes */
         n_classes: IntegerType;
     }>;
+    /** XGBoost quantile regressor (multiple models, one per quantile) */
+    xgboost_quantile: StructType<{
+        /** Cloudpickle serialized dict of {quantile: model} */
+        data: BlobType;
+        /** Quantiles this model predicts */
+        quantiles: import("@elaraai/east").ArrayType<FloatType>;
+        /** Number of input features */
+        n_features: IntegerType;
+    }>;
 }>, import("@elaraai/east").ArrayType<import("@elaraai/east").ArrayType<FloatType>>], import("@elaraai/east").ArrayType<import("@elaraai/east").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<[import("@elaraai/east").ArrayType<import("@elaraai/east").ArrayType<FloatType>>, import("@elaraai/east").ArrayType<FloatType>, StructType<{
+    /** Quantiles to predict (e.g., [0.1, 0.5, 0.9] for 80% interval + median) */
+    quantiles: import("@elaraai/east").ArrayType<FloatType>;
+    /** Number of boosting rounds (default 100) */
+    n_estimators: OptionType<IntegerType>;
+    /** Maximum tree depth (default 6) */
+    max_depth: OptionType<IntegerType>;
+    /** Learning rate / step size shrinkage (default 0.3) */
+    learning_rate: OptionType<FloatType>;
+    /** Minimum sum of instance weight needed in a child (default 1) */
+    min_child_weight: OptionType<IntegerType>;
+    /** Subsample ratio of training instances (default 1.0) */
+    subsample: OptionType<FloatType>;
+    /** Subsample ratio of columns when constructing trees (default 1.0) */
+    colsample_bytree: OptionType<FloatType>;
+    /** L1 regularization term (default 0) */
+    reg_alpha: OptionType<FloatType>;
+    /** L2 regularization term (default 1) */
+    reg_lambda: OptionType<FloatType>;
+    /** Random seed for reproducibility */
+    random_state: OptionType<IntegerType>;
+    /** Number of parallel threads (default -1 for all cores) */
+    n_jobs: OptionType<IntegerType>;
+    /** Sample weights for training (one per sample, default uniform) */
+    sample_weight: OptionType<import("@elaraai/east").ArrayType<FloatType>>;
+}>], VariantType<{
+    /** XGBoost regressor model */
+    xgboost_regressor: StructType<{
+        /** Cloudpickle serialized model */
+        data: BlobType;
+        /** Number of input features */
+        n_features: IntegerType;
+    }>;
+    /** XGBoost classifier model */
+    xgboost_classifier: StructType<{
+        /** Cloudpickle serialized model */
+        data: BlobType;
+        /** Number of input features */
+        n_features: IntegerType;
+        /** Number of classes */
+        n_classes: IntegerType;
+    }>;
+    /** XGBoost quantile regressor (multiple models, one per quantile) */
+    xgboost_quantile: StructType<{
+        /** Cloudpickle serialized dict of {quantile: model} */
+        data: BlobType;
+        /** Quantiles this model predicts */
+        quantiles: import("@elaraai/east").ArrayType<FloatType>;
+        /** Number of input features */
+        n_features: 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 */
+    xgboost_regressor: StructType<{
+        /** Cloudpickle serialized model */
+        data: BlobType;
+        /** Number of input features */
+        n_features: IntegerType;
+    }>;
+    /** XGBoost classifier model */
+    xgboost_classifier: StructType<{
+        /** Cloudpickle serialized model */
+        data: BlobType;
+        /** Number of input features */
+        n_features: IntegerType;
+        /** Number of classes */
+        n_classes: IntegerType;
+    }>;
+    /** XGBoost quantile regressor (multiple models, one per quantile) */
+    xgboost_quantile: StructType<{
+        /** Cloudpickle serialized dict of {quantile: model} */
+        data: BlobType;
+        /** Quantiles this model predicts */
+        quantiles: import("@elaraai/east").ArrayType<FloatType>;
+        /** Number of input features */
+        n_features: IntegerType;
+    }>;
+}>, import("@elaraai/east").ArrayType<import("@elaraai/east").ArrayType<FloatType>>], StructType<{
+    /** Quantile values that were predicted */
+    quantiles: import("@elaraai/east").ArrayType<FloatType>;
+    /** Predictions matrix: (n_samples x n_quantiles) */
+    predictions: import("@elaraai/east").ArrayType<import("@elaraai/east").ArrayType<FloatType>>;
+}>>;
 /**
  * Type definitions for XGBoost functions.
  */
@@ -261,6 +462,42 @@ export declare const XGBoostTypes: {
         random_state: OptionType<IntegerType>;
         /** Number of parallel threads (default -1 for all cores) */
         n_jobs: OptionType<IntegerType>;
+        /** Sample weights for training (one per sample, default uniform) */
+        sample_weight: OptionType<import("@elaraai/east").ArrayType<FloatType>>;
+    }>;
+    /** XGBoost quantile configuration type */
+    readonly XGBoostQuantileConfigType: StructType<{
+        /** Quantiles to predict (e.g., [0.1, 0.5, 0.9] for 80% interval + median) */
+        quantiles: import("@elaraai/east").ArrayType<FloatType>;
+        /** Number of boosting rounds (default 100) */
+        n_estimators: OptionType<IntegerType>;
+        /** Maximum tree depth (default 6) */
+        max_depth: OptionType<IntegerType>;
+        /** Learning rate / step size shrinkage (default 0.3) */
+        learning_rate: OptionType<FloatType>;
+        /** Minimum sum of instance weight needed in a child (default 1) */
+        min_child_weight: OptionType<IntegerType>;
+        /** Subsample ratio of training instances (default 1.0) */
+        subsample: OptionType<FloatType>;
+        /** Subsample ratio of columns when constructing trees (default 1.0) */
+        colsample_bytree: OptionType<FloatType>;
+        /** L1 regularization term (default 0) */
+        reg_alpha: OptionType<FloatType>;
+        /** L2 regularization term (default 1) */
+        reg_lambda: OptionType<FloatType>;
+        /** Random seed for reproducibility */
+        random_state: OptionType<IntegerType>;
+        /** Number of parallel threads (default -1 for all cores) */
+        n_jobs: OptionType<IntegerType>;
+        /** Sample weights for training (one per sample, default uniform) */
+        sample_weight: OptionType<import("@elaraai/east").ArrayType<FloatType>>;
+    }>;
+    /** Quantile prediction result type */
+    readonly XGBoostQuantilePredictResultType: StructType<{
+        /** Quantile values that were predicted */
+        quantiles: import("@elaraai/east").ArrayType<FloatType>;
+        /** Predictions matrix: (n_samples x n_quantiles) */
+        predictions: import("@elaraai/east").ArrayType<import("@elaraai/east").ArrayType<FloatType>>;
     }>;
     /** Model blob type for XGBoost models */
     readonly ModelBlobType: VariantType<{
@@ -280,6 +517,15 @@ export declare const XGBoostTypes: {
             /** Number of classes */
             n_classes: IntegerType;
         }>;
+        /** XGBoost quantile regressor (multiple models, one per quantile) */
+        xgboost_quantile: StructType<{
+            /** Cloudpickle serialized dict of {quantile: model} */
+            data: BlobType;
+            /** Quantiles this model predicts */
+            quantiles: import("@elaraai/east").ArrayType<FloatType>;
+            /** Number of input features */
+            n_features: IntegerType;
+        }>;
     }>;
 };
 /**
@@ -306,6 +552,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));
  * });
@@ -334,6 +581,8 @@ export declare const XGBoost: {
         random_state: OptionType<IntegerType>;
         /** Number of parallel threads (default -1 for all cores) */
         n_jobs: OptionType<IntegerType>;
+        /** Sample weights for training (one per sample, default uniform) */
+        sample_weight: OptionType<import("@elaraai/east").ArrayType<FloatType>>;
     }>], VariantType<{
         /** XGBoost regressor model */
         xgboost_regressor: StructType<{
@@ -351,6 +600,15 @@ export declare const XGBoost: {
             /** Number of classes */
             n_classes: IntegerType;
         }>;
+        /** XGBoost quantile regressor (multiple models, one per quantile) */
+        xgboost_quantile: StructType<{
+            /** Cloudpickle serialized dict of {quantile: model} */
+            data: BlobType;
+            /** Quantiles this model predicts */
+            quantiles: import("@elaraai/east").ArrayType<FloatType>;
+            /** Number of input features */
+            n_features: 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<{
@@ -374,6 +632,8 @@ export declare const XGBoost: {
         random_state: OptionType<IntegerType>;
         /** Number of parallel threads (default -1 for all cores) */
         n_jobs: OptionType<IntegerType>;
+        /** Sample weights for training (one per sample, default uniform) */
+        sample_weight: OptionType<import("@elaraai/east").ArrayType<FloatType>>;
     }>], VariantType<{
         /** XGBoost regressor model */
         xgboost_regressor: StructType<{
@@ -391,6 +651,68 @@ export declare const XGBoost: {
             /** Number of classes */
             n_classes: IntegerType;
         }>;
+        /** XGBoost quantile regressor (multiple models, one per quantile) */
+        xgboost_quantile: StructType<{
+            /** Cloudpickle serialized dict of {quantile: model} */
+            data: BlobType;
+            /** Quantiles this model predicts */
+            quantiles: import("@elaraai/east").ArrayType<FloatType>;
+            /** Number of input features */
+            n_features: IntegerType;
+        }>;
+    }>>;
+    /** Train XGBoost quantile regressor */
+    readonly trainQuantile: import("@elaraai/east").PlatformDefinition<[import("@elaraai/east").ArrayType<import("@elaraai/east").ArrayType<FloatType>>, import("@elaraai/east").ArrayType<FloatType>, StructType<{
+        /** Quantiles to predict (e.g., [0.1, 0.5, 0.9] for 80% interval + median) */
+        quantiles: import("@elaraai/east").ArrayType<FloatType>;
+        /** Number of boosting rounds (default 100) */
+        n_estimators: OptionType<IntegerType>;
+        /** Maximum tree depth (default 6) */
+        max_depth: OptionType<IntegerType>;
+        /** Learning rate / step size shrinkage (default 0.3) */
+        learning_rate: OptionType<FloatType>;
+        /** Minimum sum of instance weight needed in a child (default 1) */
+        min_child_weight: OptionType<IntegerType>;
+        /** Subsample ratio of training instances (default 1.0) */
+        subsample: OptionType<FloatType>;
+        /** Subsample ratio of columns when constructing trees (default 1.0) */
+        colsample_bytree: OptionType<FloatType>;
+        /** L1 regularization term (default 0) */
+        reg_alpha: OptionType<FloatType>;
+        /** L2 regularization term (default 1) */
+        reg_lambda: OptionType<FloatType>;
+        /** Random seed for reproducibility */
+        random_state: OptionType<IntegerType>;
+        /** Number of parallel threads (default -1 for all cores) */
+        n_jobs: OptionType<IntegerType>;
+        /** Sample weights for training (one per sample, default uniform) */
+        sample_weight: OptionType<import("@elaraai/east").ArrayType<FloatType>>;
+    }>], VariantType<{
+        /** XGBoost regressor model */
+        xgboost_regressor: StructType<{
+            /** Cloudpickle serialized model */
+            data: BlobType;
+            /** Number of input features */
+            n_features: IntegerType;
+        }>;
+        /** XGBoost classifier model */
+        xgboost_classifier: StructType<{
+            /** Cloudpickle serialized model */
+            data: BlobType;
+            /** Number of input features */
+            n_features: IntegerType;
+            /** Number of classes */
+            n_classes: IntegerType;
+        }>;
+        /** XGBoost quantile regressor (multiple models, one per quantile) */
+        xgboost_quantile: StructType<{
+            /** Cloudpickle serialized dict of {quantile: model} */
+            data: BlobType;
+            /** Quantiles this model predicts */
+            quantiles: import("@elaraai/east").ArrayType<FloatType>;
+            /** Number of input features */
+            n_features: IntegerType;
+        }>;
     }>>;
     /** Make predictions with regressor */
     readonly predict: import("@elaraai/east").PlatformDefinition<[VariantType<{
@@ -410,6 +732,15 @@ export declare const XGBoost: {
             /** Number of classes */
             n_classes: IntegerType;
         }>;
+        /** XGBoost quantile regressor (multiple models, one per quantile) */
+        xgboost_quantile: StructType<{
+            /** Cloudpickle serialized dict of {quantile: model} */
+            data: BlobType;
+            /** Quantiles this model predicts */
+            quantiles: import("@elaraai/east").ArrayType<FloatType>;
+            /** Number of input features */
+            n_features: IntegerType;
+        }>;
     }>, import("@elaraai/east").ArrayType<import("@elaraai/east").ArrayType<FloatType>>], import("@elaraai/east").ArrayType<FloatType>>;
     /** Predict class labels with classifier */
     readonly predictClass: import("@elaraai/east").PlatformDefinition<[VariantType<{
@@ -429,6 +760,15 @@ export declare const XGBoost: {
             /** Number of classes */
             n_classes: IntegerType;
         }>;
+        /** XGBoost quantile regressor (multiple models, one per quantile) */
+        xgboost_quantile: StructType<{
+            /** Cloudpickle serialized dict of {quantile: model} */
+            data: BlobType;
+            /** Quantiles this model predicts */
+            quantiles: import("@elaraai/east").ArrayType<FloatType>;
+            /** Number of input features */
+            n_features: IntegerType;
+        }>;
     }>, import("@elaraai/east").ArrayType<import("@elaraai/east").ArrayType<FloatType>>], import("@elaraai/east").ArrayType<IntegerType>>;
     /** Get class probabilities from classifier */
     readonly predictProba: import("@elaraai/east").PlatformDefinition<[VariantType<{
@@ -448,7 +788,49 @@ export declare const XGBoost: {
             /** Number of classes */
             n_classes: IntegerType;
         }>;
+        /** XGBoost quantile regressor (multiple models, one per quantile) */
+        xgboost_quantile: StructType<{
+            /** Cloudpickle serialized dict of {quantile: model} */
+            data: BlobType;
+            /** Quantiles this model predicts */
+            quantiles: import("@elaraai/east").ArrayType<FloatType>;
+            /** Number of input features */
+            n_features: IntegerType;
+        }>;
     }>, import("@elaraai/east").ArrayType<import("@elaraai/east").ArrayType<FloatType>>], import("@elaraai/east").ArrayType<import("@elaraai/east").ArrayType<FloatType>>>;
+    /** Predict quantiles with quantile regressor */
+    readonly predictQuantile: import("@elaraai/east").PlatformDefinition<[VariantType<{
+        /** XGBoost regressor model */
+        xgboost_regressor: StructType<{
+            /** Cloudpickle serialized model */
+            data: BlobType;
+            /** Number of input features */
+            n_features: IntegerType;
+        }>;
+        /** XGBoost classifier model */
+        xgboost_classifier: StructType<{
+            /** Cloudpickle serialized model */
+            data: BlobType;
+            /** Number of input features */
+            n_features: IntegerType;
+            /** Number of classes */
+            n_classes: IntegerType;
+        }>;
+        /** XGBoost quantile regressor (multiple models, one per quantile) */
+        xgboost_quantile: StructType<{
+            /** Cloudpickle serialized dict of {quantile: model} */
+            data: BlobType;
+            /** Quantiles this model predicts */
+            quantiles: import("@elaraai/east").ArrayType<FloatType>;
+            /** Number of input features */
+            n_features: IntegerType;
+        }>;
+    }>, import("@elaraai/east").ArrayType<import("@elaraai/east").ArrayType<FloatType>>], StructType<{
+        /** Quantile values that were predicted */
+        quantiles: import("@elaraai/east").ArrayType<FloatType>;
+        /** Predictions matrix: (n_samples x n_quantiles) */
+        predictions: import("@elaraai/east").ArrayType<import("@elaraai/east").ArrayType<FloatType>>;
+    }>>;
     /** Type definitions */
     readonly Types: {
         /** Vector type (array of floats) */
@@ -479,6 +861,42 @@ export declare const XGBoost: {
             random_state: OptionType<IntegerType>;
             /** Number of parallel threads (default -1 for all cores) */
             n_jobs: OptionType<IntegerType>;
+            /** Sample weights for training (one per sample, default uniform) */
+            sample_weight: OptionType<import("@elaraai/east").ArrayType<FloatType>>;
+        }>;
+        /** XGBoost quantile configuration type */
+        readonly XGBoostQuantileConfigType: StructType<{
+            /** Quantiles to predict (e.g., [0.1, 0.5, 0.9] for 80% interval + median) */
+            quantiles: import("@elaraai/east").ArrayType<FloatType>;
+            /** Number of boosting rounds (default 100) */
+            n_estimators: OptionType<IntegerType>;
+            /** Maximum tree depth (default 6) */
+            max_depth: OptionType<IntegerType>;
+            /** Learning rate / step size shrinkage (default 0.3) */
+            learning_rate: OptionType<FloatType>;
+            /** Minimum sum of instance weight needed in a child (default 1) */
+            min_child_weight: OptionType<IntegerType>;
+            /** Subsample ratio of training instances (default 1.0) */
+            subsample: OptionType<FloatType>;
+            /** Subsample ratio of columns when constructing trees (default 1.0) */
+            colsample_bytree: OptionType<FloatType>;
+            /** L1 regularization term (default 0) */
+            reg_alpha: OptionType<FloatType>;
+            /** L2 regularization term (default 1) */
+            reg_lambda: OptionType<FloatType>;
+            /** Random seed for reproducibility */
+            random_state: OptionType<IntegerType>;
+            /** Number of parallel threads (default -1 for all cores) */
+            n_jobs: OptionType<IntegerType>;
+            /** Sample weights for training (one per sample, default uniform) */
+            sample_weight: OptionType<import("@elaraai/east").ArrayType<FloatType>>;
+        }>;
+        /** Quantile prediction result type */
+        readonly XGBoostQuantilePredictResultType: StructType<{
+            /** Quantile values that were predicted */
+            quantiles: import("@elaraai/east").ArrayType<FloatType>;
+            /** Predictions matrix: (n_samples x n_quantiles) */
+            predictions: import("@elaraai/east").ArrayType<import("@elaraai/east").ArrayType<FloatType>>;
         }>;
         /** Model blob type for XGBoost models */
         readonly ModelBlobType: VariantType<{
@@ -498,6 +916,15 @@ export declare const XGBoost: {
                 /** Number of classes */
                 n_classes: IntegerType;
             }>;
+            /** XGBoost quantile regressor (multiple models, one per quantile) */
+            xgboost_quantile: StructType<{
+                /** Cloudpickle serialized dict of {quantile: model} */
+                data: BlobType;
+                /** Quantiles this model predicts */
+                quantiles: import("@elaraai/east").ArrayType<FloatType>;
+                /** Number of input features */
+                n_features: IntegerType;
+            }>;
         }>;
     };
 };

package/dist/xgboost/xgboost.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"xgboost.d.ts","sourceRoot":"","sources":["../../src/xgboost/xgboost.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"xgboost.d.ts","sourceRoot":"","sources":["../../src/xgboost/xgboost.ts"],"names":[],"mappings":"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"}