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

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

@@ -0,0 +1,2988 @@
+/**
+ * Copyright (c) 2025 Elara AI Pty Ltd
+ * Dual-licensed under AGPL-3.0 and commercial license. See LICENSE for details.
+ */
+/**
+ * SHAP platform functions for East.
+ *
+ * Provides model-agnostic feature importance and explainability using SHAP values.
+ * Uses cloudpickle for explainer serialization.
+ *
+ * @packageDocumentation
+ */
+import { StructType, VariantType, OptionType, IntegerType, FloatType, StringType, ArrayType, BlobType, NullType } from "@elaraai/east";
+import { VectorType, MatrixType } from "../types.js";
+export { VectorType, MatrixType } from "../types.js";
+/** String vector type for feature names */
+export declare const StringVectorType: ArrayType<StringType>;
+/**
+ * SHAP values type - variant for 2D (regression/binary) or 3D (multi-class).
+ */
+export declare const ShapValuesType: VariantType<{
+    /** 2D matrix for regression or binary classification (n_samples x n_features) */
+    readonly matrix_2d: MatrixType<FloatType>;
+    /** 3D tensor for multi-class classification (n_samples x n_features x n_classes) */
+    readonly tensor_3d: ArrayType<MatrixType<FloatType>>;
+}>;
+/**
+ * Base value type - variant for single (regression/binary) or per-class (multi-class).
+ */
+export declare const ShapBaseValueType: VariantType<{
+    /** Single base value for regression or binary classification */
+    readonly single: FloatType;
+    /** Per-class base values for multi-class classification */
+    readonly per_class: VectorType<FloatType>;
+}>;
+/**
+ * Result type for SHAP value computation.
+ */
+export declare const ShapResultType: StructType<{
+    /** SHAP values - 2D matrix or 3D tensor depending on model type */
+    readonly shap_values: VariantType<{
+        /** 2D matrix for regression or binary classification (n_samples x n_features) */
+        readonly matrix_2d: MatrixType<FloatType>;
+        /** 3D tensor for multi-class classification (n_samples x n_features x n_classes) */
+        readonly tensor_3d: ArrayType<MatrixType<FloatType>>;
+    }>;
+    /** Base value(s) - single float or per-class array */
+    readonly base_value: VariantType<{
+        /** Single base value for regression or binary classification */
+        readonly single: FloatType;
+        /** Per-class base values for multi-class classification */
+        readonly per_class: VectorType<FloatType>;
+    }>;
+    /** Feature names */
+    readonly feature_names: ArrayType<StringType>;
+}>;
+/**
+ * Result type for feature importance.
+ */
+export declare const 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>>;
+}>;
+/**
+ * Model blob type for serialized SHAP explainers.
+ */
+export declare const 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-based model blob type - accepts XGBoost models and MAPIE wrappers with XGBoost.
+ * Note: LightGBM is not supported for TreeExplainer due to SHAP compatibility issues.
+ * Use KernelExplainer for LightGBM models.
+ */
+export declare const TreeModelBlobType: VariantType<{
+    /** XGBoost regressor */
+    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;
+    }>;
+}>;
+/**
+ * Any model blob type - accepts any model for kernel explainer.
+ * Includes all tree-based models plus NGBoost, GP, Torch, and sklearn models.
+ */
+export declare const 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 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_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;
+    }>;
+    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 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 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;
+    }>;
+    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 mapie_interval_width: StructType<{
+        readonly data: BlobType;
+        readonly n_features: IntegerType;
+    }>;
+    readonly mapie_set_size: StructType<{
+        readonly data: BlobType;
+        readonly n_features: IntegerType;
+    }>;
+}>;
+export { MAPIEBaseModelDataType } from "../mapie/mapie.js";
+/**
+ * MAPIE regressor model blob type for SHAP.
+ * Accepts split, cross, or CQR conformal regressors.
+ * Must match MAPIERegressorBlobType from mapie.ts.
+ */
+export declare const MAPIERegressorBlobType: VariantType<{
+    readonly mapie_split: StructType<{
+        readonly data: VariantType<{
+            readonly xgboost: 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 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 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 classifier model blob type for SHAP.
+ * Must match MAPIEClassifierBlobType from mapie.ts.
+ */
+export declare const MAPIEClassifierBlobType: 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;
+}>;
+/**
+ * SHAP result for MAPIE regressors.
+ * Contains explanations for both point prediction and uncertainty (interval width).
+ */
+export declare const MapieRegressorShapResultType: StructType<{
+    /** SHAP values for point prediction (what drives the predicted value) */
+    readonly point_prediction: StructType<{
+        /** SHAP values - 2D matrix or 3D tensor depending on model type */
+        readonly shap_values: VariantType<{
+            /** 2D matrix for regression or binary classification (n_samples x n_features) */
+            readonly matrix_2d: MatrixType<FloatType>;
+            /** 3D tensor for multi-class classification (n_samples x n_features x n_classes) */
+            readonly tensor_3d: ArrayType<MatrixType<FloatType>>;
+        }>;
+        /** Base value(s) - single float or per-class array */
+        readonly base_value: VariantType<{
+            /** Single base value for regression or binary classification */
+            readonly single: FloatType;
+            /** Per-class base values for multi-class classification */
+            readonly per_class: VectorType<FloatType>;
+        }>;
+        /** Feature names */
+        readonly feature_names: ArrayType<StringType>;
+    }>;
+    /** SHAP values for interval width (what drives uncertainty) */
+    readonly interval_width: StructType<{
+        /** SHAP values - 2D matrix or 3D tensor depending on model type */
+        readonly shap_values: VariantType<{
+            /** 2D matrix for regression or binary classification (n_samples x n_features) */
+            readonly matrix_2d: MatrixType<FloatType>;
+            /** 3D tensor for multi-class classification (n_samples x n_features x n_classes) */
+            readonly tensor_3d: ArrayType<MatrixType<FloatType>>;
+        }>;
+        /** Base value(s) - single float or per-class array */
+        readonly base_value: VariantType<{
+            /** Single base value for regression or binary classification */
+            readonly single: FloatType;
+            /** Per-class base values for multi-class classification */
+            readonly per_class: VectorType<FloatType>;
+        }>;
+        /** Feature names */
+        readonly feature_names: ArrayType<StringType>;
+    }>;
+}>;
+/**
+ * SHAP result for MAPIE classifiers.
+ * Contains explanations for both class probabilities and prediction set size.
+ */
+export declare const MapieClassifierShapResultType: StructType<{
+    /** SHAP values for class probabilities (what drives each class probability) */
+    readonly class_probabilities: StructType<{
+        /** SHAP values - 2D matrix or 3D tensor depending on model type */
+        readonly shap_values: VariantType<{
+            /** 2D matrix for regression or binary classification (n_samples x n_features) */
+            readonly matrix_2d: MatrixType<FloatType>;
+            /** 3D tensor for multi-class classification (n_samples x n_features x n_classes) */
+            readonly tensor_3d: ArrayType<MatrixType<FloatType>>;
+        }>;
+        /** Base value(s) - single float or per-class array */
+        readonly base_value: VariantType<{
+            /** Single base value for regression or binary classification */
+            readonly single: FloatType;
+            /** Per-class base values for multi-class classification */
+            readonly per_class: VectorType<FloatType>;
+        }>;
+        /** Feature names */
+        readonly feature_names: ArrayType<StringType>;
+    }>;
+    /** SHAP values for prediction set size (what drives uncertainty) */
+    readonly prediction_set_size: StructType<{
+        /** SHAP values - 2D matrix or 3D tensor depending on model type */
+        readonly shap_values: VariantType<{
+            /** 2D matrix for regression or binary classification (n_samples x n_features) */
+            readonly matrix_2d: MatrixType<FloatType>;
+            /** 3D tensor for multi-class classification (n_samples x n_features x n_classes) */
+            readonly tensor_3d: ArrayType<MatrixType<FloatType>>;
+        }>;
+        /** Base value(s) - single float or per-class array */
+        readonly base_value: VariantType<{
+            /** Single base value for regression or binary classification */
+            readonly single: FloatType;
+            /** Per-class base values for multi-class classification */
+            readonly per_class: VectorType<FloatType>;
+        }>;
+        /** Feature names */
+        readonly feature_names: ArrayType<StringType>;
+    }>;
+}>;
+/**
+ * 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)
+ * @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>>;
+                }>;
+                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;
+    }>;
+}>], 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;
+    }>;
+}>>;
+/**
+ * Create a SHAP KernelExplainer for any model.
+ *
+ * Works with any model that has a predict method (NGBoost, GP, Torch, etc.).
+ * Requires background data for computing expected values.
+ *
+ * @param model - Any model blob
+ * @param X_background - Background data for computing expected values
+ * @returns SHAP KernelExplainer blob
+ */
+export declare const shap_kernel_explainer_create: import("@elaraai/east").PlatformDefinition<[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_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;
+    }>;
+    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 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 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;
+    }>;
+    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 mapie_interval_width: StructType<{
+        readonly data: BlobType;
+        readonly n_features: IntegerType;
+    }>;
+    readonly mapie_set_size: StructType<{
+        readonly data: BlobType;
+        readonly n_features: IntegerType;
+    }>;
+}>, MatrixType<FloatType>], 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;
+    }>;
+}>>;
+/**
+ * Compute SHAP values for samples.
+ *
+ * @param explainer - SHAP explainer blob
+ * @param X - Feature matrix to explain
+ * @param feature_names - Names of features
+ * @returns SHAP values, base value, and feature names
+ */
+export declare const shap_compute_values: import("@elaraai/east").PlatformDefinition<[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;
+    }>;
+}>, MatrixType<FloatType>, ArrayType<StringType>], StructType<{
+    /** SHAP values - 2D matrix or 3D tensor depending on model type */
+    readonly shap_values: VariantType<{
+        /** 2D matrix for regression or binary classification (n_samples x n_features) */
+        readonly matrix_2d: MatrixType<FloatType>;
+        /** 3D tensor for multi-class classification (n_samples x n_features x n_classes) */
+        readonly tensor_3d: ArrayType<MatrixType<FloatType>>;
+    }>;
+    /** Base value(s) - single float or per-class array */
+    readonly base_value: VariantType<{
+        /** Single base value for regression or binary classification */
+        readonly single: FloatType;
+        /** Per-class base values for multi-class classification */
+        readonly per_class: VectorType<FloatType>;
+    }>;
+    /** Feature names */
+    readonly feature_names: ArrayType<StringType>;
+}>>;
+/**
+ * Compute global feature importance from SHAP values.
+ *
+ * @param shap_values - SHAP values (2D matrix or 3D tensor)
+ * @param feature_names - Names of features
+ * @returns Feature importance with mean |SHAP| values
+ */
+export declare const shap_feature_importance: import("@elaraai/east").PlatformDefinition<[VariantType<{
+    /** 2D matrix for regression or binary classification (n_samples x n_features) */
+    readonly matrix_2d: MatrixType<FloatType>;
+    /** 3D tensor for multi-class classification (n_samples x n_features x n_classes) */
+    readonly tensor_3d: ArrayType<MatrixType<FloatType>>;
+}>, ArrayType<StringType>], 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>>;
+}>>;
+/**
+ * Type definitions for SHAP functions.
+ */
+export declare const ShapTypes: {
+    /** String vector type */
+    readonly StringVectorType: ArrayType<StringType>;
+    /** SHAP values variant type (2D or 3D) */
+    readonly ShapValuesType: VariantType<{
+        /** 2D matrix for regression or binary classification (n_samples x n_features) */
+        readonly matrix_2d: MatrixType<FloatType>;
+        /** 3D tensor for multi-class classification (n_samples x n_features x n_classes) */
+        readonly tensor_3d: ArrayType<MatrixType<FloatType>>;
+    }>;
+    /** SHAP base value variant type (single or per-class) */
+    readonly ShapBaseValueType: VariantType<{
+        /** Single base value for regression or binary classification */
+        readonly single: FloatType;
+        /** Per-class base values for multi-class classification */
+        readonly per_class: VectorType<FloatType>;
+    }>;
+    /** SHAP result type */
+    readonly ShapResultType: StructType<{
+        /** SHAP values - 2D matrix or 3D tensor depending on model type */
+        readonly shap_values: VariantType<{
+            /** 2D matrix for regression or binary classification (n_samples x n_features) */
+            readonly matrix_2d: MatrixType<FloatType>;
+            /** 3D tensor for multi-class classification (n_samples x n_features x n_classes) */
+            readonly tensor_3d: ArrayType<MatrixType<FloatType>>;
+        }>;
+        /** Base value(s) - single float or per-class array */
+        readonly base_value: VariantType<{
+            /** Single base value for regression or binary classification */
+            readonly single: FloatType;
+            /** Per-class base values for multi-class classification */
+            readonly per_class: 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;
+            }>;
+            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<{
+        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_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;
+        }>;
+        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 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 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;
+        }>;
+        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 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).
+     *
+     * @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 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;
+        }>;
+    }>], 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;
+        }>;
+    }>>;
+    /**
+     * Create a SHAP KernelExplainer for any model.
+     *
+     * Works with any model (NGBoost, GP, Torch, etc.). Requires background
+     * data for computing expected values.
+     *
+     * @example
+     * ```ts
+     * import { East, FloatType, MatrixType } from "@elaraai/east";
+     * import { Shap, NGBoost } from "@elaraai/east-py-datascience";
+     *
+     * const explain = East.function(
+     *     [NGBoost.Types.ModelBlobType, MatrixType(FloatType)],
+     *     Shap.Types.ShapModelBlobType,
+     *     ($, model, X_background) => {
+     *         return $.return(Shap.kernelExplainerCreate(model, X_background));
+     *     }
+     * );
+     * ```
+     */
+    readonly kernelExplainerCreate: import("@elaraai/east").PlatformDefinition<[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_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;
+        }>;
+        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 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 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;
+        }>;
+        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 mapie_interval_width: StructType<{
+            readonly data: BlobType;
+            readonly n_features: IntegerType;
+        }>;
+        readonly mapie_set_size: StructType<{
+            readonly data: BlobType;
+            readonly n_features: IntegerType;
+        }>;
+    }>, MatrixType<FloatType>], 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;
+        }>;
+    }>>;
+    /**
+     * Compute SHAP values for samples.
+     *
+     * @example
+     * ```ts
+     * import { East, FloatType, MatrixType, StringType, VectorType } from "@elaraai/east";
+     * import { Shap } from "@elaraai/east-py-datascience";
+     *
+     * const compute = East.function(
+     *     [Shap.Types.ShapModelBlobType, MatrixType(FloatType)],
+     *     Shap.Types.ShapResultType,
+     *     ($, explainer, X) => {
+     *         const feature_names = $.let(["feature_a", "feature_b"]);
+     *         const result = $.let(Shap.computeValues(explainer, X, feature_names));
+     *         // result.values => SHAP values matrix
+     *         // result.base_value => expected value
+     *         return $.return(result);
+     *     }
+     * );
+     * ```
+     */
+    readonly computeValues: import("@elaraai/east").PlatformDefinition<[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;
+        }>;
+    }>, MatrixType<FloatType>, ArrayType<StringType>], StructType<{
+        /** SHAP values - 2D matrix or 3D tensor depending on model type */
+        readonly shap_values: VariantType<{
+            /** 2D matrix for regression or binary classification (n_samples x n_features) */
+            readonly matrix_2d: MatrixType<FloatType>;
+            /** 3D tensor for multi-class classification (n_samples x n_features x n_classes) */
+            readonly tensor_3d: ArrayType<MatrixType<FloatType>>;
+        }>;
+        /** Base value(s) - single float or per-class array */
+        readonly base_value: VariantType<{
+            /** Single base value for regression or binary classification */
+            readonly single: FloatType;
+            /** Per-class base values for multi-class classification */
+            readonly per_class: VectorType<FloatType>;
+        }>;
+        /** Feature names */
+        readonly feature_names: ArrayType<StringType>;
+    }>>;
+    /**
+     * Compute global feature importance from SHAP values.
+     *
+     * @example
+     * ```ts
+     * import { East, FloatType, MatrixType, StringType, VectorType } from "@elaraai/east";
+     * import { Shap } from "@elaraai/east-py-datascience";
+     *
+     * const importance = East.function(
+     *     [Shap.Types.ShapModelBlobType, MatrixType(FloatType)],
+     *     Shap.Types.FeatureImportanceType,
+     *     ($, explainer, X) => {
+     *         const feature_names = $.let(["feature_a", "feature_b"]);
+     *         const shap_result = $.let(Shap.computeValues(explainer, X, feature_names));
+     *         return $.return(Shap.featureImportance(shap_result.values, feature_names));
+     *     }
+     * );
+     * ```
+     */
+    readonly featureImportance: import("@elaraai/east").PlatformDefinition<[VariantType<{
+        /** 2D matrix for regression or binary classification (n_samples x n_features) */
+        readonly matrix_2d: MatrixType<FloatType>;
+        /** 3D tensor for multi-class classification (n_samples x n_features x n_classes) */
+        readonly tensor_3d: ArrayType<MatrixType<FloatType>>;
+    }>, ArrayType<StringType>], 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>>;
+    }>>;
+    /** Type definitions */
+    readonly Types: {
+        /** String vector type */
+        readonly StringVectorType: ArrayType<StringType>;
+        /** SHAP values variant type (2D or 3D) */
+        readonly ShapValuesType: VariantType<{
+            /** 2D matrix for regression or binary classification (n_samples x n_features) */
+            readonly matrix_2d: MatrixType<FloatType>;
+            /** 3D tensor for multi-class classification (n_samples x n_features x n_classes) */
+            readonly tensor_3d: ArrayType<MatrixType<FloatType>>;
+        }>;
+        /** SHAP base value variant type (single or per-class) */
+        readonly ShapBaseValueType: VariantType<{
+            /** Single base value for regression or binary classification */
+            readonly single: FloatType;
+            /** Per-class base values for multi-class classification */
+            readonly per_class: VectorType<FloatType>;
+        }>;
+        /** SHAP result type */
+        readonly ShapResultType: StructType<{
+            /** SHAP values - 2D matrix or 3D tensor depending on model type */
+            readonly shap_values: VariantType<{
+                /** 2D matrix for regression or binary classification (n_samples x n_features) */
+                readonly matrix_2d: MatrixType<FloatType>;
+                /** 3D tensor for multi-class classification (n_samples x n_features x n_classes) */
+                readonly tensor_3d: ArrayType<MatrixType<FloatType>>;
+            }>;
+            /** Base value(s) - single float or per-class array */
+            readonly base_value: VariantType<{
+                /** Single base value for regression or binary classification */
+                readonly single: FloatType;
+                /** Per-class base values for multi-class classification */
+                readonly per_class: 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;
+                }>;
+                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<{
+            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_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;
+            }>;
+            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 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 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;
+            }>;
+            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 mapie_interval_width: StructType<{
+                readonly data: BlobType;
+                readonly n_features: IntegerType;
+            }>;
+            readonly mapie_set_size: StructType<{
+                readonly data: BlobType;
+                readonly n_features: IntegerType;
+            }>;
+        }>;
+    };
+};
+//# sourceMappingURL=shap.d.ts.map