@elaraai/east-py-datascience 0.0.2-beta.80 → 0.0.2-beta.81

package/dist/src/shap/shap.d.ts

@@ -797,203 +797,814 @@ export declare const MapieClassifierShapResultType: StructType<{
         readonly feature_names: ArrayType<StringType>;
     }>;
 }>;
+/**
+ * Configuration for TreeExplainer creation.
+ *
+ * - `path_dependent`: Uses tree structure to compute SHAP values. Fast, but may
+ *   conflate correlated features because it follows the tree's split paths.
+ * - `interventional`: Uses background data to break feature correlations, giving
+ *   causal "what if I changed this feature" explanations. Requires background samples.
+ */
+export declare const TreeExplainerConfigType: VariantType<{
+    /** Path-dependent mode: uses tree structure only (default SHAP behavior) */
+    readonly path_dependent: StructType<{
+        /** Tree-based model blob */
+        readonly model: VariantType<{
+            /** XGBoost regressor */
+            readonly xgboost_regressor: StructType<{
+                readonly data: BlobType;
+                readonly n_features: IntegerType;
+                readonly categorical_features: OptionType<VectorType<IntegerType>>;
+                readonly categorical_n: OptionType<VectorType<IntegerType>>;
+            }>;
+            /** XGBoost classifier */
+            readonly xgboost_classifier: StructType<{
+                readonly data: BlobType;
+                readonly n_features: IntegerType;
+                readonly n_classes: IntegerType;
+                readonly categorical_features: OptionType<VectorType<IntegerType>>;
+                readonly categorical_n: OptionType<VectorType<IntegerType>>;
+            }>;
+            /** XGBoost quantile regressor (uses median quantile for explanations) */
+            readonly xgboost_quantile: StructType<{
+                readonly data: BlobType;
+                readonly quantiles: VectorType<FloatType>;
+                readonly n_features: IntegerType;
+                readonly categorical_features: OptionType<VectorType<IntegerType>>;
+                readonly categorical_n: OptionType<VectorType<IntegerType>>;
+            }>;
+            /** MAPIE split conformal regressor with XGBoost base */
+            readonly mapie_split: StructType<{
+                readonly data: VariantType<{
+                    readonly xgboost: VariantType<{
+                        readonly xgboost_regressor: StructType<{
+                            readonly data: BlobType;
+                            readonly n_features: IntegerType;
+                            readonly categorical_features: OptionType<VectorType<IntegerType>>;
+                            readonly categorical_n: OptionType<VectorType<IntegerType>>;
+                        }>;
+                        readonly xgboost_classifier: StructType<{
+                            readonly data: BlobType;
+                            readonly n_features: IntegerType;
+                            readonly n_classes: IntegerType;
+                            readonly categorical_features: OptionType<VectorType<IntegerType>>;
+                            readonly categorical_n: OptionType<VectorType<IntegerType>>;
+                        }>;
+                        readonly xgboost_quantile: StructType<{
+                            readonly data: BlobType;
+                            readonly quantiles: VectorType<FloatType>;
+                            readonly n_features: IntegerType;
+                            readonly categorical_features: OptionType<VectorType<IntegerType>>;
+                            readonly categorical_n: OptionType<VectorType<IntegerType>>;
+                        }>;
+                    }>;
+                    readonly lightgbm: VariantType<{
+                        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 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: VariantType<{
+                        readonly xgboost_regressor: StructType<{
+                            readonly data: BlobType;
+                            readonly n_features: IntegerType;
+                            readonly categorical_features: OptionType<VectorType<IntegerType>>;
+                            readonly categorical_n: OptionType<VectorType<IntegerType>>;
+                        }>;
+                        readonly xgboost_classifier: StructType<{
+                            readonly data: BlobType;
+                            readonly n_features: IntegerType;
+                            readonly n_classes: IntegerType;
+                            readonly categorical_features: OptionType<VectorType<IntegerType>>;
+                            readonly categorical_n: OptionType<VectorType<IntegerType>>;
+                        }>;
+                        readonly xgboost_quantile: StructType<{
+                            readonly data: BlobType;
+                            readonly quantiles: VectorType<FloatType>;
+                            readonly n_features: IntegerType;
+                            readonly categorical_features: OptionType<VectorType<IntegerType>>;
+                            readonly categorical_n: OptionType<VectorType<IntegerType>>;
+                        }>;
+                    }>;
+                    readonly lightgbm: VariantType<{
+                        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 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: VariantType<{
+                        readonly xgboost_regressor: StructType<{
+                            readonly data: BlobType;
+                            readonly n_features: IntegerType;
+                            readonly categorical_features: OptionType<VectorType<IntegerType>>;
+                            readonly categorical_n: OptionType<VectorType<IntegerType>>;
+                        }>;
+                        readonly xgboost_classifier: StructType<{
+                            readonly data: BlobType;
+                            readonly n_features: IntegerType;
+                            readonly n_classes: IntegerType;
+                            readonly categorical_features: OptionType<VectorType<IntegerType>>;
+                            readonly categorical_n: OptionType<VectorType<IntegerType>>;
+                        }>;
+                        readonly xgboost_quantile: StructType<{
+                            readonly data: BlobType;
+                            readonly quantiles: VectorType<FloatType>;
+                            readonly n_features: IntegerType;
+                            readonly categorical_features: OptionType<VectorType<IntegerType>>;
+                            readonly categorical_n: OptionType<VectorType<IntegerType>>;
+                        }>;
+                    }>;
+                    readonly lightgbm: VariantType<{
+                        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 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: VariantType<{
+                        readonly xgboost_regressor: StructType<{
+                            readonly data: BlobType;
+                            readonly n_features: IntegerType;
+                            readonly categorical_features: OptionType<VectorType<IntegerType>>;
+                            readonly categorical_n: OptionType<VectorType<IntegerType>>;
+                        }>;
+                        readonly xgboost_classifier: StructType<{
+                            readonly data: BlobType;
+                            readonly n_features: IntegerType;
+                            readonly n_classes: IntegerType;
+                            readonly categorical_features: OptionType<VectorType<IntegerType>>;
+                            readonly categorical_n: OptionType<VectorType<IntegerType>>;
+                        }>;
+                        readonly xgboost_quantile: StructType<{
+                            readonly data: BlobType;
+                            readonly quantiles: VectorType<FloatType>;
+                            readonly n_features: IntegerType;
+                            readonly categorical_features: OptionType<VectorType<IntegerType>>;
+                            readonly categorical_n: OptionType<VectorType<IntegerType>>;
+                        }>;
+                    }>;
+                    readonly lightgbm: VariantType<{
+                        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 histogram: BlobType;
+                }>;
+                readonly n_features: IntegerType;
+                readonly n_classes: IntegerType;
+                readonly classes: VectorType<IntegerType>;
+                readonly confidence_level: FloatType;
+            }>;
+        }>;
+    }>;
+    /** Interventional mode: uses background data to break feature correlations */
+    readonly interventional: StructType<{
+        /** Tree-based model blob */
+        readonly model: VariantType<{
+            /** XGBoost regressor */
+            readonly xgboost_regressor: StructType<{
+                readonly data: BlobType;
+                readonly n_features: IntegerType;
+                readonly categorical_features: OptionType<VectorType<IntegerType>>;
+                readonly categorical_n: OptionType<VectorType<IntegerType>>;
+            }>;
+            /** XGBoost classifier */
+            readonly xgboost_classifier: StructType<{
+                readonly data: BlobType;
+                readonly n_features: IntegerType;
+                readonly n_classes: IntegerType;
+                readonly categorical_features: OptionType<VectorType<IntegerType>>;
+                readonly categorical_n: OptionType<VectorType<IntegerType>>;
+            }>;
+            /** XGBoost quantile regressor (uses median quantile for explanations) */
+            readonly xgboost_quantile: StructType<{
+                readonly data: BlobType;
+                readonly quantiles: VectorType<FloatType>;
+                readonly n_features: IntegerType;
+                readonly categorical_features: OptionType<VectorType<IntegerType>>;
+                readonly categorical_n: OptionType<VectorType<IntegerType>>;
+            }>;
+            /** MAPIE split conformal regressor with XGBoost base */
+            readonly mapie_split: StructType<{
+                readonly data: VariantType<{
+                    readonly xgboost: VariantType<{
+                        readonly xgboost_regressor: StructType<{
+                            readonly data: BlobType;
+                            readonly n_features: IntegerType;
+                            readonly categorical_features: OptionType<VectorType<IntegerType>>;
+                            readonly categorical_n: OptionType<VectorType<IntegerType>>;
+                        }>;
+                        readonly xgboost_classifier: StructType<{
+                            readonly data: BlobType;
+                            readonly n_features: IntegerType;
+                            readonly n_classes: IntegerType;
+                            readonly categorical_features: OptionType<VectorType<IntegerType>>;
+                            readonly categorical_n: OptionType<VectorType<IntegerType>>;
+                        }>;
+                        readonly xgboost_quantile: StructType<{
+                            readonly data: BlobType;
+                            readonly quantiles: VectorType<FloatType>;
+                            readonly n_features: IntegerType;
+                            readonly categorical_features: OptionType<VectorType<IntegerType>>;
+                            readonly categorical_n: OptionType<VectorType<IntegerType>>;
+                        }>;
+                    }>;
+                    readonly lightgbm: VariantType<{
+                        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 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: VariantType<{
+                        readonly xgboost_regressor: StructType<{
+                            readonly data: BlobType;
+                            readonly n_features: IntegerType;
+                            readonly categorical_features: OptionType<VectorType<IntegerType>>;
+                            readonly categorical_n: OptionType<VectorType<IntegerType>>;
+                        }>;
+                        readonly xgboost_classifier: StructType<{
+                            readonly data: BlobType;
+                            readonly n_features: IntegerType;
+                            readonly n_classes: IntegerType;
+                            readonly categorical_features: OptionType<VectorType<IntegerType>>;
+                            readonly categorical_n: OptionType<VectorType<IntegerType>>;
+                        }>;
+                        readonly xgboost_quantile: StructType<{
+                            readonly data: BlobType;
+                            readonly quantiles: VectorType<FloatType>;
+                            readonly n_features: IntegerType;
+                            readonly categorical_features: OptionType<VectorType<IntegerType>>;
+                            readonly categorical_n: OptionType<VectorType<IntegerType>>;
+                        }>;
+                    }>;
+                    readonly lightgbm: VariantType<{
+                        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 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: VariantType<{
+                        readonly xgboost_regressor: StructType<{
+                            readonly data: BlobType;
+                            readonly n_features: IntegerType;
+                            readonly categorical_features: OptionType<VectorType<IntegerType>>;
+                            readonly categorical_n: OptionType<VectorType<IntegerType>>;
+                        }>;
+                        readonly xgboost_classifier: StructType<{
+                            readonly data: BlobType;
+                            readonly n_features: IntegerType;
+                            readonly n_classes: IntegerType;
+                            readonly categorical_features: OptionType<VectorType<IntegerType>>;
+                            readonly categorical_n: OptionType<VectorType<IntegerType>>;
+                        }>;
+                        readonly xgboost_quantile: StructType<{
+                            readonly data: BlobType;
+                            readonly quantiles: VectorType<FloatType>;
+                            readonly n_features: IntegerType;
+                            readonly categorical_features: OptionType<VectorType<IntegerType>>;
+                            readonly categorical_n: OptionType<VectorType<IntegerType>>;
+                        }>;
+                    }>;
+                    readonly lightgbm: VariantType<{
+                        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 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: VariantType<{
+                        readonly xgboost_regressor: StructType<{
+                            readonly data: BlobType;
+                            readonly n_features: IntegerType;
+                            readonly categorical_features: OptionType<VectorType<IntegerType>>;
+                            readonly categorical_n: OptionType<VectorType<IntegerType>>;
+                        }>;
+                        readonly xgboost_classifier: StructType<{
+                            readonly data: BlobType;
+                            readonly n_features: IntegerType;
+                            readonly n_classes: IntegerType;
+                            readonly categorical_features: OptionType<VectorType<IntegerType>>;
+                            readonly categorical_n: OptionType<VectorType<IntegerType>>;
+                        }>;
+                        readonly xgboost_quantile: StructType<{
+                            readonly data: BlobType;
+                            readonly quantiles: VectorType<FloatType>;
+                            readonly n_features: IntegerType;
+                            readonly categorical_features: OptionType<VectorType<IntegerType>>;
+                            readonly categorical_n: OptionType<VectorType<IntegerType>>;
+                        }>;
+                    }>;
+                    readonly lightgbm: VariantType<{
+                        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 histogram: BlobType;
+                }>;
+                readonly n_features: IntegerType;
+                readonly n_classes: IntegerType;
+                readonly classes: VectorType<IntegerType>;
+                readonly confidence_level: FloatType;
+            }>;
+        }>;
+        /** Background data for computing interventional expectations */
+        readonly background: MatrixType<FloatType>;
+    }>;
+}>;
 /**
  * Create a SHAP TreeExplainer for tree-based models.
  *
  * Works with XGBoost and LightGBM models (regressor and classifier).
  *
- * @param model - Tree-based model blob (XGBoost or LightGBM)
+ * Two modes:
+ * - `path_dependent`: Uses tree split paths (fast, default SHAP behavior).
+ *   Tells you how the tree *used* features.
+ * - `interventional`: Uses background data to break feature correlations.
+ *   Tells you how *changing* a feature would change the prediction.
+ *
+ * @param config - Variant with mode selection and model/background data
  * @returns SHAP TreeExplainer blob
  */
 export declare const shap_tree_explainer_create: import("@elaraai/east").PlatformDefinition<[VariantType<{
-    /** XGBoost regressor */
-    readonly xgboost_regressor: StructType<{
-        readonly data: BlobType;
-        readonly n_features: IntegerType;
-        readonly categorical_features: OptionType<VectorType<IntegerType>>;
-        readonly categorical_n: OptionType<VectorType<IntegerType>>;
-    }>;
-    /** XGBoost classifier */
-    readonly xgboost_classifier: StructType<{
-        readonly data: BlobType;
-        readonly n_features: IntegerType;
-        readonly n_classes: IntegerType;
-        readonly categorical_features: OptionType<VectorType<IntegerType>>;
-        readonly categorical_n: OptionType<VectorType<IntegerType>>;
-    }>;
-    /** XGBoost quantile regressor (uses median quantile for explanations) */
-    readonly xgboost_quantile: StructType<{
-        readonly data: BlobType;
-        readonly quantiles: VectorType<FloatType>;
-        readonly n_features: IntegerType;
-        readonly categorical_features: OptionType<VectorType<IntegerType>>;
-        readonly categorical_n: OptionType<VectorType<IntegerType>>;
-    }>;
-    /** MAPIE split conformal regressor with XGBoost base */
-    readonly mapie_split: StructType<{
-        readonly data: VariantType<{
-            readonly xgboost: VariantType<{
-                readonly xgboost_regressor: StructType<{
-                    readonly data: BlobType;
-                    readonly n_features: IntegerType;
-                    readonly categorical_features: OptionType<VectorType<IntegerType>>;
-                    readonly categorical_n: OptionType<VectorType<IntegerType>>;
-                }>;
-                readonly xgboost_classifier: StructType<{
-                    readonly data: BlobType;
-                    readonly n_features: IntegerType;
-                    readonly n_classes: IntegerType;
-                    readonly categorical_features: OptionType<VectorType<IntegerType>>;
-                    readonly categorical_n: OptionType<VectorType<IntegerType>>;
+    /** Path-dependent mode: uses tree structure only (default SHAP behavior) */
+    readonly path_dependent: StructType<{
+        /** Tree-based model blob */
+        readonly model: VariantType<{
+            /** XGBoost regressor */
+            readonly xgboost_regressor: StructType<{
+                readonly data: BlobType;
+                readonly n_features: IntegerType;
+                readonly categorical_features: OptionType<VectorType<IntegerType>>;
+                readonly categorical_n: OptionType<VectorType<IntegerType>>;
+            }>;
+            /** XGBoost classifier */
+            readonly xgboost_classifier: StructType<{
+                readonly data: BlobType;
+                readonly n_features: IntegerType;
+                readonly n_classes: IntegerType;
+                readonly categorical_features: OptionType<VectorType<IntegerType>>;
+                readonly categorical_n: OptionType<VectorType<IntegerType>>;
+            }>;
+            /** XGBoost quantile regressor (uses median quantile for explanations) */
+            readonly xgboost_quantile: StructType<{
+                readonly data: BlobType;
+                readonly quantiles: VectorType<FloatType>;
+                readonly n_features: IntegerType;
+                readonly categorical_features: OptionType<VectorType<IntegerType>>;
+                readonly categorical_n: OptionType<VectorType<IntegerType>>;
+            }>;
+            /** MAPIE split conformal regressor with XGBoost base */
+            readonly mapie_split: StructType<{
+                readonly data: VariantType<{
+                    readonly xgboost: VariantType<{
+                        readonly xgboost_regressor: StructType<{
+                            readonly data: BlobType;
+                            readonly n_features: IntegerType;
+                            readonly categorical_features: OptionType<VectorType<IntegerType>>;
+                            readonly categorical_n: OptionType<VectorType<IntegerType>>;
+                        }>;
+                        readonly xgboost_classifier: StructType<{
+                            readonly data: BlobType;
+                            readonly n_features: IntegerType;
+                            readonly n_classes: IntegerType;
+                            readonly categorical_features: OptionType<VectorType<IntegerType>>;
+                            readonly categorical_n: OptionType<VectorType<IntegerType>>;
+                        }>;
+                        readonly xgboost_quantile: StructType<{
+                            readonly data: BlobType;
+                            readonly quantiles: VectorType<FloatType>;
+                            readonly n_features: IntegerType;
+                            readonly categorical_features: OptionType<VectorType<IntegerType>>;
+                            readonly categorical_n: OptionType<VectorType<IntegerType>>;
+                        }>;
+                    }>;
+                    readonly lightgbm: VariantType<{
+                        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 histogram: BlobType;
                 }>;
-                readonly xgboost_quantile: StructType<{
-                    readonly data: BlobType;
-                    readonly quantiles: VectorType<FloatType>;
-                    readonly n_features: IntegerType;
-                    readonly categorical_features: OptionType<VectorType<IntegerType>>;
-                    readonly categorical_n: OptionType<VectorType<IntegerType>>;
+                readonly n_features: IntegerType;
+                readonly confidence_level: FloatType;
+            }>;
+            /** MAPIE cross conformal regressor with XGBoost base */
+            readonly mapie_cross: StructType<{
+                readonly data: VariantType<{
+                    readonly xgboost: VariantType<{
+                        readonly xgboost_regressor: StructType<{
+                            readonly data: BlobType;
+                            readonly n_features: IntegerType;
+                            readonly categorical_features: OptionType<VectorType<IntegerType>>;
+                            readonly categorical_n: OptionType<VectorType<IntegerType>>;
+                        }>;
+                        readonly xgboost_classifier: StructType<{
+                            readonly data: BlobType;
+                            readonly n_features: IntegerType;
+                            readonly n_classes: IntegerType;
+                            readonly categorical_features: OptionType<VectorType<IntegerType>>;
+                            readonly categorical_n: OptionType<VectorType<IntegerType>>;
+                        }>;
+                        readonly xgboost_quantile: StructType<{
+                            readonly data: BlobType;
+                            readonly quantiles: VectorType<FloatType>;
+                            readonly n_features: IntegerType;
+                            readonly categorical_features: OptionType<VectorType<IntegerType>>;
+                            readonly categorical_n: OptionType<VectorType<IntegerType>>;
+                        }>;
+                    }>;
+                    readonly lightgbm: VariantType<{
+                        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 histogram: BlobType;
                 }>;
+                readonly n_features: IntegerType;
+                readonly confidence_level: FloatType;
             }>;
-            readonly lightgbm: VariantType<{
-                readonly lightgbm_regressor: StructType<{
-                    readonly data: BlobType;
-                    readonly n_features: IntegerType;
+            /** MAPIE CQR conformal regressor with XGBoost base */
+            readonly mapie_cqr: StructType<{
+                readonly data: VariantType<{
+                    readonly xgboost: VariantType<{
+                        readonly xgboost_regressor: StructType<{
+                            readonly data: BlobType;
+                            readonly n_features: IntegerType;
+                            readonly categorical_features: OptionType<VectorType<IntegerType>>;
+                            readonly categorical_n: OptionType<VectorType<IntegerType>>;
+                        }>;
+                        readonly xgboost_classifier: StructType<{
+                            readonly data: BlobType;
+                            readonly n_features: IntegerType;
+                            readonly n_classes: IntegerType;
+                            readonly categorical_features: OptionType<VectorType<IntegerType>>;
+                            readonly categorical_n: OptionType<VectorType<IntegerType>>;
+                        }>;
+                        readonly xgboost_quantile: StructType<{
+                            readonly data: BlobType;
+                            readonly quantiles: VectorType<FloatType>;
+                            readonly n_features: IntegerType;
+                            readonly categorical_features: OptionType<VectorType<IntegerType>>;
+                            readonly categorical_n: OptionType<VectorType<IntegerType>>;
+                        }>;
+                    }>;
+                    readonly lightgbm: VariantType<{
+                        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 histogram: BlobType;
                 }>;
-                readonly lightgbm_classifier: StructType<{
-                    readonly data: BlobType;
-                    readonly n_features: IntegerType;
-                    readonly n_classes: IntegerType;
+                readonly n_features: IntegerType;
+                readonly confidence_level: FloatType;
+            }>;
+            /** MAPIE conformal classifier with XGBoost base */
+            readonly mapie_classifier: StructType<{
+                readonly data: VariantType<{
+                    readonly xgboost: VariantType<{
+                        readonly xgboost_regressor: StructType<{
+                            readonly data: BlobType;
+                            readonly n_features: IntegerType;
+                            readonly categorical_features: OptionType<VectorType<IntegerType>>;
+                            readonly categorical_n: OptionType<VectorType<IntegerType>>;
+                        }>;
+                        readonly xgboost_classifier: StructType<{
+                            readonly data: BlobType;
+                            readonly n_features: IntegerType;
+                            readonly n_classes: IntegerType;
+                            readonly categorical_features: OptionType<VectorType<IntegerType>>;
+                            readonly categorical_n: OptionType<VectorType<IntegerType>>;
+                        }>;
+                        readonly xgboost_quantile: StructType<{
+                            readonly data: BlobType;
+                            readonly quantiles: VectorType<FloatType>;
+                            readonly n_features: IntegerType;
+                            readonly categorical_features: OptionType<VectorType<IntegerType>>;
+                            readonly categorical_n: OptionType<VectorType<IntegerType>>;
+                        }>;
+                    }>;
+                    readonly lightgbm: VariantType<{
+                        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 histogram: BlobType;
                 }>;
+                readonly n_features: IntegerType;
+                readonly n_classes: IntegerType;
+                readonly classes: VectorType<IntegerType>;
+                readonly confidence_level: FloatType;
             }>;
-            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: VariantType<{
-                readonly xgboost_regressor: StructType<{
-                    readonly data: BlobType;
-                    readonly n_features: IntegerType;
-                    readonly categorical_features: OptionType<VectorType<IntegerType>>;
-                    readonly categorical_n: OptionType<VectorType<IntegerType>>;
-                }>;
-                readonly xgboost_classifier: StructType<{
-                    readonly data: BlobType;
-                    readonly n_features: IntegerType;
-                    readonly n_classes: IntegerType;
-                    readonly categorical_features: OptionType<VectorType<IntegerType>>;
-                    readonly categorical_n: OptionType<VectorType<IntegerType>>;
-                }>;
-                readonly xgboost_quantile: StructType<{
-                    readonly data: BlobType;
-                    readonly quantiles: VectorType<FloatType>;
-                    readonly n_features: IntegerType;
-                    readonly categorical_features: OptionType<VectorType<IntegerType>>;
-                    readonly categorical_n: OptionType<VectorType<IntegerType>>;
-                }>;
+    /** Interventional mode: uses background data to break feature correlations */
+    readonly interventional: StructType<{
+        /** Tree-based model blob */
+        readonly model: VariantType<{
+            /** XGBoost regressor */
+            readonly xgboost_regressor: StructType<{
+                readonly data: BlobType;
+                readonly n_features: IntegerType;
+                readonly categorical_features: OptionType<VectorType<IntegerType>>;
+                readonly categorical_n: OptionType<VectorType<IntegerType>>;
             }>;
-            readonly lightgbm: VariantType<{
-                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;
-                }>;
+            /** XGBoost classifier */
+            readonly xgboost_classifier: StructType<{
+                readonly data: BlobType;
+                readonly n_features: IntegerType;
+                readonly n_classes: IntegerType;
+                readonly categorical_features: OptionType<VectorType<IntegerType>>;
+                readonly categorical_n: OptionType<VectorType<IntegerType>>;
             }>;
-            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: VariantType<{
-                readonly xgboost_regressor: StructType<{
-                    readonly data: BlobType;
-                    readonly n_features: IntegerType;
-                    readonly categorical_features: OptionType<VectorType<IntegerType>>;
-                    readonly categorical_n: OptionType<VectorType<IntegerType>>;
-                }>;
-                readonly xgboost_classifier: StructType<{
-                    readonly data: BlobType;
-                    readonly n_features: IntegerType;
-                    readonly n_classes: IntegerType;
-                    readonly categorical_features: OptionType<VectorType<IntegerType>>;
-                    readonly categorical_n: OptionType<VectorType<IntegerType>>;
-                }>;
-                readonly xgboost_quantile: StructType<{
-                    readonly data: BlobType;
-                    readonly quantiles: VectorType<FloatType>;
-                    readonly n_features: IntegerType;
-                    readonly categorical_features: OptionType<VectorType<IntegerType>>;
-                    readonly categorical_n: OptionType<VectorType<IntegerType>>;
-                }>;
+            /** XGBoost quantile regressor (uses median quantile for explanations) */
+            readonly xgboost_quantile: StructType<{
+                readonly data: BlobType;
+                readonly quantiles: VectorType<FloatType>;
+                readonly n_features: IntegerType;
+                readonly categorical_features: OptionType<VectorType<IntegerType>>;
+                readonly categorical_n: OptionType<VectorType<IntegerType>>;
             }>;
-            readonly lightgbm: VariantType<{
-                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;
+            /** MAPIE split conformal regressor with XGBoost base */
+            readonly mapie_split: StructType<{
+                readonly data: VariantType<{
+                    readonly xgboost: VariantType<{
+                        readonly xgboost_regressor: StructType<{
+                            readonly data: BlobType;
+                            readonly n_features: IntegerType;
+                            readonly categorical_features: OptionType<VectorType<IntegerType>>;
+                            readonly categorical_n: OptionType<VectorType<IntegerType>>;
+                        }>;
+                        readonly xgboost_classifier: StructType<{
+                            readonly data: BlobType;
+                            readonly n_features: IntegerType;
+                            readonly n_classes: IntegerType;
+                            readonly categorical_features: OptionType<VectorType<IntegerType>>;
+                            readonly categorical_n: OptionType<VectorType<IntegerType>>;
+                        }>;
+                        readonly xgboost_quantile: StructType<{
+                            readonly data: BlobType;
+                            readonly quantiles: VectorType<FloatType>;
+                            readonly n_features: IntegerType;
+                            readonly categorical_features: OptionType<VectorType<IntegerType>>;
+                            readonly categorical_n: OptionType<VectorType<IntegerType>>;
+                        }>;
+                    }>;
+                    readonly lightgbm: VariantType<{
+                        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 histogram: BlobType;
                 }>;
+                readonly n_features: IntegerType;
+                readonly confidence_level: FloatType;
             }>;
-            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: VariantType<{
-                readonly xgboost_regressor: StructType<{
-                    readonly data: BlobType;
-                    readonly n_features: IntegerType;
-                    readonly categorical_features: OptionType<VectorType<IntegerType>>;
-                    readonly categorical_n: OptionType<VectorType<IntegerType>>;
-                }>;
-                readonly xgboost_classifier: StructType<{
-                    readonly data: BlobType;
-                    readonly n_features: IntegerType;
-                    readonly n_classes: IntegerType;
-                    readonly categorical_features: OptionType<VectorType<IntegerType>>;
-                    readonly categorical_n: OptionType<VectorType<IntegerType>>;
-                }>;
-                readonly xgboost_quantile: StructType<{
-                    readonly data: BlobType;
-                    readonly quantiles: VectorType<FloatType>;
-                    readonly n_features: IntegerType;
-                    readonly categorical_features: OptionType<VectorType<IntegerType>>;
-                    readonly categorical_n: OptionType<VectorType<IntegerType>>;
+            /** MAPIE cross conformal regressor with XGBoost base */
+            readonly mapie_cross: StructType<{
+                readonly data: VariantType<{
+                    readonly xgboost: VariantType<{
+                        readonly xgboost_regressor: StructType<{
+                            readonly data: BlobType;
+                            readonly n_features: IntegerType;
+                            readonly categorical_features: OptionType<VectorType<IntegerType>>;
+                            readonly categorical_n: OptionType<VectorType<IntegerType>>;
+                        }>;
+                        readonly xgboost_classifier: StructType<{
+                            readonly data: BlobType;
+                            readonly n_features: IntegerType;
+                            readonly n_classes: IntegerType;
+                            readonly categorical_features: OptionType<VectorType<IntegerType>>;
+                            readonly categorical_n: OptionType<VectorType<IntegerType>>;
+                        }>;
+                        readonly xgboost_quantile: StructType<{
+                            readonly data: BlobType;
+                            readonly quantiles: VectorType<FloatType>;
+                            readonly n_features: IntegerType;
+                            readonly categorical_features: OptionType<VectorType<IntegerType>>;
+                            readonly categorical_n: OptionType<VectorType<IntegerType>>;
+                        }>;
+                    }>;
+                    readonly lightgbm: VariantType<{
+                        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 histogram: BlobType;
                 }>;
+                readonly n_features: IntegerType;
+                readonly confidence_level: FloatType;
             }>;
-            readonly lightgbm: VariantType<{
-                readonly lightgbm_regressor: StructType<{
-                    readonly data: BlobType;
-                    readonly n_features: IntegerType;
+            /** MAPIE CQR conformal regressor with XGBoost base */
+            readonly mapie_cqr: StructType<{
+                readonly data: VariantType<{
+                    readonly xgboost: VariantType<{
+                        readonly xgboost_regressor: StructType<{
+                            readonly data: BlobType;
+                            readonly n_features: IntegerType;
+                            readonly categorical_features: OptionType<VectorType<IntegerType>>;
+                            readonly categorical_n: OptionType<VectorType<IntegerType>>;
+                        }>;
+                        readonly xgboost_classifier: StructType<{
+                            readonly data: BlobType;
+                            readonly n_features: IntegerType;
+                            readonly n_classes: IntegerType;
+                            readonly categorical_features: OptionType<VectorType<IntegerType>>;
+                            readonly categorical_n: OptionType<VectorType<IntegerType>>;
+                        }>;
+                        readonly xgboost_quantile: StructType<{
+                            readonly data: BlobType;
+                            readonly quantiles: VectorType<FloatType>;
+                            readonly n_features: IntegerType;
+                            readonly categorical_features: OptionType<VectorType<IntegerType>>;
+                            readonly categorical_n: OptionType<VectorType<IntegerType>>;
+                        }>;
+                    }>;
+                    readonly lightgbm: VariantType<{
+                        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 histogram: BlobType;
                 }>;
-                readonly lightgbm_classifier: StructType<{
-                    readonly data: BlobType;
-                    readonly n_features: IntegerType;
-                    readonly n_classes: IntegerType;
+                readonly n_features: IntegerType;
+                readonly confidence_level: FloatType;
+            }>;
+            /** MAPIE conformal classifier with XGBoost base */
+            readonly mapie_classifier: StructType<{
+                readonly data: VariantType<{
+                    readonly xgboost: VariantType<{
+                        readonly xgboost_regressor: StructType<{
+                            readonly data: BlobType;
+                            readonly n_features: IntegerType;
+                            readonly categorical_features: OptionType<VectorType<IntegerType>>;
+                            readonly categorical_n: OptionType<VectorType<IntegerType>>;
+                        }>;
+                        readonly xgboost_classifier: StructType<{
+                            readonly data: BlobType;
+                            readonly n_features: IntegerType;
+                            readonly n_classes: IntegerType;
+                            readonly categorical_features: OptionType<VectorType<IntegerType>>;
+                            readonly categorical_n: OptionType<VectorType<IntegerType>>;
+                        }>;
+                        readonly xgboost_quantile: StructType<{
+                            readonly data: BlobType;
+                            readonly quantiles: VectorType<FloatType>;
+                            readonly n_features: IntegerType;
+                            readonly categorical_features: OptionType<VectorType<IntegerType>>;
+                            readonly categorical_n: OptionType<VectorType<IntegerType>>;
+                        }>;
+                    }>;
+                    readonly lightgbm: VariantType<{
+                        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 histogram: BlobType;
                 }>;
+                readonly n_features: IntegerType;
+                readonly n_classes: IntegerType;
+                readonly classes: VectorType<IntegerType>;
+                readonly confidence_level: FloatType;
             }>;
-            readonly histogram: BlobType;
         }>;
-        readonly n_features: IntegerType;
-        readonly n_classes: IntegerType;
-        readonly classes: VectorType<IntegerType>;
-        readonly confidence_level: FloatType;
+        /** Background data for computing interventional expectations */
+        readonly background: MatrixType<FloatType>;
     }>;
 }>], VariantType<{
     /** SHAP TreeExplainer for tree-based models */
@@ -1383,236 +1994,46 @@ export declare const ShapTypes: {
             readonly single: FloatType;
             /** Per-class base values for multi-class classification */
             readonly per_class: VectorType<FloatType>;
-        }>;
-        /** Feature names */
-        readonly feature_names: ArrayType<StringType>;
-    }>;
-    /** Feature importance type */
-    readonly FeatureImportanceType: StructType<{
-        /** Feature names */
-        readonly feature_names: ArrayType<StringType>;
-        /** Mean absolute SHAP value for each feature */
-        readonly importances: VectorType<FloatType>;
-        /** Standard deviation of absolute SHAP values */
-        readonly std: OptionType<VectorType<FloatType>>;
-    }>;
-    /** SHAP explainer model blob type */
-    readonly ShapModelBlobType: VariantType<{
-        /** SHAP TreeExplainer for tree-based models */
-        readonly shap_tree_explainer: StructType<{
-            /** Cloudpickle serialized explainer */
-            readonly data: BlobType;
-            /** Number of input features */
-            readonly n_features: IntegerType;
-        }>;
-        /** SHAP KernelExplainer for any model */
-        readonly shap_kernel_explainer: StructType<{
-            /** Cloudpickle serialized explainer */
-            readonly data: BlobType;
-            /** Number of input features */
-            readonly n_features: IntegerType;
-        }>;
-    }>;
-    /** Tree model blob type for input */
-    readonly TreeModelBlobType: VariantType<{
-        /** XGBoost regressor */
-        readonly xgboost_regressor: StructType<{
-            readonly data: BlobType;
-            readonly n_features: IntegerType;
-            readonly categorical_features: OptionType<VectorType<IntegerType>>;
-            readonly categorical_n: OptionType<VectorType<IntegerType>>;
-        }>;
-        /** XGBoost classifier */
-        readonly xgboost_classifier: StructType<{
-            readonly data: BlobType;
-            readonly n_features: IntegerType;
-            readonly n_classes: IntegerType;
-            readonly categorical_features: OptionType<VectorType<IntegerType>>;
-            readonly categorical_n: OptionType<VectorType<IntegerType>>;
-        }>;
-        /** XGBoost quantile regressor (uses median quantile for explanations) */
-        readonly xgboost_quantile: StructType<{
-            readonly data: BlobType;
-            readonly quantiles: VectorType<FloatType>;
-            readonly n_features: IntegerType;
-            readonly categorical_features: OptionType<VectorType<IntegerType>>;
-            readonly categorical_n: OptionType<VectorType<IntegerType>>;
-        }>;
-        /** MAPIE split conformal regressor with XGBoost base */
-        readonly mapie_split: StructType<{
-            readonly data: VariantType<{
-                readonly xgboost: VariantType<{
-                    readonly xgboost_regressor: StructType<{
-                        readonly data: BlobType;
-                        readonly n_features: IntegerType;
-                        readonly categorical_features: OptionType<VectorType<IntegerType>>;
-                        readonly categorical_n: OptionType<VectorType<IntegerType>>;
-                    }>;
-                    readonly xgboost_classifier: StructType<{
-                        readonly data: BlobType;
-                        readonly n_features: IntegerType;
-                        readonly n_classes: IntegerType;
-                        readonly categorical_features: OptionType<VectorType<IntegerType>>;
-                        readonly categorical_n: OptionType<VectorType<IntegerType>>;
-                    }>;
-                    readonly xgboost_quantile: StructType<{
-                        readonly data: BlobType;
-                        readonly quantiles: VectorType<FloatType>;
-                        readonly n_features: IntegerType;
-                        readonly categorical_features: OptionType<VectorType<IntegerType>>;
-                        readonly categorical_n: OptionType<VectorType<IntegerType>>;
-                    }>;
-                }>;
-                readonly lightgbm: VariantType<{
-                    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 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: VariantType<{
-                    readonly xgboost_regressor: StructType<{
-                        readonly data: BlobType;
-                        readonly n_features: IntegerType;
-                        readonly categorical_features: OptionType<VectorType<IntegerType>>;
-                        readonly categorical_n: OptionType<VectorType<IntegerType>>;
-                    }>;
-                    readonly xgboost_classifier: StructType<{
-                        readonly data: BlobType;
-                        readonly n_features: IntegerType;
-                        readonly n_classes: IntegerType;
-                        readonly categorical_features: OptionType<VectorType<IntegerType>>;
-                        readonly categorical_n: OptionType<VectorType<IntegerType>>;
-                    }>;
-                    readonly xgboost_quantile: StructType<{
-                        readonly data: BlobType;
-                        readonly quantiles: VectorType<FloatType>;
-                        readonly n_features: IntegerType;
-                        readonly categorical_features: OptionType<VectorType<IntegerType>>;
-                        readonly categorical_n: OptionType<VectorType<IntegerType>>;
-                    }>;
-                }>;
-                readonly lightgbm: VariantType<{
-                    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 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: VariantType<{
-                    readonly xgboost_regressor: StructType<{
-                        readonly data: BlobType;
-                        readonly n_features: IntegerType;
-                        readonly categorical_features: OptionType<VectorType<IntegerType>>;
-                        readonly categorical_n: OptionType<VectorType<IntegerType>>;
-                    }>;
-                    readonly xgboost_classifier: StructType<{
-                        readonly data: BlobType;
-                        readonly n_features: IntegerType;
-                        readonly n_classes: IntegerType;
-                        readonly categorical_features: OptionType<VectorType<IntegerType>>;
-                        readonly categorical_n: OptionType<VectorType<IntegerType>>;
-                    }>;
-                    readonly xgboost_quantile: StructType<{
-                        readonly data: BlobType;
-                        readonly quantiles: VectorType<FloatType>;
-                        readonly n_features: IntegerType;
-                        readonly categorical_features: OptionType<VectorType<IntegerType>>;
-                        readonly categorical_n: OptionType<VectorType<IntegerType>>;
-                    }>;
-                }>;
-                readonly lightgbm: VariantType<{
-                    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 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: VariantType<{
-                    readonly xgboost_regressor: StructType<{
-                        readonly data: BlobType;
-                        readonly n_features: IntegerType;
-                        readonly categorical_features: OptionType<VectorType<IntegerType>>;
-                        readonly categorical_n: OptionType<VectorType<IntegerType>>;
-                    }>;
-                    readonly xgboost_classifier: StructType<{
-                        readonly data: BlobType;
-                        readonly n_features: IntegerType;
-                        readonly n_classes: IntegerType;
-                        readonly categorical_features: OptionType<VectorType<IntegerType>>;
-                        readonly categorical_n: OptionType<VectorType<IntegerType>>;
-                    }>;
-                    readonly xgboost_quantile: StructType<{
-                        readonly data: BlobType;
-                        readonly quantiles: VectorType<FloatType>;
-                        readonly n_features: IntegerType;
-                        readonly categorical_features: OptionType<VectorType<IntegerType>>;
-                        readonly categorical_n: OptionType<VectorType<IntegerType>>;
-                    }>;
-                }>;
-                readonly lightgbm: VariantType<{
-                    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 histogram: BlobType;
-            }>;
+        }>;
+        /** Feature names */
+        readonly feature_names: ArrayType<StringType>;
+    }>;
+    /** Feature importance type */
+    readonly FeatureImportanceType: StructType<{
+        /** Feature names */
+        readonly feature_names: ArrayType<StringType>;
+        /** Mean absolute SHAP value for each feature */
+        readonly importances: VectorType<FloatType>;
+        /** Standard deviation of absolute SHAP values */
+        readonly std: OptionType<VectorType<FloatType>>;
+    }>;
+    /** SHAP explainer model blob type */
+    readonly ShapModelBlobType: VariantType<{
+        /** SHAP TreeExplainer for tree-based models */
+        readonly shap_tree_explainer: StructType<{
+            /** Cloudpickle serialized explainer */
+            readonly data: BlobType;
+            /** Number of input features */
+            readonly n_features: IntegerType;
+        }>;
+        /** SHAP KernelExplainer for any model */
+        readonly shap_kernel_explainer: StructType<{
+            /** Cloudpickle serialized explainer */
+            readonly data: BlobType;
+            /** Number of input features */
             readonly n_features: IntegerType;
-            readonly n_classes: IntegerType;
-            readonly classes: VectorType<IntegerType>;
-            readonly confidence_level: FloatType;
         }>;
     }>;
-    /** Any model blob type for kernel explainer */
-    readonly AnyModelBlobType: VariantType<{
+    /** Tree model blob type for input */
+    readonly TreeModelBlobType: VariantType<{
+        /** XGBoost regressor */
         readonly xgboost_regressor: StructType<{
             readonly data: BlobType;
             readonly n_features: IntegerType;
             readonly categorical_features: OptionType<VectorType<IntegerType>>;
             readonly categorical_n: OptionType<VectorType<IntegerType>>;
         }>;
+        /** XGBoost classifier */
         readonly xgboost_classifier: StructType<{
             readonly data: BlobType;
             readonly n_features: IntegerType;
@@ -1620,6 +2041,7 @@ export declare const ShapTypes: {
             readonly categorical_features: OptionType<VectorType<IntegerType>>;
             readonly categorical_n: OptionType<VectorType<IntegerType>>;
         }>;
+        /** XGBoost quantile regressor (uses median quantile for explanations) */
         readonly xgboost_quantile: StructType<{
             readonly data: BlobType;
             readonly quantiles: VectorType<FloatType>;
@@ -1627,65 +2049,7 @@ export declare const ShapTypes: {
             readonly categorical_features: OptionType<VectorType<IntegerType>>;
             readonly categorical_n: OptionType<VectorType<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 robust_scaler: StructType<{
-            readonly onnx: BlobType;
-            readonly n_features: IntegerType;
-        }>;
-        readonly label_encoder: StructType<{
-            readonly data: BlobType;
-            readonly n_classes: IntegerType;
-        }>;
-        readonly ordinal_encoder: StructType<{
-            readonly data: BlobType;
-            readonly n_features: IntegerType;
-        }>;
-        readonly gaussian_mixture: StructType<{
-            readonly data: BlobType;
-            readonly n_features: IntegerType;
-            readonly n_components: IntegerType;
-        }>;
-        readonly regressor_chain: StructType<{
-            readonly data: BlobType;
-            readonly n_features: IntegerType;
-            readonly n_targets: IntegerType;
-            readonly base_estimator_type: StringType;
-        }>;
+        /** MAPIE split conformal regressor with XGBoost base */
         readonly mapie_split: StructType<{
             readonly data: VariantType<{
                 readonly xgboost: VariantType<{
@@ -1726,6 +2090,7 @@ export declare const ShapTypes: {
             readonly n_features: IntegerType;
             readonly confidence_level: FloatType;
         }>;
+        /** MAPIE cross conformal regressor with XGBoost base */
         readonly mapie_cross: StructType<{
             readonly data: VariantType<{
                 readonly xgboost: VariantType<{
@@ -1766,6 +2131,7 @@ export declare const ShapTypes: {
             readonly n_features: IntegerType;
             readonly confidence_level: FloatType;
         }>;
+        /** MAPIE CQR conformal regressor with XGBoost base */
         readonly mapie_cqr: StructType<{
             readonly data: VariantType<{
                 readonly xgboost: VariantType<{
@@ -1806,6 +2172,7 @@ export declare const ShapTypes: {
             readonly n_features: IntegerType;
             readonly confidence_level: FloatType;
         }>;
+        /** MAPIE conformal classifier with XGBoost base */
         readonly mapie_classifier: StructType<{
             readonly data: VariantType<{
                 readonly xgboost: VariantType<{
@@ -1848,81 +2215,483 @@ export declare const ShapTypes: {
             readonly classes: VectorType<IntegerType>;
             readonly confidence_level: FloatType;
         }>;
-        readonly mapie_interval_width: StructType<{
+    }>;
+    /** TreeExplainer configuration type (path_dependent | interventional) */
+    readonly TreeExplainerConfigType: VariantType<{
+        /** Path-dependent mode: uses tree structure only (default SHAP behavior) */
+        readonly path_dependent: StructType<{
+            /** Tree-based model blob */
+            readonly model: VariantType<{
+                /** XGBoost regressor */
+                readonly xgboost_regressor: StructType<{
+                    readonly data: BlobType;
+                    readonly n_features: IntegerType;
+                    readonly categorical_features: OptionType<VectorType<IntegerType>>;
+                    readonly categorical_n: OptionType<VectorType<IntegerType>>;
+                }>;
+                /** XGBoost classifier */
+                readonly xgboost_classifier: StructType<{
+                    readonly data: BlobType;
+                    readonly n_features: IntegerType;
+                    readonly n_classes: IntegerType;
+                    readonly categorical_features: OptionType<VectorType<IntegerType>>;
+                    readonly categorical_n: OptionType<VectorType<IntegerType>>;
+                }>;
+                /** XGBoost quantile regressor (uses median quantile for explanations) */
+                readonly xgboost_quantile: StructType<{
+                    readonly data: BlobType;
+                    readonly quantiles: VectorType<FloatType>;
+                    readonly n_features: IntegerType;
+                    readonly categorical_features: OptionType<VectorType<IntegerType>>;
+                    readonly categorical_n: OptionType<VectorType<IntegerType>>;
+                }>;
+                /** MAPIE split conformal regressor with XGBoost base */
+                readonly mapie_split: StructType<{
+                    readonly data: VariantType<{
+                        readonly xgboost: VariantType<{
+                            readonly xgboost_regressor: StructType<{
+                                readonly data: BlobType;
+                                readonly n_features: IntegerType;
+                                readonly categorical_features: OptionType<VectorType<IntegerType>>;
+                                readonly categorical_n: OptionType<VectorType<IntegerType>>;
+                            }>;
+                            readonly xgboost_classifier: StructType<{
+                                readonly data: BlobType;
+                                readonly n_features: IntegerType;
+                                readonly n_classes: IntegerType;
+                                readonly categorical_features: OptionType<VectorType<IntegerType>>;
+                                readonly categorical_n: OptionType<VectorType<IntegerType>>;
+                            }>;
+                            readonly xgboost_quantile: StructType<{
+                                readonly data: BlobType;
+                                readonly quantiles: VectorType<FloatType>;
+                                readonly n_features: IntegerType;
+                                readonly categorical_features: OptionType<VectorType<IntegerType>>;
+                                readonly categorical_n: OptionType<VectorType<IntegerType>>;
+                            }>;
+                        }>;
+                        readonly lightgbm: VariantType<{
+                            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 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: VariantType<{
+                            readonly xgboost_regressor: StructType<{
+                                readonly data: BlobType;
+                                readonly n_features: IntegerType;
+                                readonly categorical_features: OptionType<VectorType<IntegerType>>;
+                                readonly categorical_n: OptionType<VectorType<IntegerType>>;
+                            }>;
+                            readonly xgboost_classifier: StructType<{
+                                readonly data: BlobType;
+                                readonly n_features: IntegerType;
+                                readonly n_classes: IntegerType;
+                                readonly categorical_features: OptionType<VectorType<IntegerType>>;
+                                readonly categorical_n: OptionType<VectorType<IntegerType>>;
+                            }>;
+                            readonly xgboost_quantile: StructType<{
+                                readonly data: BlobType;
+                                readonly quantiles: VectorType<FloatType>;
+                                readonly n_features: IntegerType;
+                                readonly categorical_features: OptionType<VectorType<IntegerType>>;
+                                readonly categorical_n: OptionType<VectorType<IntegerType>>;
+                            }>;
+                        }>;
+                        readonly lightgbm: VariantType<{
+                            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 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: VariantType<{
+                            readonly xgboost_regressor: StructType<{
+                                readonly data: BlobType;
+                                readonly n_features: IntegerType;
+                                readonly categorical_features: OptionType<VectorType<IntegerType>>;
+                                readonly categorical_n: OptionType<VectorType<IntegerType>>;
+                            }>;
+                            readonly xgboost_classifier: StructType<{
+                                readonly data: BlobType;
+                                readonly n_features: IntegerType;
+                                readonly n_classes: IntegerType;
+                                readonly categorical_features: OptionType<VectorType<IntegerType>>;
+                                readonly categorical_n: OptionType<VectorType<IntegerType>>;
+                            }>;
+                            readonly xgboost_quantile: StructType<{
+                                readonly data: BlobType;
+                                readonly quantiles: VectorType<FloatType>;
+                                readonly n_features: IntegerType;
+                                readonly categorical_features: OptionType<VectorType<IntegerType>>;
+                                readonly categorical_n: OptionType<VectorType<IntegerType>>;
+                            }>;
+                        }>;
+                        readonly lightgbm: VariantType<{
+                            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 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: VariantType<{
+                            readonly xgboost_regressor: StructType<{
+                                readonly data: BlobType;
+                                readonly n_features: IntegerType;
+                                readonly categorical_features: OptionType<VectorType<IntegerType>>;
+                                readonly categorical_n: OptionType<VectorType<IntegerType>>;
+                            }>;
+                            readonly xgboost_classifier: StructType<{
+                                readonly data: BlobType;
+                                readonly n_features: IntegerType;
+                                readonly n_classes: IntegerType;
+                                readonly categorical_features: OptionType<VectorType<IntegerType>>;
+                                readonly categorical_n: OptionType<VectorType<IntegerType>>;
+                            }>;
+                            readonly xgboost_quantile: StructType<{
+                                readonly data: BlobType;
+                                readonly quantiles: VectorType<FloatType>;
+                                readonly n_features: IntegerType;
+                                readonly categorical_features: OptionType<VectorType<IntegerType>>;
+                                readonly categorical_n: OptionType<VectorType<IntegerType>>;
+                            }>;
+                        }>;
+                        readonly lightgbm: VariantType<{
+                            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 histogram: BlobType;
+                    }>;
+                    readonly n_features: IntegerType;
+                    readonly n_classes: IntegerType;
+                    readonly classes: VectorType<IntegerType>;
+                    readonly confidence_level: FloatType;
+                }>;
+            }>;
+        }>;
+        /** Interventional mode: uses background data to break feature correlations */
+        readonly interventional: StructType<{
+            /** Tree-based model blob */
+            readonly model: VariantType<{
+                /** XGBoost regressor */
+                readonly xgboost_regressor: StructType<{
+                    readonly data: BlobType;
+                    readonly n_features: IntegerType;
+                    readonly categorical_features: OptionType<VectorType<IntegerType>>;
+                    readonly categorical_n: OptionType<VectorType<IntegerType>>;
+                }>;
+                /** XGBoost classifier */
+                readonly xgboost_classifier: StructType<{
+                    readonly data: BlobType;
+                    readonly n_features: IntegerType;
+                    readonly n_classes: IntegerType;
+                    readonly categorical_features: OptionType<VectorType<IntegerType>>;
+                    readonly categorical_n: OptionType<VectorType<IntegerType>>;
+                }>;
+                /** XGBoost quantile regressor (uses median quantile for explanations) */
+                readonly xgboost_quantile: StructType<{
+                    readonly data: BlobType;
+                    readonly quantiles: VectorType<FloatType>;
+                    readonly n_features: IntegerType;
+                    readonly categorical_features: OptionType<VectorType<IntegerType>>;
+                    readonly categorical_n: OptionType<VectorType<IntegerType>>;
+                }>;
+                /** MAPIE split conformal regressor with XGBoost base */
+                readonly mapie_split: StructType<{
+                    readonly data: VariantType<{
+                        readonly xgboost: VariantType<{
+                            readonly xgboost_regressor: StructType<{
+                                readonly data: BlobType;
+                                readonly n_features: IntegerType;
+                                readonly categorical_features: OptionType<VectorType<IntegerType>>;
+                                readonly categorical_n: OptionType<VectorType<IntegerType>>;
+                            }>;
+                            readonly xgboost_classifier: StructType<{
+                                readonly data: BlobType;
+                                readonly n_features: IntegerType;
+                                readonly n_classes: IntegerType;
+                                readonly categorical_features: OptionType<VectorType<IntegerType>>;
+                                readonly categorical_n: OptionType<VectorType<IntegerType>>;
+                            }>;
+                            readonly xgboost_quantile: StructType<{
+                                readonly data: BlobType;
+                                readonly quantiles: VectorType<FloatType>;
+                                readonly n_features: IntegerType;
+                                readonly categorical_features: OptionType<VectorType<IntegerType>>;
+                                readonly categorical_n: OptionType<VectorType<IntegerType>>;
+                            }>;
+                        }>;
+                        readonly lightgbm: VariantType<{
+                            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 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: VariantType<{
+                            readonly xgboost_regressor: StructType<{
+                                readonly data: BlobType;
+                                readonly n_features: IntegerType;
+                                readonly categorical_features: OptionType<VectorType<IntegerType>>;
+                                readonly categorical_n: OptionType<VectorType<IntegerType>>;
+                            }>;
+                            readonly xgboost_classifier: StructType<{
+                                readonly data: BlobType;
+                                readonly n_features: IntegerType;
+                                readonly n_classes: IntegerType;
+                                readonly categorical_features: OptionType<VectorType<IntegerType>>;
+                                readonly categorical_n: OptionType<VectorType<IntegerType>>;
+                            }>;
+                            readonly xgboost_quantile: StructType<{
+                                readonly data: BlobType;
+                                readonly quantiles: VectorType<FloatType>;
+                                readonly n_features: IntegerType;
+                                readonly categorical_features: OptionType<VectorType<IntegerType>>;
+                                readonly categorical_n: OptionType<VectorType<IntegerType>>;
+                            }>;
+                        }>;
+                        readonly lightgbm: VariantType<{
+                            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 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: VariantType<{
+                            readonly xgboost_regressor: StructType<{
+                                readonly data: BlobType;
+                                readonly n_features: IntegerType;
+                                readonly categorical_features: OptionType<VectorType<IntegerType>>;
+                                readonly categorical_n: OptionType<VectorType<IntegerType>>;
+                            }>;
+                            readonly xgboost_classifier: StructType<{
+                                readonly data: BlobType;
+                                readonly n_features: IntegerType;
+                                readonly n_classes: IntegerType;
+                                readonly categorical_features: OptionType<VectorType<IntegerType>>;
+                                readonly categorical_n: OptionType<VectorType<IntegerType>>;
+                            }>;
+                            readonly xgboost_quantile: StructType<{
+                                readonly data: BlobType;
+                                readonly quantiles: VectorType<FloatType>;
+                                readonly n_features: IntegerType;
+                                readonly categorical_features: OptionType<VectorType<IntegerType>>;
+                                readonly categorical_n: OptionType<VectorType<IntegerType>>;
+                            }>;
+                        }>;
+                        readonly lightgbm: VariantType<{
+                            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 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: VariantType<{
+                            readonly xgboost_regressor: StructType<{
+                                readonly data: BlobType;
+                                readonly n_features: IntegerType;
+                                readonly categorical_features: OptionType<VectorType<IntegerType>>;
+                                readonly categorical_n: OptionType<VectorType<IntegerType>>;
+                            }>;
+                            readonly xgboost_classifier: StructType<{
+                                readonly data: BlobType;
+                                readonly n_features: IntegerType;
+                                readonly n_classes: IntegerType;
+                                readonly categorical_features: OptionType<VectorType<IntegerType>>;
+                                readonly categorical_n: OptionType<VectorType<IntegerType>>;
+                            }>;
+                            readonly xgboost_quantile: StructType<{
+                                readonly data: BlobType;
+                                readonly quantiles: VectorType<FloatType>;
+                                readonly n_features: IntegerType;
+                                readonly categorical_features: OptionType<VectorType<IntegerType>>;
+                                readonly categorical_n: OptionType<VectorType<IntegerType>>;
+                            }>;
+                        }>;
+                        readonly lightgbm: VariantType<{
+                            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 histogram: BlobType;
+                    }>;
+                    readonly n_features: IntegerType;
+                    readonly n_classes: IntegerType;
+                    readonly classes: VectorType<IntegerType>;
+                    readonly confidence_level: FloatType;
+                }>;
+            }>;
+            /** Background data for computing interventional expectations */
+            readonly background: MatrixType<FloatType>;
+        }>;
+    }>;
+    /** Any model blob type for kernel explainer */
+    readonly AnyModelBlobType: VariantType<{
+        readonly xgboost_regressor: StructType<{
             readonly data: BlobType;
             readonly n_features: IntegerType;
+            readonly categorical_features: OptionType<VectorType<IntegerType>>;
+            readonly categorical_n: OptionType<VectorType<IntegerType>>;
         }>;
-        readonly mapie_set_size: StructType<{
+        readonly xgboost_classifier: StructType<{
+            readonly data: BlobType;
+            readonly n_features: IntegerType;
+            readonly n_classes: IntegerType;
+            readonly categorical_features: OptionType<VectorType<IntegerType>>;
+            readonly categorical_n: OptionType<VectorType<IntegerType>>;
+        }>;
+        readonly xgboost_quantile: StructType<{
             readonly data: BlobType;
+            readonly quantiles: VectorType<FloatType>;
             readonly n_features: IntegerType;
+            readonly categorical_features: OptionType<VectorType<IntegerType>>;
+            readonly categorical_n: OptionType<VectorType<IntegerType>>;
         }>;
-    }>;
-};
-/**
- * SHAP explainability functions.
- *
- * Provides model-agnostic feature importance and SHAP value computation.
- *
- * @example
- * ```ts
- * import { East, variant } from "@elaraai/east";
- * import { Shap, LightGBM } from "@elaraai/east-py-datascience";
- *
- * const explain = East.function([LightGBM.Types.ModelBlobType, Shap.Types.MatrixType(FloatType)], Shap.Types.ShapResultType, ($, model, X) => {
- *     // Create explainer
- *     const explainer = $.let(Shap.treeExplainerCreate(model));
- *
- *     // Compute SHAP values
- *     const feature_names = $.let(["feature1", "feature2"]);
- *     const result = $.let(Shap.computeValues(explainer, X, feature_names));
- *
- *     return $.return(result);
- * });
- * ```
- */
-export declare const Shap: {
-    /**
-     * Create a SHAP TreeExplainer for tree-based models (XGBoost, LightGBM).
-     *
-     * @example
-     * ```ts
-     * import { East, FloatType, MatrixType } from "@elaraai/east";
-     * import { Shap, XGBoost } from "@elaraai/east-py-datascience";
-     *
-     * const explain = East.function(
-     *     [XGBoost.Types.ModelBlobType],
-     *     Shap.Types.ShapModelBlobType,
-     *     ($, model) => {
-     *         return $.return(Shap.treeExplainerCreate(model));
-     *     }
-     * );
-     * ```
-     */
-    readonly treeExplainerCreate: import("@elaraai/east").PlatformDefinition<[VariantType<{
-        /** XGBoost regressor */
-        readonly xgboost_regressor: StructType<{
+        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 categorical_features: OptionType<VectorType<IntegerType>>;
-            readonly categorical_n: OptionType<VectorType<IntegerType>>;
+            readonly kernel_type: StringType;
         }>;
-        /** XGBoost classifier */
-        readonly xgboost_classifier: StructType<{
+        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 robust_scaler: StructType<{
+            readonly onnx: BlobType;
+            readonly n_features: IntegerType;
+        }>;
+        readonly label_encoder: StructType<{
+            readonly data: BlobType;
             readonly n_classes: IntegerType;
-            readonly categorical_features: OptionType<VectorType<IntegerType>>;
-            readonly categorical_n: OptionType<VectorType<IntegerType>>;
         }>;
-        /** XGBoost quantile regressor (uses median quantile for explanations) */
-        readonly xgboost_quantile: StructType<{
+        readonly ordinal_encoder: StructType<{
             readonly data: BlobType;
-            readonly quantiles: VectorType<FloatType>;
             readonly n_features: IntegerType;
-            readonly categorical_features: OptionType<VectorType<IntegerType>>;
-            readonly categorical_n: OptionType<VectorType<IntegerType>>;
         }>;
-        /** MAPIE split conformal regressor with XGBoost base */
+        readonly gaussian_mixture: StructType<{
+            readonly data: BlobType;
+            readonly n_features: IntegerType;
+            readonly n_components: 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: VariantType<{
@@ -1963,7 +2732,6 @@ export declare const Shap: {
             readonly n_features: IntegerType;
             readonly confidence_level: FloatType;
         }>;
-        /** MAPIE cross conformal regressor with XGBoost base */
         readonly mapie_cross: StructType<{
             readonly data: VariantType<{
                 readonly xgboost: VariantType<{
@@ -2004,7 +2772,6 @@ export declare const Shap: {
             readonly n_features: IntegerType;
             readonly confidence_level: FloatType;
         }>;
-        /** MAPIE CQR conformal regressor with XGBoost base */
         readonly mapie_cqr: StructType<{
             readonly data: VariantType<{
                 readonly xgboost: VariantType<{
@@ -2045,7 +2812,6 @@ export declare const Shap: {
             readonly n_features: IntegerType;
             readonly confidence_level: FloatType;
         }>;
-        /** MAPIE conformal classifier with XGBoost base */
         readonly mapie_classifier: StructType<{
             readonly data: VariantType<{
                 readonly xgboost: VariantType<{
@@ -2088,6 +2854,468 @@ export declare const Shap: {
             readonly classes: VectorType<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;
+        }>;
+    }>;
+};
+/**
+ * SHAP explainability functions.
+ *
+ * Provides model-agnostic feature importance and SHAP value computation.
+ *
+ * @example
+ * ```ts
+ * import { East, variant } from "@elaraai/east";
+ * import { Shap, LightGBM } from "@elaraai/east-py-datascience";
+ *
+ * const explain = East.function([LightGBM.Types.ModelBlobType, Shap.Types.MatrixType(FloatType)], Shap.Types.ShapResultType, ($, model, X) => {
+ *     // Create explainer
+ *     const explainer = $.let(Shap.treeExplainerCreate(model));
+ *
+ *     // Compute SHAP values
+ *     const feature_names = $.let(["feature1", "feature2"]);
+ *     const result = $.let(Shap.computeValues(explainer, X, feature_names));
+ *
+ *     return $.return(result);
+ * });
+ * ```
+ */
+export declare const Shap: {
+    /**
+     * Create a SHAP TreeExplainer for tree-based models (XGBoost, LightGBM).
+     *
+     * Two modes:
+     * - `path_dependent`: Uses tree split paths. Tells you how the tree used features.
+     * - `interventional`: Uses background data to break correlations. Tells you how
+     *   changing a feature would change the prediction.
+     *
+     * @example
+     * ```ts
+     * import { East, FloatType, variant } from "@elaraai/east";
+     * import { Shap, XGBoost } from "@elaraai/east-py-datascience";
+     *
+     * // Path-dependent mode (default SHAP behavior)
+     * const explainPD = East.function(
+     *     [XGBoost.Types.ModelBlobType],
+     *     Shap.Types.ShapModelBlobType,
+     *     ($, model) => {
+     *         return $.return(Shap.treeExplainerCreate(
+     *             variant('path_dependent', { model })
+     *         ));
+     *     }
+     * );
+     *
+     * // Interventional mode (causal, uses background data)
+     * const explainIV = East.function(
+     *     [XGBoost.Types.ModelBlobType, Shap.Types.MatrixType(FloatType)],
+     *     Shap.Types.ShapModelBlobType,
+     *     ($, model, background) => {
+     *         return $.return(Shap.treeExplainerCreate(
+     *             variant('interventional', { model, background })
+     *         ));
+     *     }
+     * );
+     * ```
+     */
+    readonly treeExplainerCreate: import("@elaraai/east").PlatformDefinition<[VariantType<{
+        /** Path-dependent mode: uses tree structure only (default SHAP behavior) */
+        readonly path_dependent: StructType<{
+            /** Tree-based model blob */
+            readonly model: VariantType<{
+                /** XGBoost regressor */
+                readonly xgboost_regressor: StructType<{
+                    readonly data: BlobType;
+                    readonly n_features: IntegerType;
+                    readonly categorical_features: OptionType<VectorType<IntegerType>>;
+                    readonly categorical_n: OptionType<VectorType<IntegerType>>;
+                }>;
+                /** XGBoost classifier */
+                readonly xgboost_classifier: StructType<{
+                    readonly data: BlobType;
+                    readonly n_features: IntegerType;
+                    readonly n_classes: IntegerType;
+                    readonly categorical_features: OptionType<VectorType<IntegerType>>;
+                    readonly categorical_n: OptionType<VectorType<IntegerType>>;
+                }>;
+                /** XGBoost quantile regressor (uses median quantile for explanations) */
+                readonly xgboost_quantile: StructType<{
+                    readonly data: BlobType;
+                    readonly quantiles: VectorType<FloatType>;
+                    readonly n_features: IntegerType;
+                    readonly categorical_features: OptionType<VectorType<IntegerType>>;
+                    readonly categorical_n: OptionType<VectorType<IntegerType>>;
+                }>;
+                /** MAPIE split conformal regressor with XGBoost base */
+                readonly mapie_split: StructType<{
+                    readonly data: VariantType<{
+                        readonly xgboost: VariantType<{
+                            readonly xgboost_regressor: StructType<{
+                                readonly data: BlobType;
+                                readonly n_features: IntegerType;
+                                readonly categorical_features: OptionType<VectorType<IntegerType>>;
+                                readonly categorical_n: OptionType<VectorType<IntegerType>>;
+                            }>;
+                            readonly xgboost_classifier: StructType<{
+                                readonly data: BlobType;
+                                readonly n_features: IntegerType;
+                                readonly n_classes: IntegerType;
+                                readonly categorical_features: OptionType<VectorType<IntegerType>>;
+                                readonly categorical_n: OptionType<VectorType<IntegerType>>;
+                            }>;
+                            readonly xgboost_quantile: StructType<{
+                                readonly data: BlobType;
+                                readonly quantiles: VectorType<FloatType>;
+                                readonly n_features: IntegerType;
+                                readonly categorical_features: OptionType<VectorType<IntegerType>>;
+                                readonly categorical_n: OptionType<VectorType<IntegerType>>;
+                            }>;
+                        }>;
+                        readonly lightgbm: VariantType<{
+                            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 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: VariantType<{
+                            readonly xgboost_regressor: StructType<{
+                                readonly data: BlobType;
+                                readonly n_features: IntegerType;
+                                readonly categorical_features: OptionType<VectorType<IntegerType>>;
+                                readonly categorical_n: OptionType<VectorType<IntegerType>>;
+                            }>;
+                            readonly xgboost_classifier: StructType<{
+                                readonly data: BlobType;
+                                readonly n_features: IntegerType;
+                                readonly n_classes: IntegerType;
+                                readonly categorical_features: OptionType<VectorType<IntegerType>>;
+                                readonly categorical_n: OptionType<VectorType<IntegerType>>;
+                            }>;
+                            readonly xgboost_quantile: StructType<{
+                                readonly data: BlobType;
+                                readonly quantiles: VectorType<FloatType>;
+                                readonly n_features: IntegerType;
+                                readonly categorical_features: OptionType<VectorType<IntegerType>>;
+                                readonly categorical_n: OptionType<VectorType<IntegerType>>;
+                            }>;
+                        }>;
+                        readonly lightgbm: VariantType<{
+                            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 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: VariantType<{
+                            readonly xgboost_regressor: StructType<{
+                                readonly data: BlobType;
+                                readonly n_features: IntegerType;
+                                readonly categorical_features: OptionType<VectorType<IntegerType>>;
+                                readonly categorical_n: OptionType<VectorType<IntegerType>>;
+                            }>;
+                            readonly xgboost_classifier: StructType<{
+                                readonly data: BlobType;
+                                readonly n_features: IntegerType;
+                                readonly n_classes: IntegerType;
+                                readonly categorical_features: OptionType<VectorType<IntegerType>>;
+                                readonly categorical_n: OptionType<VectorType<IntegerType>>;
+                            }>;
+                            readonly xgboost_quantile: StructType<{
+                                readonly data: BlobType;
+                                readonly quantiles: VectorType<FloatType>;
+                                readonly n_features: IntegerType;
+                                readonly categorical_features: OptionType<VectorType<IntegerType>>;
+                                readonly categorical_n: OptionType<VectorType<IntegerType>>;
+                            }>;
+                        }>;
+                        readonly lightgbm: VariantType<{
+                            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 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: VariantType<{
+                            readonly xgboost_regressor: StructType<{
+                                readonly data: BlobType;
+                                readonly n_features: IntegerType;
+                                readonly categorical_features: OptionType<VectorType<IntegerType>>;
+                                readonly categorical_n: OptionType<VectorType<IntegerType>>;
+                            }>;
+                            readonly xgboost_classifier: StructType<{
+                                readonly data: BlobType;
+                                readonly n_features: IntegerType;
+                                readonly n_classes: IntegerType;
+                                readonly categorical_features: OptionType<VectorType<IntegerType>>;
+                                readonly categorical_n: OptionType<VectorType<IntegerType>>;
+                            }>;
+                            readonly xgboost_quantile: StructType<{
+                                readonly data: BlobType;
+                                readonly quantiles: VectorType<FloatType>;
+                                readonly n_features: IntegerType;
+                                readonly categorical_features: OptionType<VectorType<IntegerType>>;
+                                readonly categorical_n: OptionType<VectorType<IntegerType>>;
+                            }>;
+                        }>;
+                        readonly lightgbm: VariantType<{
+                            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 histogram: BlobType;
+                    }>;
+                    readonly n_features: IntegerType;
+                    readonly n_classes: IntegerType;
+                    readonly classes: VectorType<IntegerType>;
+                    readonly confidence_level: FloatType;
+                }>;
+            }>;
+        }>;
+        /** Interventional mode: uses background data to break feature correlations */
+        readonly interventional: StructType<{
+            /** Tree-based model blob */
+            readonly model: VariantType<{
+                /** XGBoost regressor */
+                readonly xgboost_regressor: StructType<{
+                    readonly data: BlobType;
+                    readonly n_features: IntegerType;
+                    readonly categorical_features: OptionType<VectorType<IntegerType>>;
+                    readonly categorical_n: OptionType<VectorType<IntegerType>>;
+                }>;
+                /** XGBoost classifier */
+                readonly xgboost_classifier: StructType<{
+                    readonly data: BlobType;
+                    readonly n_features: IntegerType;
+                    readonly n_classes: IntegerType;
+                    readonly categorical_features: OptionType<VectorType<IntegerType>>;
+                    readonly categorical_n: OptionType<VectorType<IntegerType>>;
+                }>;
+                /** XGBoost quantile regressor (uses median quantile for explanations) */
+                readonly xgboost_quantile: StructType<{
+                    readonly data: BlobType;
+                    readonly quantiles: VectorType<FloatType>;
+                    readonly n_features: IntegerType;
+                    readonly categorical_features: OptionType<VectorType<IntegerType>>;
+                    readonly categorical_n: OptionType<VectorType<IntegerType>>;
+                }>;
+                /** MAPIE split conformal regressor with XGBoost base */
+                readonly mapie_split: StructType<{
+                    readonly data: VariantType<{
+                        readonly xgboost: VariantType<{
+                            readonly xgboost_regressor: StructType<{
+                                readonly data: BlobType;
+                                readonly n_features: IntegerType;
+                                readonly categorical_features: OptionType<VectorType<IntegerType>>;
+                                readonly categorical_n: OptionType<VectorType<IntegerType>>;
+                            }>;
+                            readonly xgboost_classifier: StructType<{
+                                readonly data: BlobType;
+                                readonly n_features: IntegerType;
+                                readonly n_classes: IntegerType;
+                                readonly categorical_features: OptionType<VectorType<IntegerType>>;
+                                readonly categorical_n: OptionType<VectorType<IntegerType>>;
+                            }>;
+                            readonly xgboost_quantile: StructType<{
+                                readonly data: BlobType;
+                                readonly quantiles: VectorType<FloatType>;
+                                readonly n_features: IntegerType;
+                                readonly categorical_features: OptionType<VectorType<IntegerType>>;
+                                readonly categorical_n: OptionType<VectorType<IntegerType>>;
+                            }>;
+                        }>;
+                        readonly lightgbm: VariantType<{
+                            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 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: VariantType<{
+                            readonly xgboost_regressor: StructType<{
+                                readonly data: BlobType;
+                                readonly n_features: IntegerType;
+                                readonly categorical_features: OptionType<VectorType<IntegerType>>;
+                                readonly categorical_n: OptionType<VectorType<IntegerType>>;
+                            }>;
+                            readonly xgboost_classifier: StructType<{
+                                readonly data: BlobType;
+                                readonly n_features: IntegerType;
+                                readonly n_classes: IntegerType;
+                                readonly categorical_features: OptionType<VectorType<IntegerType>>;
+                                readonly categorical_n: OptionType<VectorType<IntegerType>>;
+                            }>;
+                            readonly xgboost_quantile: StructType<{
+                                readonly data: BlobType;
+                                readonly quantiles: VectorType<FloatType>;
+                                readonly n_features: IntegerType;
+                                readonly categorical_features: OptionType<VectorType<IntegerType>>;
+                                readonly categorical_n: OptionType<VectorType<IntegerType>>;
+                            }>;
+                        }>;
+                        readonly lightgbm: VariantType<{
+                            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 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: VariantType<{
+                            readonly xgboost_regressor: StructType<{
+                                readonly data: BlobType;
+                                readonly n_features: IntegerType;
+                                readonly categorical_features: OptionType<VectorType<IntegerType>>;
+                                readonly categorical_n: OptionType<VectorType<IntegerType>>;
+                            }>;
+                            readonly xgboost_classifier: StructType<{
+                                readonly data: BlobType;
+                                readonly n_features: IntegerType;
+                                readonly n_classes: IntegerType;
+                                readonly categorical_features: OptionType<VectorType<IntegerType>>;
+                                readonly categorical_n: OptionType<VectorType<IntegerType>>;
+                            }>;
+                            readonly xgboost_quantile: StructType<{
+                                readonly data: BlobType;
+                                readonly quantiles: VectorType<FloatType>;
+                                readonly n_features: IntegerType;
+                                readonly categorical_features: OptionType<VectorType<IntegerType>>;
+                                readonly categorical_n: OptionType<VectorType<IntegerType>>;
+                            }>;
+                        }>;
+                        readonly lightgbm: VariantType<{
+                            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 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: VariantType<{
+                            readonly xgboost_regressor: StructType<{
+                                readonly data: BlobType;
+                                readonly n_features: IntegerType;
+                                readonly categorical_features: OptionType<VectorType<IntegerType>>;
+                                readonly categorical_n: OptionType<VectorType<IntegerType>>;
+                            }>;
+                            readonly xgboost_classifier: StructType<{
+                                readonly data: BlobType;
+                                readonly n_features: IntegerType;
+                                readonly n_classes: IntegerType;
+                                readonly categorical_features: OptionType<VectorType<IntegerType>>;
+                                readonly categorical_n: OptionType<VectorType<IntegerType>>;
+                            }>;
+                            readonly xgboost_quantile: StructType<{
+                                readonly data: BlobType;
+                                readonly quantiles: VectorType<FloatType>;
+                                readonly n_features: IntegerType;
+                                readonly categorical_features: OptionType<VectorType<IntegerType>>;
+                                readonly categorical_n: OptionType<VectorType<IntegerType>>;
+                            }>;
+                        }>;
+                        readonly lightgbm: VariantType<{
+                            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 histogram: BlobType;
+                    }>;
+                    readonly n_features: IntegerType;
+                    readonly n_classes: IntegerType;
+                    readonly classes: VectorType<IntegerType>;
+                    readonly confidence_level: FloatType;
+                }>;
+            }>;
+            /** Background data for computing interventional expectations */
+            readonly background: MatrixType<FloatType>;
+        }>;
     }>], VariantType<{
         /** SHAP TreeExplainer for tree-based models */
         readonly shap_tree_explainer: StructType<{
@@ -2731,6 +3959,401 @@ export declare const Shap: {
                 readonly confidence_level: FloatType;
             }>;
         }>;
+        /** TreeExplainer configuration type (path_dependent | interventional) */
+        readonly TreeExplainerConfigType: VariantType<{
+            /** Path-dependent mode: uses tree structure only (default SHAP behavior) */
+            readonly path_dependent: StructType<{
+                /** Tree-based model blob */
+                readonly model: VariantType<{
+                    /** XGBoost regressor */
+                    readonly xgboost_regressor: StructType<{
+                        readonly data: BlobType;
+                        readonly n_features: IntegerType;
+                        readonly categorical_features: OptionType<VectorType<IntegerType>>;
+                        readonly categorical_n: OptionType<VectorType<IntegerType>>;
+                    }>;
+                    /** XGBoost classifier */
+                    readonly xgboost_classifier: StructType<{
+                        readonly data: BlobType;
+                        readonly n_features: IntegerType;
+                        readonly n_classes: IntegerType;
+                        readonly categorical_features: OptionType<VectorType<IntegerType>>;
+                        readonly categorical_n: OptionType<VectorType<IntegerType>>;
+                    }>;
+                    /** XGBoost quantile regressor (uses median quantile for explanations) */
+                    readonly xgboost_quantile: StructType<{
+                        readonly data: BlobType;
+                        readonly quantiles: VectorType<FloatType>;
+                        readonly n_features: IntegerType;
+                        readonly categorical_features: OptionType<VectorType<IntegerType>>;
+                        readonly categorical_n: OptionType<VectorType<IntegerType>>;
+                    }>;
+                    /** MAPIE split conformal regressor with XGBoost base */
+                    readonly mapie_split: StructType<{
+                        readonly data: VariantType<{
+                            readonly xgboost: VariantType<{
+                                readonly xgboost_regressor: StructType<{
+                                    readonly data: BlobType;
+                                    readonly n_features: IntegerType;
+                                    readonly categorical_features: OptionType<VectorType<IntegerType>>;
+                                    readonly categorical_n: OptionType<VectorType<IntegerType>>;
+                                }>;
+                                readonly xgboost_classifier: StructType<{
+                                    readonly data: BlobType;
+                                    readonly n_features: IntegerType;
+                                    readonly n_classes: IntegerType;
+                                    readonly categorical_features: OptionType<VectorType<IntegerType>>;
+                                    readonly categorical_n: OptionType<VectorType<IntegerType>>;
+                                }>;
+                                readonly xgboost_quantile: StructType<{
+                                    readonly data: BlobType;
+                                    readonly quantiles: VectorType<FloatType>;
+                                    readonly n_features: IntegerType;
+                                    readonly categorical_features: OptionType<VectorType<IntegerType>>;
+                                    readonly categorical_n: OptionType<VectorType<IntegerType>>;
+                                }>;
+                            }>;
+                            readonly lightgbm: VariantType<{
+                                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 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: VariantType<{
+                                readonly xgboost_regressor: StructType<{
+                                    readonly data: BlobType;
+                                    readonly n_features: IntegerType;
+                                    readonly categorical_features: OptionType<VectorType<IntegerType>>;
+                                    readonly categorical_n: OptionType<VectorType<IntegerType>>;
+                                }>;
+                                readonly xgboost_classifier: StructType<{
+                                    readonly data: BlobType;
+                                    readonly n_features: IntegerType;
+                                    readonly n_classes: IntegerType;
+                                    readonly categorical_features: OptionType<VectorType<IntegerType>>;
+                                    readonly categorical_n: OptionType<VectorType<IntegerType>>;
+                                }>;
+                                readonly xgboost_quantile: StructType<{
+                                    readonly data: BlobType;
+                                    readonly quantiles: VectorType<FloatType>;
+                                    readonly n_features: IntegerType;
+                                    readonly categorical_features: OptionType<VectorType<IntegerType>>;
+                                    readonly categorical_n: OptionType<VectorType<IntegerType>>;
+                                }>;
+                            }>;
+                            readonly lightgbm: VariantType<{
+                                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 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: VariantType<{
+                                readonly xgboost_regressor: StructType<{
+                                    readonly data: BlobType;
+                                    readonly n_features: IntegerType;
+                                    readonly categorical_features: OptionType<VectorType<IntegerType>>;
+                                    readonly categorical_n: OptionType<VectorType<IntegerType>>;
+                                }>;
+                                readonly xgboost_classifier: StructType<{
+                                    readonly data: BlobType;
+                                    readonly n_features: IntegerType;
+                                    readonly n_classes: IntegerType;
+                                    readonly categorical_features: OptionType<VectorType<IntegerType>>;
+                                    readonly categorical_n: OptionType<VectorType<IntegerType>>;
+                                }>;
+                                readonly xgboost_quantile: StructType<{
+                                    readonly data: BlobType;
+                                    readonly quantiles: VectorType<FloatType>;
+                                    readonly n_features: IntegerType;
+                                    readonly categorical_features: OptionType<VectorType<IntegerType>>;
+                                    readonly categorical_n: OptionType<VectorType<IntegerType>>;
+                                }>;
+                            }>;
+                            readonly lightgbm: VariantType<{
+                                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 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: VariantType<{
+                                readonly xgboost_regressor: StructType<{
+                                    readonly data: BlobType;
+                                    readonly n_features: IntegerType;
+                                    readonly categorical_features: OptionType<VectorType<IntegerType>>;
+                                    readonly categorical_n: OptionType<VectorType<IntegerType>>;
+                                }>;
+                                readonly xgboost_classifier: StructType<{
+                                    readonly data: BlobType;
+                                    readonly n_features: IntegerType;
+                                    readonly n_classes: IntegerType;
+                                    readonly categorical_features: OptionType<VectorType<IntegerType>>;
+                                    readonly categorical_n: OptionType<VectorType<IntegerType>>;
+                                }>;
+                                readonly xgboost_quantile: StructType<{
+                                    readonly data: BlobType;
+                                    readonly quantiles: VectorType<FloatType>;
+                                    readonly n_features: IntegerType;
+                                    readonly categorical_features: OptionType<VectorType<IntegerType>>;
+                                    readonly categorical_n: OptionType<VectorType<IntegerType>>;
+                                }>;
+                            }>;
+                            readonly lightgbm: VariantType<{
+                                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 histogram: BlobType;
+                        }>;
+                        readonly n_features: IntegerType;
+                        readonly n_classes: IntegerType;
+                        readonly classes: VectorType<IntegerType>;
+                        readonly confidence_level: FloatType;
+                    }>;
+                }>;
+            }>;
+            /** Interventional mode: uses background data to break feature correlations */
+            readonly interventional: StructType<{
+                /** Tree-based model blob */
+                readonly model: VariantType<{
+                    /** XGBoost regressor */
+                    readonly xgboost_regressor: StructType<{
+                        readonly data: BlobType;
+                        readonly n_features: IntegerType;
+                        readonly categorical_features: OptionType<VectorType<IntegerType>>;
+                        readonly categorical_n: OptionType<VectorType<IntegerType>>;
+                    }>;
+                    /** XGBoost classifier */
+                    readonly xgboost_classifier: StructType<{
+                        readonly data: BlobType;
+                        readonly n_features: IntegerType;
+                        readonly n_classes: IntegerType;
+                        readonly categorical_features: OptionType<VectorType<IntegerType>>;
+                        readonly categorical_n: OptionType<VectorType<IntegerType>>;
+                    }>;
+                    /** XGBoost quantile regressor (uses median quantile for explanations) */
+                    readonly xgboost_quantile: StructType<{
+                        readonly data: BlobType;
+                        readonly quantiles: VectorType<FloatType>;
+                        readonly n_features: IntegerType;
+                        readonly categorical_features: OptionType<VectorType<IntegerType>>;
+                        readonly categorical_n: OptionType<VectorType<IntegerType>>;
+                    }>;
+                    /** MAPIE split conformal regressor with XGBoost base */
+                    readonly mapie_split: StructType<{
+                        readonly data: VariantType<{
+                            readonly xgboost: VariantType<{
+                                readonly xgboost_regressor: StructType<{
+                                    readonly data: BlobType;
+                                    readonly n_features: IntegerType;
+                                    readonly categorical_features: OptionType<VectorType<IntegerType>>;
+                                    readonly categorical_n: OptionType<VectorType<IntegerType>>;
+                                }>;
+                                readonly xgboost_classifier: StructType<{
+                                    readonly data: BlobType;
+                                    readonly n_features: IntegerType;
+                                    readonly n_classes: IntegerType;
+                                    readonly categorical_features: OptionType<VectorType<IntegerType>>;
+                                    readonly categorical_n: OptionType<VectorType<IntegerType>>;
+                                }>;
+                                readonly xgboost_quantile: StructType<{
+                                    readonly data: BlobType;
+                                    readonly quantiles: VectorType<FloatType>;
+                                    readonly n_features: IntegerType;
+                                    readonly categorical_features: OptionType<VectorType<IntegerType>>;
+                                    readonly categorical_n: OptionType<VectorType<IntegerType>>;
+                                }>;
+                            }>;
+                            readonly lightgbm: VariantType<{
+                                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 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: VariantType<{
+                                readonly xgboost_regressor: StructType<{
+                                    readonly data: BlobType;
+                                    readonly n_features: IntegerType;
+                                    readonly categorical_features: OptionType<VectorType<IntegerType>>;
+                                    readonly categorical_n: OptionType<VectorType<IntegerType>>;
+                                }>;
+                                readonly xgboost_classifier: StructType<{
+                                    readonly data: BlobType;
+                                    readonly n_features: IntegerType;
+                                    readonly n_classes: IntegerType;
+                                    readonly categorical_features: OptionType<VectorType<IntegerType>>;
+                                    readonly categorical_n: OptionType<VectorType<IntegerType>>;
+                                }>;
+                                readonly xgboost_quantile: StructType<{
+                                    readonly data: BlobType;
+                                    readonly quantiles: VectorType<FloatType>;
+                                    readonly n_features: IntegerType;
+                                    readonly categorical_features: OptionType<VectorType<IntegerType>>;
+                                    readonly categorical_n: OptionType<VectorType<IntegerType>>;
+                                }>;
+                            }>;
+                            readonly lightgbm: VariantType<{
+                                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 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: VariantType<{
+                                readonly xgboost_regressor: StructType<{
+                                    readonly data: BlobType;
+                                    readonly n_features: IntegerType;
+                                    readonly categorical_features: OptionType<VectorType<IntegerType>>;
+                                    readonly categorical_n: OptionType<VectorType<IntegerType>>;
+                                }>;
+                                readonly xgboost_classifier: StructType<{
+                                    readonly data: BlobType;
+                                    readonly n_features: IntegerType;
+                                    readonly n_classes: IntegerType;
+                                    readonly categorical_features: OptionType<VectorType<IntegerType>>;
+                                    readonly categorical_n: OptionType<VectorType<IntegerType>>;
+                                }>;
+                                readonly xgboost_quantile: StructType<{
+                                    readonly data: BlobType;
+                                    readonly quantiles: VectorType<FloatType>;
+                                    readonly n_features: IntegerType;
+                                    readonly categorical_features: OptionType<VectorType<IntegerType>>;
+                                    readonly categorical_n: OptionType<VectorType<IntegerType>>;
+                                }>;
+                            }>;
+                            readonly lightgbm: VariantType<{
+                                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 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: VariantType<{
+                                readonly xgboost_regressor: StructType<{
+                                    readonly data: BlobType;
+                                    readonly n_features: IntegerType;
+                                    readonly categorical_features: OptionType<VectorType<IntegerType>>;
+                                    readonly categorical_n: OptionType<VectorType<IntegerType>>;
+                                }>;
+                                readonly xgboost_classifier: StructType<{
+                                    readonly data: BlobType;
+                                    readonly n_features: IntegerType;
+                                    readonly n_classes: IntegerType;
+                                    readonly categorical_features: OptionType<VectorType<IntegerType>>;
+                                    readonly categorical_n: OptionType<VectorType<IntegerType>>;
+                                }>;
+                                readonly xgboost_quantile: StructType<{
+                                    readonly data: BlobType;
+                                    readonly quantiles: VectorType<FloatType>;
+                                    readonly n_features: IntegerType;
+                                    readonly categorical_features: OptionType<VectorType<IntegerType>>;
+                                    readonly categorical_n: OptionType<VectorType<IntegerType>>;
+                                }>;
+                            }>;
+                            readonly lightgbm: VariantType<{
+                                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 histogram: BlobType;
+                        }>;
+                        readonly n_features: IntegerType;
+                        readonly n_classes: IntegerType;
+                        readonly classes: VectorType<IntegerType>;
+                        readonly confidence_level: FloatType;
+                    }>;
+                }>;
+                /** Background data for computing interventional expectations */
+                readonly background: MatrixType<FloatType>;
+            }>;
+        }>;
         /** Any model blob type for kernel explainer */
         readonly AnyModelBlobType: VariantType<{
             readonly xgboost_regressor: StructType<{