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

package/dist/shap/shap.d.ts

@@ -10,119 +10,403 @@
  *
  * @packageDocumentation
  */
-import { StructType, VariantType, OptionType, IntegerType, FloatType, StringType, ArrayType, BlobType } from "@elaraai/east";
+import { StructType, VariantType, OptionType, IntegerType, FloatType, StringType, ArrayType, BlobType, NullType } from "@elaraai/east";
 export { VectorType, MatrixType } from "../types.js";
 /** String vector type for feature names */
 export declare const StringVectorType: ArrayType<StringType>;
+/**
+ * SHAP values type - variant for 2D (regression/binary) or 3D (multi-class).
+ */
+export declare const ShapValuesType: VariantType<{
+    /** 2D matrix for regression or binary classification (n_samples x n_features) */
+    readonly matrix_2d: ArrayType<ArrayType<FloatType>>;
+    /** 3D tensor for multi-class classification (n_samples x n_features x n_classes) */
+    readonly tensor_3d: ArrayType<ArrayType<ArrayType<FloatType>>>;
+}>;
+/**
+ * Base value type - variant for single (regression/binary) or per-class (multi-class).
+ */
+export declare const ShapBaseValueType: VariantType<{
+    /** Single base value for regression or binary classification */
+    readonly single: FloatType;
+    /** Per-class base values for multi-class classification */
+    readonly per_class: ArrayType<FloatType>;
+}>;
 /**
  * Result type for SHAP value computation.
  */
 export declare const ShapResultType: StructType<{
-    /** SHAP values matrix (n_samples x n_features) */
-    shap_values: ArrayType<ArrayType<FloatType>>;
-    /** Base value (expected model output) */
-    base_value: FloatType;
+    /** SHAP values - 2D matrix or 3D tensor depending on model type */
+    readonly shap_values: VariantType<{
+        /** 2D matrix for regression or binary classification (n_samples x n_features) */
+        readonly matrix_2d: ArrayType<ArrayType<FloatType>>;
+        /** 3D tensor for multi-class classification (n_samples x n_features x n_classes) */
+        readonly tensor_3d: ArrayType<ArrayType<ArrayType<FloatType>>>;
+    }>;
+    /** Base value(s) - single float or per-class array */
+    readonly base_value: VariantType<{
+        /** Single base value for regression or binary classification */
+        readonly single: FloatType;
+        /** Per-class base values for multi-class classification */
+        readonly per_class: ArrayType<FloatType>;
+    }>;
     /** Feature names */
-    feature_names: ArrayType<StringType>;
+    readonly feature_names: ArrayType<StringType>;
 }>;
 /**
  * Result type for feature importance.
  */
 export declare const FeatureImportanceType: StructType<{
     /** Feature names */
-    feature_names: ArrayType<StringType>;
+    readonly feature_names: ArrayType<StringType>;
     /** Mean absolute SHAP value for each feature */
-    importances: ArrayType<FloatType>;
+    readonly importances: ArrayType<FloatType>;
     /** Standard deviation of absolute SHAP values */
-    std: OptionType<ArrayType<FloatType>>;
+    readonly std: OptionType<ArrayType<FloatType>>;
 }>;
 /**
  * Model blob type for serialized SHAP explainers.
  */
 export declare const ShapModelBlobType: VariantType<{
     /** SHAP TreeExplainer for tree-based models */
-    shap_tree_explainer: StructType<{
+    readonly shap_tree_explainer: StructType<{
         /** Cloudpickle serialized explainer */
-        data: BlobType;
+        readonly data: BlobType;
         /** Number of input features */
-        n_features: IntegerType;
+        readonly n_features: IntegerType;
     }>;
     /** SHAP KernelExplainer for any model */
-    shap_kernel_explainer: StructType<{
+    readonly shap_kernel_explainer: StructType<{
         /** Cloudpickle serialized explainer */
-        data: BlobType;
+        readonly data: BlobType;
         /** Number of input features */
-        n_features: IntegerType;
+        readonly n_features: IntegerType;
     }>;
 }>;
 /**
- * Tree-based model blob type - accepts XGBoost and LightGBM models.
+ * Tree-based model blob type - accepts XGBoost models and MAPIE wrappers with XGBoost.
+ * Note: LightGBM is not supported for TreeExplainer due to SHAP compatibility issues.
+ * Use KernelExplainer for LightGBM models.
  */
 export declare const TreeModelBlobType: VariantType<{
     /** XGBoost regressor */
-    xgboost_regressor: StructType<{
-        data: BlobType;
-        n_features: IntegerType;
+    readonly xgboost_regressor: StructType<{
+        readonly data: BlobType;
+        readonly n_features: IntegerType;
+        readonly categorical_features: OptionType<ArrayType<IntegerType>>;
     }>;
     /** XGBoost classifier */
-    xgboost_classifier: StructType<{
-        data: BlobType;
-        n_features: IntegerType;
-        n_classes: IntegerType;
-    }>;
-    /** LightGBM regressor */
-    lightgbm_regressor: StructType<{
-        data: BlobType;
-        n_features: IntegerType;
-    }>;
-    /** LightGBM classifier */
-    lightgbm_classifier: StructType<{
-        data: BlobType;
-        n_features: IntegerType;
-        n_classes: IntegerType;
+    readonly xgboost_classifier: StructType<{
+        readonly data: BlobType;
+        readonly n_features: IntegerType;
+        readonly n_classes: IntegerType;
+        readonly categorical_features: OptionType<ArrayType<IntegerType>>;
+    }>;
+    /** XGBoost quantile regressor (uses median quantile for explanations) */
+    readonly xgboost_quantile: StructType<{
+        readonly data: BlobType;
+        readonly quantiles: ArrayType<FloatType>;
+        readonly n_features: IntegerType;
+        readonly categorical_features: OptionType<ArrayType<IntegerType>>;
+    }>;
+    /** MAPIE split conformal regressor with XGBoost base */
+    readonly mapie_split: StructType<{
+        readonly data: VariantType<{
+            readonly xgboost: BlobType;
+            readonly lightgbm: BlobType;
+            readonly histogram: BlobType;
+        }>;
+        readonly n_features: IntegerType;
+        readonly confidence_level: FloatType;
+    }>;
+    /** MAPIE cross conformal regressor with XGBoost base */
+    readonly mapie_cross: StructType<{
+        readonly data: VariantType<{
+            readonly xgboost: BlobType;
+            readonly lightgbm: BlobType;
+            readonly histogram: BlobType;
+        }>;
+        readonly n_features: IntegerType;
+        readonly confidence_level: FloatType;
+    }>;
+    /** MAPIE CQR conformal regressor with XGBoost base */
+    readonly mapie_cqr: StructType<{
+        readonly data: VariantType<{
+            readonly xgboost: BlobType;
+            readonly lightgbm: BlobType;
+            readonly histogram: BlobType;
+        }>;
+        readonly n_features: IntegerType;
+        readonly confidence_level: FloatType;
+    }>;
+    /** MAPIE conformal classifier with XGBoost base */
+    readonly mapie_classifier: StructType<{
+        readonly data: VariantType<{
+            readonly xgboost: BlobType;
+            readonly lightgbm: BlobType;
+            readonly histogram: BlobType;
+        }>;
+        readonly n_features: IntegerType;
+        readonly n_classes: IntegerType;
+        readonly classes: ArrayType<IntegerType>;
+        readonly confidence_level: FloatType;
     }>;
 }>;
 /**
  * Any model blob type - accepts any model for kernel explainer.
- * Includes all tree-based models plus NGBoost, GP, and Torch.
+ * Includes all tree-based models plus NGBoost, GP, Torch, and sklearn models.
  */
 export declare const AnyModelBlobType: VariantType<{
-    xgboost_regressor: StructType<{
-        data: BlobType;
-        n_features: IntegerType;
-    }>;
-    xgboost_classifier: StructType<{
-        data: BlobType;
-        n_features: IntegerType;
-        n_classes: IntegerType;
-    }>;
-    lightgbm_regressor: StructType<{
-        data: BlobType;
-        n_features: IntegerType;
-    }>;
-    lightgbm_classifier: StructType<{
-        data: BlobType;
-        n_features: IntegerType;
-        n_classes: IntegerType;
-    }>;
-    ngboost_regressor: StructType<{
-        data: BlobType;
-        distribution: VariantType<{
-            normal: StructType<{}>;
-            lognormal: StructType<{}>;
-        }>;
-        n_features: IntegerType;
-    }>;
-    gp_regressor: StructType<{
-        data: BlobType;
-        n_features: IntegerType;
-        kernel_type: StringType;
-    }>;
-    torch_mlp: StructType<{
-        data: BlobType;
-        n_features: IntegerType;
-        hidden_layers: ArrayType<IntegerType>;
-        output_dim: IntegerType;
+    readonly xgboost_regressor: StructType<{
+        readonly data: BlobType;
+        readonly n_features: IntegerType;
+        readonly categorical_features: OptionType<ArrayType<IntegerType>>;
+    }>;
+    readonly xgboost_classifier: StructType<{
+        readonly data: BlobType;
+        readonly n_features: IntegerType;
+        readonly n_classes: IntegerType;
+        readonly categorical_features: OptionType<ArrayType<IntegerType>>;
+    }>;
+    readonly xgboost_quantile: StructType<{
+        readonly data: BlobType;
+        readonly quantiles: ArrayType<FloatType>;
+        readonly n_features: IntegerType;
+        readonly categorical_features: OptionType<ArrayType<IntegerType>>;
+    }>;
+    readonly lightgbm_regressor: StructType<{
+        readonly data: BlobType;
+        readonly n_features: IntegerType;
+    }>;
+    readonly lightgbm_classifier: StructType<{
+        readonly data: BlobType;
+        readonly n_features: IntegerType;
+        readonly n_classes: IntegerType;
+    }>;
+    readonly ngboost_regressor: StructType<{
+        readonly data: BlobType;
+        readonly distribution: VariantType<{
+            readonly normal: NullType;
+            readonly lognormal: NullType;
+        }>;
+        readonly n_features: IntegerType;
+    }>;
+    readonly gp_regressor: StructType<{
+        readonly data: BlobType;
+        readonly n_features: IntegerType;
+        readonly kernel_type: StringType;
+    }>;
+    readonly torch_mlp: StructType<{
+        readonly data: BlobType;
+        readonly n_features: IntegerType;
+        readonly hidden_layers: ArrayType<IntegerType>;
+        readonly output_dim: IntegerType;
+    }>;
+    readonly standard_scaler: StructType<{
+        readonly onnx: BlobType;
+        readonly n_features: IntegerType;
+    }>;
+    readonly min_max_scaler: StructType<{
+        readonly onnx: BlobType;
+        readonly n_features: IntegerType;
+    }>;
+    readonly regressor_chain: StructType<{
+        readonly data: BlobType;
+        readonly n_features: IntegerType;
+        readonly n_targets: IntegerType;
+        readonly base_estimator_type: StringType;
+    }>;
+    readonly mapie_split: StructType<{
+        readonly data: VariantType<{
+            readonly xgboost: BlobType;
+            readonly lightgbm: BlobType;
+            readonly histogram: BlobType;
+        }>;
+        readonly n_features: IntegerType;
+        readonly confidence_level: FloatType;
+    }>;
+    readonly mapie_cross: StructType<{
+        readonly data: VariantType<{
+            readonly xgboost: BlobType;
+            readonly lightgbm: BlobType;
+            readonly histogram: BlobType;
+        }>;
+        readonly n_features: IntegerType;
+        readonly confidence_level: FloatType;
+    }>;
+    readonly mapie_cqr: StructType<{
+        readonly data: VariantType<{
+            readonly xgboost: BlobType;
+            readonly lightgbm: BlobType;
+            readonly histogram: BlobType;
+        }>;
+        readonly n_features: IntegerType;
+        readonly confidence_level: FloatType;
+    }>;
+    readonly mapie_classifier: StructType<{
+        readonly data: VariantType<{
+            readonly xgboost: BlobType;
+            readonly lightgbm: BlobType;
+            readonly histogram: BlobType;
+        }>;
+        readonly n_features: IntegerType;
+        readonly n_classes: IntegerType;
+        readonly classes: ArrayType<IntegerType>;
+        readonly confidence_level: FloatType;
+    }>;
+    readonly mapie_interval_width: StructType<{
+        readonly data: BlobType;
+        readonly n_features: IntegerType;
+    }>;
+    readonly mapie_set_size: StructType<{
+        readonly data: BlobType;
+        readonly n_features: IntegerType;
+    }>;
+}>;
+/**
+ * Tagged model data - variant tag indicates base model type, value is the blob.
+ * Re-exported from mapie.ts for convenience.
+ */
+export declare const MAPIEBaseModelDataType: VariantType<{
+    readonly xgboost: BlobType;
+    readonly lightgbm: BlobType;
+    readonly histogram: BlobType;
+}>;
+/**
+ * MAPIE regressor model blob type for SHAP.
+ * Accepts split, cross, or CQR conformal regressors.
+ * Must match MAPIERegressorBlobType from mapie.ts.
+ */
+export declare const MAPIERegressorBlobType: VariantType<{
+    readonly mapie_split: StructType<{
+        readonly data: VariantType<{
+            readonly xgboost: BlobType;
+            readonly lightgbm: BlobType;
+            readonly histogram: BlobType;
+        }>;
+        readonly n_features: IntegerType;
+        readonly confidence_level: FloatType;
+    }>;
+    readonly mapie_cross: StructType<{
+        readonly data: VariantType<{
+            readonly xgboost: BlobType;
+            readonly lightgbm: BlobType;
+            readonly histogram: BlobType;
+        }>;
+        readonly n_features: IntegerType;
+        readonly confidence_level: FloatType;
+    }>;
+    readonly mapie_cqr: StructType<{
+        readonly data: VariantType<{
+            readonly xgboost: BlobType;
+            readonly lightgbm: BlobType;
+            readonly histogram: BlobType;
+        }>;
+        readonly n_features: IntegerType;
+        readonly confidence_level: FloatType;
+    }>;
+}>;
+/**
+ * MAPIE classifier model blob type for SHAP.
+ * Must match MAPIEClassifierBlobType from mapie.ts.
+ */
+export declare const MAPIEClassifierBlobType: StructType<{
+    readonly data: VariantType<{
+        readonly xgboost: BlobType;
+        readonly lightgbm: BlobType;
+        readonly histogram: BlobType;
+    }>;
+    readonly n_features: IntegerType;
+    readonly n_classes: IntegerType;
+    readonly classes: ArrayType<IntegerType>;
+    readonly confidence_level: FloatType;
+}>;
+/**
+ * SHAP result for MAPIE regressors.
+ * Contains explanations for both point prediction and uncertainty (interval width).
+ */
+export declare const MapieRegressorShapResultType: StructType<{
+    /** SHAP values for point prediction (what drives the predicted value) */
+    readonly point_prediction: StructType<{
+        /** SHAP values - 2D matrix or 3D tensor depending on model type */
+        readonly shap_values: VariantType<{
+            /** 2D matrix for regression or binary classification (n_samples x n_features) */
+            readonly matrix_2d: ArrayType<ArrayType<FloatType>>;
+            /** 3D tensor for multi-class classification (n_samples x n_features x n_classes) */
+            readonly tensor_3d: ArrayType<ArrayType<ArrayType<FloatType>>>;
+        }>;
+        /** Base value(s) - single float or per-class array */
+        readonly base_value: VariantType<{
+            /** Single base value for regression or binary classification */
+            readonly single: FloatType;
+            /** Per-class base values for multi-class classification */
+            readonly per_class: ArrayType<FloatType>;
+        }>;
+        /** Feature names */
+        readonly feature_names: ArrayType<StringType>;
+    }>;
+    /** SHAP values for interval width (what drives uncertainty) */
+    readonly interval_width: StructType<{
+        /** SHAP values - 2D matrix or 3D tensor depending on model type */
+        readonly shap_values: VariantType<{
+            /** 2D matrix for regression or binary classification (n_samples x n_features) */
+            readonly matrix_2d: ArrayType<ArrayType<FloatType>>;
+            /** 3D tensor for multi-class classification (n_samples x n_features x n_classes) */
+            readonly tensor_3d: ArrayType<ArrayType<ArrayType<FloatType>>>;
+        }>;
+        /** Base value(s) - single float or per-class array */
+        readonly base_value: VariantType<{
+            /** Single base value for regression or binary classification */
+            readonly single: FloatType;
+            /** Per-class base values for multi-class classification */
+            readonly per_class: ArrayType<FloatType>;
+        }>;
+        /** Feature names */
+        readonly feature_names: ArrayType<StringType>;
+    }>;
+}>;
+/**
+ * SHAP result for MAPIE classifiers.
+ * Contains explanations for both class probabilities and prediction set size.
+ */
+export declare const MapieClassifierShapResultType: StructType<{
+    /** SHAP values for class probabilities (what drives each class probability) */
+    readonly class_probabilities: StructType<{
+        /** SHAP values - 2D matrix or 3D tensor depending on model type */
+        readonly shap_values: VariantType<{
+            /** 2D matrix for regression or binary classification (n_samples x n_features) */
+            readonly matrix_2d: ArrayType<ArrayType<FloatType>>;
+            /** 3D tensor for multi-class classification (n_samples x n_features x n_classes) */
+            readonly tensor_3d: ArrayType<ArrayType<ArrayType<FloatType>>>;
+        }>;
+        /** Base value(s) - single float or per-class array */
+        readonly base_value: VariantType<{
+            /** Single base value for regression or binary classification */
+            readonly single: FloatType;
+            /** Per-class base values for multi-class classification */
+            readonly per_class: ArrayType<FloatType>;
+        }>;
+        /** Feature names */
+        readonly feature_names: ArrayType<StringType>;
+    }>;
+    /** SHAP values for prediction set size (what drives uncertainty) */
+    readonly prediction_set_size: StructType<{
+        /** SHAP values - 2D matrix or 3D tensor depending on model type */
+        readonly shap_values: VariantType<{
+            /** 2D matrix for regression or binary classification (n_samples x n_features) */
+            readonly matrix_2d: ArrayType<ArrayType<FloatType>>;
+            /** 3D tensor for multi-class classification (n_samples x n_features x n_classes) */
+            readonly tensor_3d: ArrayType<ArrayType<ArrayType<FloatType>>>;
+        }>;
+        /** Base value(s) - single float or per-class array */
+        readonly base_value: VariantType<{
+            /** Single base value for regression or binary classification */
+            readonly single: FloatType;
+            /** Per-class base values for multi-class classification */
+            readonly per_class: ArrayType<FloatType>;
+        }>;
+        /** Feature names */
+        readonly feature_names: ArrayType<StringType>;
     }>;
 }>;
 /**
@@ -135,41 +419,81 @@ export declare const AnyModelBlobType: VariantType<{
  */
 export declare const shap_tree_explainer_create: import("@elaraai/east").PlatformDefinition<[VariantType<{
     /** XGBoost regressor */
-    xgboost_regressor: StructType<{
-        data: BlobType;
-        n_features: IntegerType;
+    readonly xgboost_regressor: StructType<{
+        readonly data: BlobType;
+        readonly n_features: IntegerType;
+        readonly categorical_features: OptionType<ArrayType<IntegerType>>;
     }>;
     /** XGBoost classifier */
-    xgboost_classifier: StructType<{
-        data: BlobType;
-        n_features: IntegerType;
-        n_classes: IntegerType;
-    }>;
-    /** LightGBM regressor */
-    lightgbm_regressor: StructType<{
-        data: BlobType;
-        n_features: IntegerType;
-    }>;
-    /** LightGBM classifier */
-    lightgbm_classifier: StructType<{
-        data: BlobType;
-        n_features: IntegerType;
-        n_classes: IntegerType;
+    readonly xgboost_classifier: StructType<{
+        readonly data: BlobType;
+        readonly n_features: IntegerType;
+        readonly n_classes: IntegerType;
+        readonly categorical_features: OptionType<ArrayType<IntegerType>>;
+    }>;
+    /** XGBoost quantile regressor (uses median quantile for explanations) */
+    readonly xgboost_quantile: StructType<{
+        readonly data: BlobType;
+        readonly quantiles: ArrayType<FloatType>;
+        readonly n_features: IntegerType;
+        readonly categorical_features: OptionType<ArrayType<IntegerType>>;
+    }>;
+    /** MAPIE split conformal regressor with XGBoost base */
+    readonly mapie_split: StructType<{
+        readonly data: VariantType<{
+            readonly xgboost: BlobType;
+            readonly lightgbm: BlobType;
+            readonly histogram: BlobType;
+        }>;
+        readonly n_features: IntegerType;
+        readonly confidence_level: FloatType;
+    }>;
+    /** MAPIE cross conformal regressor with XGBoost base */
+    readonly mapie_cross: StructType<{
+        readonly data: VariantType<{
+            readonly xgboost: BlobType;
+            readonly lightgbm: BlobType;
+            readonly histogram: BlobType;
+        }>;
+        readonly n_features: IntegerType;
+        readonly confidence_level: FloatType;
+    }>;
+    /** MAPIE CQR conformal regressor with XGBoost base */
+    readonly mapie_cqr: StructType<{
+        readonly data: VariantType<{
+            readonly xgboost: BlobType;
+            readonly lightgbm: BlobType;
+            readonly histogram: BlobType;
+        }>;
+        readonly n_features: IntegerType;
+        readonly confidence_level: FloatType;
+    }>;
+    /** MAPIE conformal classifier with XGBoost base */
+    readonly mapie_classifier: StructType<{
+        readonly data: VariantType<{
+            readonly xgboost: BlobType;
+            readonly lightgbm: BlobType;
+            readonly histogram: BlobType;
+        }>;
+        readonly n_features: IntegerType;
+        readonly n_classes: IntegerType;
+        readonly classes: ArrayType<IntegerType>;
+        readonly confidence_level: FloatType;
     }>;
 }>], VariantType<{
     /** SHAP TreeExplainer for tree-based models */
-    shap_tree_explainer: StructType<{
+    readonly shap_tree_explainer: StructType<{
         /** Cloudpickle serialized explainer */
-        data: BlobType;
+        readonly data: BlobType;
         /** Number of input features */
-        n_features: IntegerType;
+        readonly n_features: IntegerType;
     }>;
     /** SHAP KernelExplainer for any model */
-    shap_kernel_explainer: StructType<{
+    readonly shap_kernel_explainer: StructType<{
         /** Cloudpickle serialized explainer */
-        data: BlobType;
+        readonly data: BlobType;
         /** Number of input features */
-        n_features: IntegerType;
+        readonly n_features: IntegerType;
     }>;
 }>>;
 /**
@@ -183,57 +507,125 @@ export declare const shap_tree_explainer_create: import("@elaraai/east").Platfor
  * @returns SHAP KernelExplainer blob
  */
 export declare const shap_kernel_explainer_create: import("@elaraai/east").PlatformDefinition<[VariantType<{
-    xgboost_regressor: StructType<{
-        data: BlobType;
-        n_features: IntegerType;
-    }>;
-    xgboost_classifier: StructType<{
-        data: BlobType;
-        n_features: IntegerType;
-        n_classes: IntegerType;
-    }>;
-    lightgbm_regressor: StructType<{
-        data: BlobType;
-        n_features: IntegerType;
-    }>;
-    lightgbm_classifier: StructType<{
-        data: BlobType;
-        n_features: IntegerType;
-        n_classes: IntegerType;
-    }>;
-    ngboost_regressor: StructType<{
-        data: BlobType;
-        distribution: VariantType<{
-            normal: StructType<{}>;
-            lognormal: StructType<{}>;
-        }>;
-        n_features: IntegerType;
-    }>;
-    gp_regressor: StructType<{
-        data: BlobType;
-        n_features: IntegerType;
-        kernel_type: StringType;
-    }>;
-    torch_mlp: StructType<{
-        data: BlobType;
-        n_features: IntegerType;
-        hidden_layers: ArrayType<IntegerType>;
-        output_dim: IntegerType;
+    readonly xgboost_regressor: StructType<{
+        readonly data: BlobType;
+        readonly n_features: IntegerType;
+        readonly categorical_features: OptionType<ArrayType<IntegerType>>;
+    }>;
+    readonly xgboost_classifier: StructType<{
+        readonly data: BlobType;
+        readonly n_features: IntegerType;
+        readonly n_classes: IntegerType;
+        readonly categorical_features: OptionType<ArrayType<IntegerType>>;
+    }>;
+    readonly xgboost_quantile: StructType<{
+        readonly data: BlobType;
+        readonly quantiles: ArrayType<FloatType>;
+        readonly n_features: IntegerType;
+        readonly categorical_features: OptionType<ArrayType<IntegerType>>;
+    }>;
+    readonly lightgbm_regressor: StructType<{
+        readonly data: BlobType;
+        readonly n_features: IntegerType;
+    }>;
+    readonly lightgbm_classifier: StructType<{
+        readonly data: BlobType;
+        readonly n_features: IntegerType;
+        readonly n_classes: IntegerType;
+    }>;
+    readonly ngboost_regressor: StructType<{
+        readonly data: BlobType;
+        readonly distribution: VariantType<{
+            readonly normal: NullType;
+            readonly lognormal: NullType;
+        }>;
+        readonly n_features: IntegerType;
+    }>;
+    readonly gp_regressor: StructType<{
+        readonly data: BlobType;
+        readonly n_features: IntegerType;
+        readonly kernel_type: StringType;
+    }>;
+    readonly torch_mlp: StructType<{
+        readonly data: BlobType;
+        readonly n_features: IntegerType;
+        readonly hidden_layers: ArrayType<IntegerType>;
+        readonly output_dim: IntegerType;
+    }>;
+    readonly standard_scaler: StructType<{
+        readonly onnx: BlobType;
+        readonly n_features: IntegerType;
+    }>;
+    readonly min_max_scaler: StructType<{
+        readonly onnx: BlobType;
+        readonly n_features: IntegerType;
+    }>;
+    readonly regressor_chain: StructType<{
+        readonly data: BlobType;
+        readonly n_features: IntegerType;
+        readonly n_targets: IntegerType;
+        readonly base_estimator_type: StringType;
+    }>;
+    readonly mapie_split: StructType<{
+        readonly data: VariantType<{
+            readonly xgboost: BlobType;
+            readonly lightgbm: BlobType;
+            readonly histogram: BlobType;
+        }>;
+        readonly n_features: IntegerType;
+        readonly confidence_level: FloatType;
+    }>;
+    readonly mapie_cross: StructType<{
+        readonly data: VariantType<{
+            readonly xgboost: BlobType;
+            readonly lightgbm: BlobType;
+            readonly histogram: BlobType;
+        }>;
+        readonly n_features: IntegerType;
+        readonly confidence_level: FloatType;
+    }>;
+    readonly mapie_cqr: StructType<{
+        readonly data: VariantType<{
+            readonly xgboost: BlobType;
+            readonly lightgbm: BlobType;
+            readonly histogram: BlobType;
+        }>;
+        readonly n_features: IntegerType;
+        readonly confidence_level: FloatType;
+    }>;
+    readonly mapie_classifier: StructType<{
+        readonly data: VariantType<{
+            readonly xgboost: BlobType;
+            readonly lightgbm: BlobType;
+            readonly histogram: BlobType;
+        }>;
+        readonly n_features: IntegerType;
+        readonly n_classes: IntegerType;
+        readonly classes: ArrayType<IntegerType>;
+        readonly confidence_level: FloatType;
+    }>;
+    readonly mapie_interval_width: StructType<{
+        readonly data: BlobType;
+        readonly n_features: IntegerType;
+    }>;
+    readonly mapie_set_size: StructType<{
+        readonly data: BlobType;
+        readonly n_features: IntegerType;
     }>;
 }>, ArrayType<ArrayType<FloatType>>], VariantType<{
     /** SHAP TreeExplainer for tree-based models */
-    shap_tree_explainer: StructType<{
+    readonly shap_tree_explainer: StructType<{
         /** Cloudpickle serialized explainer */
-        data: BlobType;
+        readonly data: BlobType;
         /** Number of input features */
-        n_features: IntegerType;
+        readonly n_features: IntegerType;
     }>;
     /** SHAP KernelExplainer for any model */
-    shap_kernel_explainer: StructType<{
+    readonly shap_kernel_explainer: StructType<{
         /** Cloudpickle serialized explainer */
-        data: BlobType;
+        readonly data: BlobType;
         /** Number of input features */
-        n_features: IntegerType;
+        readonly n_features: IntegerType;
     }>;
 }>>;
 /**
@@ -246,41 +638,56 @@ export declare const shap_kernel_explainer_create: import("@elaraai/east").Platf
  */
 export declare const shap_compute_values: import("@elaraai/east").PlatformDefinition<[VariantType<{
     /** SHAP TreeExplainer for tree-based models */
-    shap_tree_explainer: StructType<{
+    readonly shap_tree_explainer: StructType<{
         /** Cloudpickle serialized explainer */
-        data: BlobType;
+        readonly data: BlobType;
         /** Number of input features */
-        n_features: IntegerType;
+        readonly n_features: IntegerType;
     }>;
     /** SHAP KernelExplainer for any model */
-    shap_kernel_explainer: StructType<{
+    readonly shap_kernel_explainer: StructType<{
         /** Cloudpickle serialized explainer */
-        data: BlobType;
+        readonly data: BlobType;
         /** Number of input features */
-        n_features: IntegerType;
+        readonly n_features: IntegerType;
     }>;
 }>, ArrayType<ArrayType<FloatType>>, ArrayType<StringType>], StructType<{
-    /** SHAP values matrix (n_samples x n_features) */
-    shap_values: ArrayType<ArrayType<FloatType>>;
-    /** Base value (expected model output) */
-    base_value: FloatType;
+    /** SHAP values - 2D matrix or 3D tensor depending on model type */
+    readonly shap_values: VariantType<{
+        /** 2D matrix for regression or binary classification (n_samples x n_features) */
+        readonly matrix_2d: ArrayType<ArrayType<FloatType>>;
+        /** 3D tensor for multi-class classification (n_samples x n_features x n_classes) */
+        readonly tensor_3d: ArrayType<ArrayType<ArrayType<FloatType>>>;
+    }>;
+    /** Base value(s) - single float or per-class array */
+    readonly base_value: VariantType<{
+        /** Single base value for regression or binary classification */
+        readonly single: FloatType;
+        /** Per-class base values for multi-class classification */
+        readonly per_class: ArrayType<FloatType>;
+    }>;
     /** Feature names */
-    feature_names: ArrayType<StringType>;
+    readonly feature_names: ArrayType<StringType>;
 }>>;
 /**
  * Compute global feature importance from SHAP values.
  *
- * @param shap_values - SHAP values matrix
+ * @param shap_values - SHAP values (2D matrix or 3D tensor)
  * @param feature_names - Names of features
  * @returns Feature importance with mean |SHAP| values
  */
-export declare const shap_feature_importance: import("@elaraai/east").PlatformDefinition<[ArrayType<ArrayType<FloatType>>, ArrayType<StringType>], StructType<{
+export declare const shap_feature_importance: import("@elaraai/east").PlatformDefinition<[VariantType<{
+    /** 2D matrix for regression or binary classification (n_samples x n_features) */
+    readonly matrix_2d: ArrayType<ArrayType<FloatType>>;
+    /** 3D tensor for multi-class classification (n_samples x n_features x n_classes) */
+    readonly tensor_3d: ArrayType<ArrayType<ArrayType<FloatType>>>;
+}>, ArrayType<StringType>], StructType<{
     /** Feature names */
-    feature_names: ArrayType<StringType>;
+    readonly feature_names: ArrayType<StringType>;
     /** Mean absolute SHAP value for each feature */
-    importances: ArrayType<FloatType>;
+    readonly importances: ArrayType<FloatType>;
     /** Standard deviation of absolute SHAP values */
-    std: OptionType<ArrayType<FloatType>>;
+    readonly std: OptionType<ArrayType<FloatType>>;
 }>>;
 /**
  * Type definitions for SHAP functions.
@@ -292,104 +699,236 @@ export declare const ShapTypes: {
     readonly MatrixType: ArrayType<ArrayType<FloatType>>;
     /** String vector type */
     readonly StringVectorType: ArrayType<StringType>;
+    /** SHAP values variant type (2D or 3D) */
+    readonly ShapValuesType: VariantType<{
+        /** 2D matrix for regression or binary classification (n_samples x n_features) */
+        readonly matrix_2d: ArrayType<ArrayType<FloatType>>;
+        /** 3D tensor for multi-class classification (n_samples x n_features x n_classes) */
+        readonly tensor_3d: ArrayType<ArrayType<ArrayType<FloatType>>>;
+    }>;
+    /** SHAP base value variant type (single or per-class) */
+    readonly ShapBaseValueType: VariantType<{
+        /** Single base value for regression or binary classification */
+        readonly single: FloatType;
+        /** Per-class base values for multi-class classification */
+        readonly per_class: ArrayType<FloatType>;
+    }>;
     /** SHAP result type */
     readonly ShapResultType: StructType<{
-        /** SHAP values matrix (n_samples x n_features) */
-        shap_values: ArrayType<ArrayType<FloatType>>;
-        /** Base value (expected model output) */
-        base_value: FloatType;
+        /** SHAP values - 2D matrix or 3D tensor depending on model type */
+        readonly shap_values: VariantType<{
+            /** 2D matrix for regression or binary classification (n_samples x n_features) */
+            readonly matrix_2d: ArrayType<ArrayType<FloatType>>;
+            /** 3D tensor for multi-class classification (n_samples x n_features x n_classes) */
+            readonly tensor_3d: ArrayType<ArrayType<ArrayType<FloatType>>>;
+        }>;
+        /** Base value(s) - single float or per-class array */
+        readonly base_value: VariantType<{
+            /** Single base value for regression or binary classification */
+            readonly single: FloatType;
+            /** Per-class base values for multi-class classification */
+            readonly per_class: ArrayType<FloatType>;
+        }>;
         /** Feature names */
-        feature_names: ArrayType<StringType>;
+        readonly feature_names: ArrayType<StringType>;
     }>;
     /** Feature importance type */
     readonly FeatureImportanceType: StructType<{
         /** Feature names */
-        feature_names: ArrayType<StringType>;
+        readonly feature_names: ArrayType<StringType>;
         /** Mean absolute SHAP value for each feature */
-        importances: ArrayType<FloatType>;
+        readonly importances: ArrayType<FloatType>;
         /** Standard deviation of absolute SHAP values */
-        std: OptionType<ArrayType<FloatType>>;
+        readonly std: OptionType<ArrayType<FloatType>>;
     }>;
     /** SHAP explainer model blob type */
     readonly ShapModelBlobType: VariantType<{
         /** SHAP TreeExplainer for tree-based models */
-        shap_tree_explainer: StructType<{
+        readonly shap_tree_explainer: StructType<{
             /** Cloudpickle serialized explainer */
-            data: BlobType;
+            readonly data: BlobType;
             /** Number of input features */
-            n_features: IntegerType;
+            readonly n_features: IntegerType;
         }>;
         /** SHAP KernelExplainer for any model */
-        shap_kernel_explainer: StructType<{
+        readonly shap_kernel_explainer: StructType<{
             /** Cloudpickle serialized explainer */
-            data: BlobType;
+            readonly data: BlobType;
             /** Number of input features */
-            n_features: IntegerType;
+            readonly n_features: IntegerType;
         }>;
     }>;
     /** Tree model blob type for input */
     readonly TreeModelBlobType: VariantType<{
         /** XGBoost regressor */
-        xgboost_regressor: StructType<{
-            data: BlobType;
-            n_features: IntegerType;
+        readonly xgboost_regressor: StructType<{
+            readonly data: BlobType;
+            readonly n_features: IntegerType;
+            readonly categorical_features: OptionType<ArrayType<IntegerType>>;
         }>;
         /** XGBoost classifier */
-        xgboost_classifier: StructType<{
-            data: BlobType;
-            n_features: IntegerType;
-            n_classes: IntegerType;
+        readonly xgboost_classifier: StructType<{
+            readonly data: BlobType;
+            readonly n_features: IntegerType;
+            readonly n_classes: IntegerType;
+            readonly categorical_features: OptionType<ArrayType<IntegerType>>;
+        }>;
+        /** XGBoost quantile regressor (uses median quantile for explanations) */
+        readonly xgboost_quantile: StructType<{
+            readonly data: BlobType;
+            readonly quantiles: ArrayType<FloatType>;
+            readonly n_features: IntegerType;
+            readonly categorical_features: OptionType<ArrayType<IntegerType>>;
+        }>;
+        /** MAPIE split conformal regressor with XGBoost base */
+        readonly mapie_split: StructType<{
+            readonly data: VariantType<{
+                readonly xgboost: BlobType;
+                readonly lightgbm: BlobType;
+                readonly histogram: BlobType;
+            }>;
+            readonly n_features: IntegerType;
+            readonly confidence_level: FloatType;
+        }>;
+        /** MAPIE cross conformal regressor with XGBoost base */
+        readonly mapie_cross: StructType<{
+            readonly data: VariantType<{
+                readonly xgboost: BlobType;
+                readonly lightgbm: BlobType;
+                readonly histogram: BlobType;
+            }>;
+            readonly n_features: IntegerType;
+            readonly confidence_level: FloatType;
         }>;
-        /** LightGBM regressor */
-        lightgbm_regressor: StructType<{
-            data: BlobType;
-            n_features: IntegerType;
+        /** MAPIE CQR conformal regressor with XGBoost base */
+        readonly mapie_cqr: StructType<{
+            readonly data: VariantType<{
+                readonly xgboost: BlobType;
+                readonly lightgbm: BlobType;
+                readonly histogram: BlobType;
+            }>;
+            readonly n_features: IntegerType;
+            readonly confidence_level: FloatType;
         }>;
-        /** LightGBM classifier */
-        lightgbm_classifier: StructType<{
-            data: BlobType;
-            n_features: IntegerType;
-            n_classes: IntegerType;
+        /** MAPIE conformal classifier with XGBoost base */
+        readonly mapie_classifier: StructType<{
+            readonly data: VariantType<{
+                readonly xgboost: BlobType;
+                readonly lightgbm: BlobType;
+                readonly histogram: BlobType;
+            }>;
+            readonly n_features: IntegerType;
+            readonly n_classes: IntegerType;
+            readonly classes: ArrayType<IntegerType>;
+            readonly confidence_level: FloatType;
         }>;
     }>;
     /** Any model blob type for kernel explainer */
     readonly AnyModelBlobType: VariantType<{
-        xgboost_regressor: StructType<{
-            data: BlobType;
-            n_features: IntegerType;
+        readonly xgboost_regressor: StructType<{
+            readonly data: BlobType;
+            readonly n_features: IntegerType;
+            readonly categorical_features: OptionType<ArrayType<IntegerType>>;
+        }>;
+        readonly xgboost_classifier: StructType<{
+            readonly data: BlobType;
+            readonly n_features: IntegerType;
+            readonly n_classes: IntegerType;
+            readonly categorical_features: OptionType<ArrayType<IntegerType>>;
         }>;
-        xgboost_classifier: StructType<{
-            data: BlobType;
-            n_features: IntegerType;
-            n_classes: IntegerType;
+        readonly xgboost_quantile: StructType<{
+            readonly data: BlobType;
+            readonly quantiles: ArrayType<FloatType>;
+            readonly n_features: IntegerType;
+            readonly categorical_features: OptionType<ArrayType<IntegerType>>;
         }>;
-        lightgbm_regressor: StructType<{
-            data: BlobType;
-            n_features: IntegerType;
+        readonly lightgbm_regressor: StructType<{
+            readonly data: BlobType;
+            readonly n_features: IntegerType;
         }>;
-        lightgbm_classifier: StructType<{
-            data: BlobType;
-            n_features: IntegerType;
-            n_classes: IntegerType;
+        readonly lightgbm_classifier: StructType<{
+            readonly data: BlobType;
+            readonly n_features: IntegerType;
+            readonly n_classes: IntegerType;
         }>;
-        ngboost_regressor: StructType<{
-            data: BlobType;
-            distribution: VariantType<{
-                normal: StructType<{}>;
-                lognormal: StructType<{}>;
+        readonly ngboost_regressor: StructType<{
+            readonly data: BlobType;
+            readonly distribution: VariantType<{
+                readonly normal: NullType;
+                readonly lognormal: NullType;
             }>;
-            n_features: IntegerType;
+            readonly n_features: IntegerType;
+        }>;
+        readonly gp_regressor: StructType<{
+            readonly data: BlobType;
+            readonly n_features: IntegerType;
+            readonly kernel_type: StringType;
+        }>;
+        readonly torch_mlp: StructType<{
+            readonly data: BlobType;
+            readonly n_features: IntegerType;
+            readonly hidden_layers: ArrayType<IntegerType>;
+            readonly output_dim: IntegerType;
+        }>;
+        readonly standard_scaler: StructType<{
+            readonly onnx: BlobType;
+            readonly n_features: IntegerType;
         }>;
-        gp_regressor: StructType<{
-            data: BlobType;
-            n_features: IntegerType;
-            kernel_type: StringType;
+        readonly min_max_scaler: StructType<{
+            readonly onnx: BlobType;
+            readonly n_features: IntegerType;
         }>;
-        torch_mlp: StructType<{
-            data: BlobType;
-            n_features: IntegerType;
-            hidden_layers: ArrayType<IntegerType>;
-            output_dim: IntegerType;
+        readonly regressor_chain: StructType<{
+            readonly data: BlobType;
+            readonly n_features: IntegerType;
+            readonly n_targets: IntegerType;
+            readonly base_estimator_type: StringType;
+        }>;
+        readonly mapie_split: StructType<{
+            readonly data: VariantType<{
+                readonly xgboost: BlobType;
+                readonly lightgbm: BlobType;
+                readonly histogram: BlobType;
+            }>;
+            readonly n_features: IntegerType;
+            readonly confidence_level: FloatType;
+        }>;
+        readonly mapie_cross: StructType<{
+            readonly data: VariantType<{
+                readonly xgboost: BlobType;
+                readonly lightgbm: BlobType;
+                readonly histogram: BlobType;
+            }>;
+            readonly n_features: IntegerType;
+            readonly confidence_level: FloatType;
+        }>;
+        readonly mapie_cqr: StructType<{
+            readonly data: VariantType<{
+                readonly xgboost: BlobType;
+                readonly lightgbm: BlobType;
+                readonly histogram: BlobType;
+            }>;
+            readonly n_features: IntegerType;
+            readonly confidence_level: FloatType;
+        }>;
+        readonly mapie_classifier: StructType<{
+            readonly data: VariantType<{
+                readonly xgboost: BlobType;
+                readonly lightgbm: BlobType;
+                readonly histogram: BlobType;
+            }>;
+            readonly n_features: IntegerType;
+            readonly n_classes: IntegerType;
+            readonly classes: ArrayType<IntegerType>;
+            readonly confidence_level: FloatType;
+        }>;
+        readonly mapie_interval_width: StructType<{
+            readonly data: BlobType;
+            readonly n_features: IntegerType;
+        }>;
+        readonly mapie_set_size: StructType<{
+            readonly data: BlobType;
+            readonly n_features: IntegerType;
         }>;
     }>;
 };
@@ -419,130 +958,253 @@ export declare const Shap: {
     /** Create TreeExplainer for tree-based models */
     readonly treeExplainerCreate: import("@elaraai/east").PlatformDefinition<[VariantType<{
         /** XGBoost regressor */
-        xgboost_regressor: StructType<{
-            data: BlobType;
-            n_features: IntegerType;
+        readonly xgboost_regressor: StructType<{
+            readonly data: BlobType;
+            readonly n_features: IntegerType;
+            readonly categorical_features: OptionType<ArrayType<IntegerType>>;
         }>;
         /** XGBoost classifier */
-        xgboost_classifier: StructType<{
-            data: BlobType;
-            n_features: IntegerType;
-            n_classes: IntegerType;
-        }>;
-        /** LightGBM regressor */
-        lightgbm_regressor: StructType<{
-            data: BlobType;
-            n_features: IntegerType;
-        }>;
-        /** LightGBM classifier */
-        lightgbm_classifier: StructType<{
-            data: BlobType;
-            n_features: IntegerType;
-            n_classes: IntegerType;
+        readonly xgboost_classifier: StructType<{
+            readonly data: BlobType;
+            readonly n_features: IntegerType;
+            readonly n_classes: IntegerType;
+            readonly categorical_features: OptionType<ArrayType<IntegerType>>;
+        }>;
+        /** XGBoost quantile regressor (uses median quantile for explanations) */
+        readonly xgboost_quantile: StructType<{
+            readonly data: BlobType;
+            readonly quantiles: ArrayType<FloatType>;
+            readonly n_features: IntegerType;
+            readonly categorical_features: OptionType<ArrayType<IntegerType>>;
+        }>;
+        /** MAPIE split conformal regressor with XGBoost base */
+        readonly mapie_split: StructType<{
+            readonly data: VariantType<{
+                readonly xgboost: BlobType;
+                readonly lightgbm: BlobType;
+                readonly histogram: BlobType;
+            }>;
+            readonly n_features: IntegerType;
+            readonly confidence_level: FloatType;
+        }>;
+        /** MAPIE cross conformal regressor with XGBoost base */
+        readonly mapie_cross: StructType<{
+            readonly data: VariantType<{
+                readonly xgboost: BlobType;
+                readonly lightgbm: BlobType;
+                readonly histogram: BlobType;
+            }>;
+            readonly n_features: IntegerType;
+            readonly confidence_level: FloatType;
+        }>;
+        /** MAPIE CQR conformal regressor with XGBoost base */
+        readonly mapie_cqr: StructType<{
+            readonly data: VariantType<{
+                readonly xgboost: BlobType;
+                readonly lightgbm: BlobType;
+                readonly histogram: BlobType;
+            }>;
+            readonly n_features: IntegerType;
+            readonly confidence_level: FloatType;
+        }>;
+        /** MAPIE conformal classifier with XGBoost base */
+        readonly mapie_classifier: StructType<{
+            readonly data: VariantType<{
+                readonly xgboost: BlobType;
+                readonly lightgbm: BlobType;
+                readonly histogram: BlobType;
+            }>;
+            readonly n_features: IntegerType;
+            readonly n_classes: IntegerType;
+            readonly classes: ArrayType<IntegerType>;
+            readonly confidence_level: FloatType;
         }>;
     }>], VariantType<{
         /** SHAP TreeExplainer for tree-based models */
-        shap_tree_explainer: StructType<{
+        readonly shap_tree_explainer: StructType<{
             /** Cloudpickle serialized explainer */
-            data: BlobType;
+            readonly data: BlobType;
             /** Number of input features */
-            n_features: IntegerType;
+            readonly n_features: IntegerType;
         }>;
         /** SHAP KernelExplainer for any model */
-        shap_kernel_explainer: StructType<{
+        readonly shap_kernel_explainer: StructType<{
             /** Cloudpickle serialized explainer */
-            data: BlobType;
+            readonly data: BlobType;
             /** Number of input features */
-            n_features: IntegerType;
+            readonly n_features: IntegerType;
         }>;
     }>>;
     /** Create KernelExplainer for any model */
     readonly kernelExplainerCreate: import("@elaraai/east").PlatformDefinition<[VariantType<{
-        xgboost_regressor: StructType<{
-            data: BlobType;
-            n_features: IntegerType;
-        }>;
-        xgboost_classifier: StructType<{
-            data: BlobType;
-            n_features: IntegerType;
-            n_classes: IntegerType;
-        }>;
-        lightgbm_regressor: StructType<{
-            data: BlobType;
-            n_features: IntegerType;
-        }>;
-        lightgbm_classifier: StructType<{
-            data: BlobType;
-            n_features: IntegerType;
-            n_classes: IntegerType;
-        }>;
-        ngboost_regressor: StructType<{
-            data: BlobType;
-            distribution: VariantType<{
-                normal: StructType<{}>;
-                lognormal: StructType<{}>;
-            }>;
-            n_features: IntegerType;
-        }>;
-        gp_regressor: StructType<{
-            data: BlobType;
-            n_features: IntegerType;
-            kernel_type: StringType;
-        }>;
-        torch_mlp: StructType<{
-            data: BlobType;
-            n_features: IntegerType;
-            hidden_layers: ArrayType<IntegerType>;
-            output_dim: IntegerType;
+        readonly xgboost_regressor: StructType<{
+            readonly data: BlobType;
+            readonly n_features: IntegerType;
+            readonly categorical_features: OptionType<ArrayType<IntegerType>>;
+        }>;
+        readonly xgboost_classifier: StructType<{
+            readonly data: BlobType;
+            readonly n_features: IntegerType;
+            readonly n_classes: IntegerType;
+            readonly categorical_features: OptionType<ArrayType<IntegerType>>;
+        }>;
+        readonly xgboost_quantile: StructType<{
+            readonly data: BlobType;
+            readonly quantiles: ArrayType<FloatType>;
+            readonly n_features: IntegerType;
+            readonly categorical_features: OptionType<ArrayType<IntegerType>>;
+        }>;
+        readonly lightgbm_regressor: StructType<{
+            readonly data: BlobType;
+            readonly n_features: IntegerType;
+        }>;
+        readonly lightgbm_classifier: StructType<{
+            readonly data: BlobType;
+            readonly n_features: IntegerType;
+            readonly n_classes: IntegerType;
+        }>;
+        readonly ngboost_regressor: StructType<{
+            readonly data: BlobType;
+            readonly distribution: VariantType<{
+                readonly normal: NullType;
+                readonly lognormal: NullType;
+            }>;
+            readonly n_features: IntegerType;
+        }>;
+        readonly gp_regressor: StructType<{
+            readonly data: BlobType;
+            readonly n_features: IntegerType;
+            readonly kernel_type: StringType;
+        }>;
+        readonly torch_mlp: StructType<{
+            readonly data: BlobType;
+            readonly n_features: IntegerType;
+            readonly hidden_layers: ArrayType<IntegerType>;
+            readonly output_dim: IntegerType;
+        }>;
+        readonly standard_scaler: StructType<{
+            readonly onnx: BlobType;
+            readonly n_features: IntegerType;
+        }>;
+        readonly min_max_scaler: StructType<{
+            readonly onnx: BlobType;
+            readonly n_features: IntegerType;
+        }>;
+        readonly regressor_chain: StructType<{
+            readonly data: BlobType;
+            readonly n_features: IntegerType;
+            readonly n_targets: IntegerType;
+            readonly base_estimator_type: StringType;
+        }>;
+        readonly mapie_split: StructType<{
+            readonly data: VariantType<{
+                readonly xgboost: BlobType;
+                readonly lightgbm: BlobType;
+                readonly histogram: BlobType;
+            }>;
+            readonly n_features: IntegerType;
+            readonly confidence_level: FloatType;
+        }>;
+        readonly mapie_cross: StructType<{
+            readonly data: VariantType<{
+                readonly xgboost: BlobType;
+                readonly lightgbm: BlobType;
+                readonly histogram: BlobType;
+            }>;
+            readonly n_features: IntegerType;
+            readonly confidence_level: FloatType;
+        }>;
+        readonly mapie_cqr: StructType<{
+            readonly data: VariantType<{
+                readonly xgboost: BlobType;
+                readonly lightgbm: BlobType;
+                readonly histogram: BlobType;
+            }>;
+            readonly n_features: IntegerType;
+            readonly confidence_level: FloatType;
+        }>;
+        readonly mapie_classifier: StructType<{
+            readonly data: VariantType<{
+                readonly xgboost: BlobType;
+                readonly lightgbm: BlobType;
+                readonly histogram: BlobType;
+            }>;
+            readonly n_features: IntegerType;
+            readonly n_classes: IntegerType;
+            readonly classes: ArrayType<IntegerType>;
+            readonly confidence_level: FloatType;
+        }>;
+        readonly mapie_interval_width: StructType<{
+            readonly data: BlobType;
+            readonly n_features: IntegerType;
+        }>;
+        readonly mapie_set_size: StructType<{
+            readonly data: BlobType;
+            readonly n_features: IntegerType;
         }>;
     }>, ArrayType<ArrayType<FloatType>>], VariantType<{
         /** SHAP TreeExplainer for tree-based models */
-        shap_tree_explainer: StructType<{
+        readonly shap_tree_explainer: StructType<{
             /** Cloudpickle serialized explainer */
-            data: BlobType;
+            readonly data: BlobType;
             /** Number of input features */
-            n_features: IntegerType;
+            readonly n_features: IntegerType;
         }>;
         /** SHAP KernelExplainer for any model */
-        shap_kernel_explainer: StructType<{
+        readonly shap_kernel_explainer: StructType<{
             /** Cloudpickle serialized explainer */
-            data: BlobType;
+            readonly data: BlobType;
             /** Number of input features */
-            n_features: IntegerType;
+            readonly n_features: IntegerType;
         }>;
     }>>;
     /** Compute SHAP values */
     readonly computeValues: import("@elaraai/east").PlatformDefinition<[VariantType<{
         /** SHAP TreeExplainer for tree-based models */
-        shap_tree_explainer: StructType<{
+        readonly shap_tree_explainer: StructType<{
             /** Cloudpickle serialized explainer */
-            data: BlobType;
+            readonly data: BlobType;
             /** Number of input features */
-            n_features: IntegerType;
+            readonly n_features: IntegerType;
         }>;
         /** SHAP KernelExplainer for any model */
-        shap_kernel_explainer: StructType<{
+        readonly shap_kernel_explainer: StructType<{
             /** Cloudpickle serialized explainer */
-            data: BlobType;
+            readonly data: BlobType;
             /** Number of input features */
-            n_features: IntegerType;
+            readonly n_features: IntegerType;
         }>;
     }>, ArrayType<ArrayType<FloatType>>, ArrayType<StringType>], StructType<{
-        /** SHAP values matrix (n_samples x n_features) */
-        shap_values: ArrayType<ArrayType<FloatType>>;
-        /** Base value (expected model output) */
-        base_value: FloatType;
+        /** SHAP values - 2D matrix or 3D tensor depending on model type */
+        readonly shap_values: VariantType<{
+            /** 2D matrix for regression or binary classification (n_samples x n_features) */
+            readonly matrix_2d: ArrayType<ArrayType<FloatType>>;
+            /** 3D tensor for multi-class classification (n_samples x n_features x n_classes) */
+            readonly tensor_3d: ArrayType<ArrayType<ArrayType<FloatType>>>;
+        }>;
+        /** Base value(s) - single float or per-class array */
+        readonly base_value: VariantType<{
+            /** Single base value for regression or binary classification */
+            readonly single: FloatType;
+            /** Per-class base values for multi-class classification */
+            readonly per_class: ArrayType<FloatType>;
+        }>;
         /** Feature names */
-        feature_names: ArrayType<StringType>;
+        readonly feature_names: ArrayType<StringType>;
     }>>;
     /** Compute feature importance from SHAP values */
-    readonly featureImportance: import("@elaraai/east").PlatformDefinition<[ArrayType<ArrayType<FloatType>>, ArrayType<StringType>], StructType<{
+    readonly featureImportance: import("@elaraai/east").PlatformDefinition<[VariantType<{
+        /** 2D matrix for regression or binary classification (n_samples x n_features) */
+        readonly matrix_2d: ArrayType<ArrayType<FloatType>>;
+        /** 3D tensor for multi-class classification (n_samples x n_features x n_classes) */
+        readonly tensor_3d: ArrayType<ArrayType<ArrayType<FloatType>>>;
+    }>, ArrayType<StringType>], StructType<{
         /** Feature names */
-        feature_names: ArrayType<StringType>;
+        readonly feature_names: ArrayType<StringType>;
         /** Mean absolute SHAP value for each feature */
-        importances: ArrayType<FloatType>;
+        readonly importances: ArrayType<FloatType>;
         /** Standard deviation of absolute SHAP values */
-        std: OptionType<ArrayType<FloatType>>;
+        readonly std: OptionType<ArrayType<FloatType>>;
     }>>;
     /** Type definitions */
     readonly Types: {
@@ -552,104 +1214,236 @@ export declare const Shap: {
         readonly MatrixType: ArrayType<ArrayType<FloatType>>;
         /** String vector type */
         readonly StringVectorType: ArrayType<StringType>;
+        /** SHAP values variant type (2D or 3D) */
+        readonly ShapValuesType: VariantType<{
+            /** 2D matrix for regression or binary classification (n_samples x n_features) */
+            readonly matrix_2d: ArrayType<ArrayType<FloatType>>;
+            /** 3D tensor for multi-class classification (n_samples x n_features x n_classes) */
+            readonly tensor_3d: ArrayType<ArrayType<ArrayType<FloatType>>>;
+        }>;
+        /** SHAP base value variant type (single or per-class) */
+        readonly ShapBaseValueType: VariantType<{
+            /** Single base value for regression or binary classification */
+            readonly single: FloatType;
+            /** Per-class base values for multi-class classification */
+            readonly per_class: ArrayType<FloatType>;
+        }>;
         /** SHAP result type */
         readonly ShapResultType: StructType<{
-            /** SHAP values matrix (n_samples x n_features) */
-            shap_values: ArrayType<ArrayType<FloatType>>;
-            /** Base value (expected model output) */
-            base_value: FloatType;
+            /** SHAP values - 2D matrix or 3D tensor depending on model type */
+            readonly shap_values: VariantType<{
+                /** 2D matrix for regression or binary classification (n_samples x n_features) */
+                readonly matrix_2d: ArrayType<ArrayType<FloatType>>;
+                /** 3D tensor for multi-class classification (n_samples x n_features x n_classes) */
+                readonly tensor_3d: ArrayType<ArrayType<ArrayType<FloatType>>>;
+            }>;
+            /** Base value(s) - single float or per-class array */
+            readonly base_value: VariantType<{
+                /** Single base value for regression or binary classification */
+                readonly single: FloatType;
+                /** Per-class base values for multi-class classification */
+                readonly per_class: ArrayType<FloatType>;
+            }>;
             /** Feature names */
-            feature_names: ArrayType<StringType>;
+            readonly feature_names: ArrayType<StringType>;
         }>;
         /** Feature importance type */
         readonly FeatureImportanceType: StructType<{
             /** Feature names */
-            feature_names: ArrayType<StringType>;
+            readonly feature_names: ArrayType<StringType>;
             /** Mean absolute SHAP value for each feature */
-            importances: ArrayType<FloatType>;
+            readonly importances: ArrayType<FloatType>;
             /** Standard deviation of absolute SHAP values */
-            std: OptionType<ArrayType<FloatType>>;
+            readonly std: OptionType<ArrayType<FloatType>>;
         }>;
         /** SHAP explainer model blob type */
         readonly ShapModelBlobType: VariantType<{
             /** SHAP TreeExplainer for tree-based models */
-            shap_tree_explainer: StructType<{
+            readonly shap_tree_explainer: StructType<{
                 /** Cloudpickle serialized explainer */
-                data: BlobType;
+                readonly data: BlobType;
                 /** Number of input features */
-                n_features: IntegerType;
+                readonly n_features: IntegerType;
             }>;
             /** SHAP KernelExplainer for any model */
-            shap_kernel_explainer: StructType<{
+            readonly shap_kernel_explainer: StructType<{
                 /** Cloudpickle serialized explainer */
-                data: BlobType;
+                readonly data: BlobType;
                 /** Number of input features */
-                n_features: IntegerType;
+                readonly n_features: IntegerType;
             }>;
         }>;
         /** Tree model blob type for input */
         readonly TreeModelBlobType: VariantType<{
             /** XGBoost regressor */
-            xgboost_regressor: StructType<{
-                data: BlobType;
-                n_features: IntegerType;
+            readonly xgboost_regressor: StructType<{
+                readonly data: BlobType;
+                readonly n_features: IntegerType;
+                readonly categorical_features: OptionType<ArrayType<IntegerType>>;
             }>;
             /** XGBoost classifier */
-            xgboost_classifier: StructType<{
-                data: BlobType;
-                n_features: IntegerType;
-                n_classes: IntegerType;
+            readonly xgboost_classifier: StructType<{
+                readonly data: BlobType;
+                readonly n_features: IntegerType;
+                readonly n_classes: IntegerType;
+                readonly categorical_features: OptionType<ArrayType<IntegerType>>;
             }>;
-            /** LightGBM regressor */
-            lightgbm_regressor: StructType<{
-                data: BlobType;
-                n_features: IntegerType;
+            /** XGBoost quantile regressor (uses median quantile for explanations) */
+            readonly xgboost_quantile: StructType<{
+                readonly data: BlobType;
+                readonly quantiles: ArrayType<FloatType>;
+                readonly n_features: IntegerType;
+                readonly categorical_features: OptionType<ArrayType<IntegerType>>;
             }>;
-            /** LightGBM classifier */
-            lightgbm_classifier: StructType<{
-                data: BlobType;
-                n_features: IntegerType;
-                n_classes: IntegerType;
+            /** MAPIE split conformal regressor with XGBoost base */
+            readonly mapie_split: StructType<{
+                readonly data: VariantType<{
+                    readonly xgboost: BlobType;
+                    readonly lightgbm: BlobType;
+                    readonly histogram: BlobType;
+                }>;
+                readonly n_features: IntegerType;
+                readonly confidence_level: FloatType;
+            }>;
+            /** MAPIE cross conformal regressor with XGBoost base */
+            readonly mapie_cross: StructType<{
+                readonly data: VariantType<{
+                    readonly xgboost: BlobType;
+                    readonly lightgbm: BlobType;
+                    readonly histogram: BlobType;
+                }>;
+                readonly n_features: IntegerType;
+                readonly confidence_level: FloatType;
+            }>;
+            /** MAPIE CQR conformal regressor with XGBoost base */
+            readonly mapie_cqr: StructType<{
+                readonly data: VariantType<{
+                    readonly xgboost: BlobType;
+                    readonly lightgbm: BlobType;
+                    readonly histogram: BlobType;
+                }>;
+                readonly n_features: IntegerType;
+                readonly confidence_level: FloatType;
+            }>;
+            /** MAPIE conformal classifier with XGBoost base */
+            readonly mapie_classifier: StructType<{
+                readonly data: VariantType<{
+                    readonly xgboost: BlobType;
+                    readonly lightgbm: BlobType;
+                    readonly histogram: BlobType;
+                }>;
+                readonly n_features: IntegerType;
+                readonly n_classes: IntegerType;
+                readonly classes: ArrayType<IntegerType>;
+                readonly confidence_level: FloatType;
             }>;
         }>;
         /** Any model blob type for kernel explainer */
         readonly AnyModelBlobType: VariantType<{
-            xgboost_regressor: StructType<{
-                data: BlobType;
-                n_features: IntegerType;
-            }>;
-            xgboost_classifier: StructType<{
-                data: BlobType;
-                n_features: IntegerType;
-                n_classes: IntegerType;
-            }>;
-            lightgbm_regressor: StructType<{
-                data: BlobType;
-                n_features: IntegerType;
-            }>;
-            lightgbm_classifier: StructType<{
-                data: BlobType;
-                n_features: IntegerType;
-                n_classes: IntegerType;
-            }>;
-            ngboost_regressor: StructType<{
-                data: BlobType;
-                distribution: VariantType<{
-                    normal: StructType<{}>;
-                    lognormal: StructType<{}>;
+            readonly xgboost_regressor: StructType<{
+                readonly data: BlobType;
+                readonly n_features: IntegerType;
+                readonly categorical_features: OptionType<ArrayType<IntegerType>>;
+            }>;
+            readonly xgboost_classifier: StructType<{
+                readonly data: BlobType;
+                readonly n_features: IntegerType;
+                readonly n_classes: IntegerType;
+                readonly categorical_features: OptionType<ArrayType<IntegerType>>;
+            }>;
+            readonly xgboost_quantile: StructType<{
+                readonly data: BlobType;
+                readonly quantiles: ArrayType<FloatType>;
+                readonly n_features: IntegerType;
+                readonly categorical_features: OptionType<ArrayType<IntegerType>>;
+            }>;
+            readonly lightgbm_regressor: StructType<{
+                readonly data: BlobType;
+                readonly n_features: IntegerType;
+            }>;
+            readonly lightgbm_classifier: StructType<{
+                readonly data: BlobType;
+                readonly n_features: IntegerType;
+                readonly n_classes: IntegerType;
+            }>;
+            readonly ngboost_regressor: StructType<{
+                readonly data: BlobType;
+                readonly distribution: VariantType<{
+                    readonly normal: NullType;
+                    readonly lognormal: NullType;
+                }>;
+                readonly n_features: IntegerType;
+            }>;
+            readonly gp_regressor: StructType<{
+                readonly data: BlobType;
+                readonly n_features: IntegerType;
+                readonly kernel_type: StringType;
+            }>;
+            readonly torch_mlp: StructType<{
+                readonly data: BlobType;
+                readonly n_features: IntegerType;
+                readonly hidden_layers: ArrayType<IntegerType>;
+                readonly output_dim: IntegerType;
+            }>;
+            readonly standard_scaler: StructType<{
+                readonly onnx: BlobType;
+                readonly n_features: IntegerType;
+            }>;
+            readonly min_max_scaler: StructType<{
+                readonly onnx: BlobType;
+                readonly n_features: IntegerType;
+            }>;
+            readonly regressor_chain: StructType<{
+                readonly data: BlobType;
+                readonly n_features: IntegerType;
+                readonly n_targets: IntegerType;
+                readonly base_estimator_type: StringType;
+            }>;
+            readonly mapie_split: StructType<{
+                readonly data: VariantType<{
+                    readonly xgboost: BlobType;
+                    readonly lightgbm: BlobType;
+                    readonly histogram: BlobType;
+                }>;
+                readonly n_features: IntegerType;
+                readonly confidence_level: FloatType;
+            }>;
+            readonly mapie_cross: StructType<{
+                readonly data: VariantType<{
+                    readonly xgboost: BlobType;
+                    readonly lightgbm: BlobType;
+                    readonly histogram: BlobType;
                 }>;
-                n_features: IntegerType;
-            }>;
-            gp_regressor: StructType<{
-                data: BlobType;
-                n_features: IntegerType;
-                kernel_type: StringType;
-            }>;
-            torch_mlp: StructType<{
-                data: BlobType;
-                n_features: IntegerType;
-                hidden_layers: ArrayType<IntegerType>;
-                output_dim: IntegerType;
+                readonly n_features: IntegerType;
+                readonly confidence_level: FloatType;
+            }>;
+            readonly mapie_cqr: StructType<{
+                readonly data: VariantType<{
+                    readonly xgboost: BlobType;
+                    readonly lightgbm: BlobType;
+                    readonly histogram: BlobType;
+                }>;
+                readonly n_features: IntegerType;
+                readonly confidence_level: FloatType;
+            }>;
+            readonly mapie_classifier: StructType<{
+                readonly data: VariantType<{
+                    readonly xgboost: BlobType;
+                    readonly lightgbm: BlobType;
+                    readonly histogram: BlobType;
+                }>;
+                readonly n_features: IntegerType;
+                readonly n_classes: IntegerType;
+                readonly classes: ArrayType<IntegerType>;
+                readonly confidence_level: FloatType;
+            }>;
+            readonly mapie_interval_width: StructType<{
+                readonly data: BlobType;
+                readonly n_features: IntegerType;
+            }>;
+            readonly mapie_set_size: StructType<{
+                readonly data: BlobType;
+                readonly n_features: IntegerType;
             }>;
         }>;
     };